private void addServerIPAndHostEntries() {
    String hostName = serverConfigurationInformation.getHostName();
    String ipAddress = serverConfigurationInformation.getIpAddress();
    if (hostName != null && !"".equals(hostName)) {
      Entry entry = new Entry(SynapseConstants.SERVER_HOST);
      entry.setValue(hostName);
      synapseConfiguration.addEntry(SynapseConstants.SERVER_HOST, entry);
    }

    if (ipAddress != null && !"".equals(ipAddress)) {
      Entry entry = new Entry(SynapseConstants.SERVER_IP);
      entry.setValue(ipAddress);
      if (synapseConfiguration.getAxisConfiguration().getTransportsIn() != null) {
        Map<String, TransportInDescription> transportInConfigMap =
            synapseConfiguration.getAxisConfiguration().getTransportsIn();
        if (transportInConfigMap != null) {
          TransportInDescription transportInDescription = transportInConfigMap.get("http");
          if (transportInDescription != null) {
            Parameter bindAddressParam = transportInDescription.getParameter("bind-address");
            if (bindAddressParam != null) {
              entry.setValue(bindAddressParam.getValue());
            }
          }
        }
      }
      synapseConfiguration.addEntry(SynapseConstants.SERVER_IP, entry);
    }
  }
예제 #2
0
  @Override
  public V put(final K key, final V value) {
    final Entry<K, V>[] table = this.table;
    final int hash = key.hashCode();
    final int index = HashUtil.indexFor(hash, table.length, shift, mask);

    for (Entry<K, V> e = table[index]; e != null; e = e.hashNext) {
      final K entryKey;
      if (e.keyHash == hash && ((entryKey = e.key) == key || entryKey.equals(key))) {
        moveToTop(e);
        return e.setValue(value);
      }
    }

    final Entry<K, V> e = new Entry<K, V>(key, value);
    e.hashNext = table[index];
    table[index] = e;
    final Entry<K, V> top = this.top;
    e.next = top;
    if (top != null) {
      top.previous = e;
    } else {
      back = e;
    }
    this.top = e;
    size = size + 1;

    if (removeEldestEntry(back)) {
      remove(back.key);
    } else if (size > capacity) {
      rehash(HashUtil.nextCapacity(capacity));
    }
    return null;
  }
예제 #3
0
 /**
  * increments every value in the sequence by (what?).. <br>
  * you can decrement if you want to. But values below 0 will be REJECTED. As will values above 255
  *
  * @param byWhat this much!
  * @throws if you give a bogus value
  */
 public void increment(int byWhat) throws Exception {
   for (Entry e : compressedSequence) {
     e.setValue(e.getValue() + byWhat);
     if (e.getValue() > 255 || e.getValue() < 0) {
       throw new Exception("too big value");
     }
   }
 }
예제 #4
0
 private Map<String, String> sanitizeMap() {
   Map<String, String> sanitized = new HashMap<String, String>(map);
   for (Entry<String, String> entry : sanitized.entrySet()) {
     if (entry.getKey().startsWith(SENSITIVE_PREFIX)) {
       entry.setValue(SENSITIVE_MASK);
     }
   }
   return sanitized;
 }
 @Override
 public List<Entry> marshal(Map<String, ? extends Set<String>> map) throws Exception {
   List<Entry> entryList = new ArrayList<StringSetMapAdapter.Entry>();
   for (Map.Entry<String, ? extends Set<String>> mapEntry : map.entrySet()) {
     for (String value : mapEntry.getValue()) {
       Entry entry = new Entry();
       entry.setKey(mapEntry.getKey());
       entry.setValue(value);
       entryList.add(entry);
     }
   }
   return entryList;
 }
예제 #6
0
 @Override
 public V put(K key, V value) {
   int index = index(key);
   Entry<K, V> e = find(index, key);
   if (e != null) {
     return e.setValue(value);
   }
   e = new Entry<K, V>(key, value);
   if (table[index] == null) {
     table[index] = e;
   } else {
     e.next = table[index];
     table[index] = e;
   }
   size++;
   return null;
 }
예제 #7
0
  public V put(final int key, final V value) {
    final Entry<V>[] table = this.table;
    final int index = HashUtil.indexFor(key, table.length, mask);

    for (Entry<V> e = table[index]; e != null; e = e.hashNext) {
      if (e.key == key) {
        return e.setValue(value);
      }
    }

    final Entry<V> e = new Entry<>(key, value);
    e.hashNext = table[index];
    table[index] = e;
    size += 1;

    if (size > capacity) {
      rehash(HashUtil.nextCapacity(capacity));
    }
    return null;
  }
예제 #8
0
    public Object put(Comparator comparator, Object key, Object val) {
      Object oldVal;

      int search = binarySearch(this, 0, size, key, comparator);
      if (search > -1) {
        Entry entry = get(search);
        oldVal = entry.getValue();
        entry.setValue(val);
      } else if (size < capacity) {
        oldVal = null;

        search = -(search + 1);
        insert(search, key, val);

      } else {
        Leaf next = Leaf.newInstance(capacity);

        int halfSize = size / 2;

        shallowCopy(this, halfSize, next, 0, halfSize);
        clear(halfSize, size);

        size = halfSize;
        next.size = halfSize;

        if (compare(comparator, key, next.firstKey()) < 0) {
          put(comparator, key, val);
        } else {
          next.put(comparator, key, val);
        }

        next.next = this.next;
        this.next = next;

        oldVal = Node.Sentinal.SPLIT;
      }

      return oldVal;
    }
  /**
   * This method adds or replaces a Key,Value.
   *
   * @param key The key of an Entry object.
   * @param value The value of the Entry object.
   * @return Returns the old value of the key.
   */
  public V put(K key, V value) {
    System.nanoTime();
    int index = theHasher(key);

    if (array[index] == null) {
      array[index] = new LinkedList<Entry<K, V>>();
      size++;
    }
    for (Entry<K, V> nextItem : array[index]) {
      if (nextItem.getKey().equals(key)) {
        V temp = nextItem.getValue();
        nextItem.setValue(value);
        return temp; // Previous value is returned.
      }
    }
    array[index].addFirst(new Entry<K, V>(key, value)); // addFirst method from Java LinkedList
    numElements++;
    long sysTime = System.nanoTime();
    if (printTimes == true) {
      System.out.print("This put process took " + sysTime + " nanoseconds." + "\n");
    }
    return null; // No previous value to return.
  }
예제 #10
0
  public void put(K key, V value) {
    int index = key.hashCode();

    // Wir können uns an dieser Stelle sicher sein, dass das Objekt eine
    // LinkedList mit entsprechendem Entry ist,
    // da wir keinen Zugriff von außen auf das Array erlauben
    @SuppressWarnings("unchecked")
    LinkedList<Entry<K, V>> list = (LinkedList<Entry<K, V>>) this.values[index];

    // Wenn die Liste noch nicht existiert
    if (list == null) {
      list = new LinkedList<Entry<K, V>>();
      this.values[index] = list;
      n--;
    }

    // Wenn das Element mit dem gegeben Schlüssel existiert, dann überschreiben den Wert
    boolean containsKey = false;
    for (Entry<K, V> e : list) {
      if (e.getKey().equals(key)) {
        e.setValue(value);
        containsKey = true;
        break;
      }
    }

    // füge an das Ende der Liste ein Entry Element bestehend aus Wert und Punkt ein, wenn
    // das Element noch nicht existiert.
    if (containsKey == false) {
      Entry<K, V> item = new Entry<K, V>(key, value);
      list.add(item);
      entrySet.add(item);
      n++;
    }

    size++;
  }
예제 #11
0
  /**
   * priavate! Why is this method so long? Because it has to deal with a lot of checking and
   * recompression to make sure that everything is compressed correctly and in the right place.
   *
   * @param entryIndex see step 1
   * @param indexWithinEntry see step1
   * @param val the value, just like step 1 which you should have looked at
   * @throws Exception same as step 1
   */
  private void setStepTwo(int entryIndex, int indexWithinEntry, int val) throws Exception {
    Entry previousEntry = null;

    Entry currentEntry = compressedSequence.get(entryIndex);

    if (entryIndex > 0) {
      previousEntry = compressedSequence.get(entryIndex - 1);
    }
    Entry nextEntry = null;
    if (entryIndex < compressedSequence.size() - 1) {
      nextEntry = compressedSequence.get(entryIndex + 1);
    }
    // case 1
    if (currentEntry.getNumber() == 1) {

      currentEntry.setValue(val);

      Entry firstCompare = compareTwo(previousEntry, currentEntry);
      Entry secondCompare = compareTwo(currentEntry, nextEntry);

      if (firstCompare != null && secondCompare != null) {
        Entry thirdCompare = compareTwo(firstCompare, secondCompare);
        compressedSequence.set(entryIndex, thirdCompare);
        compressedSequence.remove(entryIndex - 1);
        // since we've shifted one to the left
        compressedSequence.remove(entryIndex);
      } else if (secondCompare != null) {
        compressedSequence.set(entryIndex, secondCompare);
        compressedSequence.remove(entryIndex + 1);
      } else if (firstCompare != null) {
        compressedSequence.set(entryIndex, firstCompare);
        compressedSequence.remove(entryIndex - 1);
      }

    }
    // case 2
    else {
      // these are sub-entries

      Entry previousStuff = null;
      Entry nextStuff = null;
      Entry userInsertedEntry = null;
      for (int i = 0; i < currentEntry.getNumber(); i++) {
        if (i == indexWithinEntry) {
          if (i != 0) {

            previousStuff = new Entry(i, currentEntry.getValue());
          }
          if (i < currentEntry.getNumber() - 1) {

            nextStuff = new Entry(currentEntry.getNumber() - i - 1, currentEntry.getValue());
          }
          userInsertedEntry = new Entry(1, val);
        }
      }
      if (previousStuff != null && nextStuff != null) {
        compressedSequence.set(entryIndex, userInsertedEntry);
        compressedSequence.add(entryIndex + 1, nextStuff);
        compressedSequence.add(entryIndex, previousStuff);
      } else if (previousStuff != null) {
        Entry one = compareTwo(nextEntry, userInsertedEntry);
        if (one != null) {
          compressedSequence.set(entryIndex + 1, one);
          currentEntry.setNumber(currentEntry.getNumber() - 1);
        } else {
          compressedSequence.set(entryIndex, userInsertedEntry);
          compressedSequence.add(entryIndex, previousStuff);
        }
      } else if (nextStuff != null) {
        Entry two = compareTwo(previousEntry, userInsertedEntry);
        if (two != null) {
          compressedSequence.set(entryIndex - 1, two);
          currentEntry.setNumber(currentEntry.getNumber() - 1);
        } else {
          compressedSequence.set(entryIndex, userInsertedEntry);
          compressedSequence.add(entryIndex + 1, nextStuff);
        }
      } else {
        // this is mathematically impossible because
        // it is handled above, in case 1
      }
    }
  }
예제 #12
0
 @Override
 public V setValue(V value) {
   return ent.setValue(value);
 }
예제 #13
0
  public V remove(Object key) {
    Entry<K, V>[] tab = this.table;

    if (key != null) {
      int hash = key.hashCode();
      int index = (hash & 0x7fffffff) % tab.length;

      for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) {
        V entryValue = e.get();

        if (entryValue == null) {
          // Clean up after a cleared Reference.
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[index] = e.next;
          }
          this.count--;
        } else if (e.hash == hash && key.equals(e.key)) {
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[index] = e.next;
          }
          this.count--;

          e.setValue(null);
          return (entryValue == KeyFactory.NULL) ? null : entryValue;
        } else {
          prev = e;
        }
      }
    } else {
      for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) {
        V entryValue = e.get();

        if (entryValue == null) {
          // Clean up after a cleared Reference.
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[0] = e.next;
          }
          this.count--;
        } else if (e.key == null) {
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[0] = e.next;
          }
          this.count--;

          e.setValue(null);
          return (entryValue == KeyFactory.NULL) ? null : entryValue;
        } else {
          prev = e;
        }
      }
    }

    return null;
  }
예제 #14
0
  public V put(K key, V value) {
    if (value == null) {
      value = (V) KeyFactory.NULL;
    }

    // Makes sure the key is not already in the HashMap.
    Entry<K, V>[] tab = this.table;
    int hash;
    int index;

    if (key != null) {
      hash = key.hashCode();
      index = (hash & 0x7fffffff) % tab.length;
      for (Entry<K, V> e = tab[index], prev = null; e != null; e = e.next) {
        V entryValue = e.get();

        if (entryValue == null) {
          // Clean up after a cleared Reference.
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[index] = e.next;
          }
          this.count--;
        } else if (e.hash == hash && key.equals(e.key)) {
          e.setValue(value);
          return (entryValue == KeyFactory.NULL) ? null : entryValue;
        } else {
          prev = e;
        }
      }
    } else {
      hash = 0;
      index = 0;
      for (Entry<K, V> e = tab[0], prev = null; e != null; e = e.next) {
        V entryValue = e.get();

        if (entryValue == null) {
          // Clean up after a cleared Reference.
          this.modCount++;
          if (prev != null) {
            prev.next = e.next;
          } else {
            tab[0] = e.next;
          }
          this.count--;
        } else if (e.key == null) {
          e.setValue(value);
          return (entryValue == KeyFactory.NULL) ? null : entryValue;
        } else {
          prev = e;
        }
      }
    }

    this.modCount++;

    if (this.count >= this.threshold) {
      // Cleanup the table if the threshold is exceeded.
      cleanup();
    }

    if (this.count >= this.threshold) {
      // Rehash the table if the threshold is still exceeded.
      rehash();
      tab = this.table;
      index = (hash & 0x7fffffff) % tab.length;
    }

    // Creates the new entry.
    Entry<K, V> e = newEntry(hash, key, (V) value, tab[index]);
    tab[index] = e;
    this.count++;
    return null;
  }
예제 #15
0
 /**
  * Sets the value of the entry, and returns the former value. The value is {@link #validateValue
  * validated}.
  *
  * @param entry the entry.
  * @param value the value.
  * @return the former value, or <code>null</code>.
  */
 protected V putEntry(Entry<K, V> entry, V value) {
   return entry.setValue(value);
 }