Package com.tangosol.util

Class MultiBinaryLongMap.DelegatingBinaryLongMap

java.lang.Object
com.tangosol.util.MultiBinaryLongMap.AbstractDelegateBinaryLongMap
com.tangosol.util.MultiBinaryLongMap.DelegatingBinaryLongMap
All Implemented Interfaces:
BinaryLongMap
Enclosing class:
MultiBinaryLongMap
public static class MultiBinaryLongMap.DelegatingBinaryLongMap extends MultiBinaryLongMap.AbstractDelegateBinaryLongMap
An implementation of BinaryLongMap that uses another BinaryLongMap to store its keys and one index of a LongStorage to store its values. This allows a number of BinaryLongMap instances to be created that share a single other BinaryLongMap (e.g. BinaryRadixTree) instance.

This implementation differs substantially from the BinaryLongMap interface's contract in the following ways:

  1. There is a concept of a primary BinaryLongMap instance, which owns the keys in the underlying BinaryRadixTree;
  2. Only the primary can add and remove keys;
  3. Other instances besides the primary will generate exceptions if they attempt to add keys that aren't already in the primary, and will store zero values when they attempt to remove keys (which will have the effect of removing that key from the keys() iterator for the instance);
  4. The key iterator for the non-primary instances will only iterate keys with non-zero values (which is to be expected);
  5. Since the primary instance can remove keys, and since that removal will also remove the same keys from all other dependent instances, consumers of the dependent instances should use a BinaryLongMapListener to listen to changes to the primary instance.
In each of these cases, it should be apparent that using dependent instances requires some knowledge of the specific implementation behavior of the DelegatingBinaryLongMap, and thus the substitutability of DelegatingBinaryLongMap for BinaryRadixTree cannot be done blindly.

  • Constructor Details

    • DelegatingBinaryLongMap

      public DelegatingBinaryLongMap(BinaryLongMap blm, MultiBinaryLongMap.LongStorage store, int iIndex)
      Construct a DelegatingBinaryLongMap.
      Parameters:
      blm - the BinaryLongMap that holds the keys for this map
      store - the LongStorage that holds the values for this map
      iIndex - the index into the LongStorage for this map; must be > 0

  • Method Details

    • put

      public void put(Binary binKey, long lValue)
      Blindly store the passed value for the specified key, adding the key if it is not already in the map, or replacing the current value if the key is in the map.

      Note that associating the value zero with a key is analogous to removing the key.

      Parameters:
      binKey - the Binary key to add or update
      lValue - the value to associate with the key

    • putIfAbsent

      public boolean putIfAbsent(Binary binKey, long lValue)
      Store the passed value for the specified key, only if the key does not currently exist in the map.

      Note that associating the value zero with a key using this method will have no effect, since were that key already present, there would be no change, and were it not present, the value zero is analogous to removing the key, which again is no change (since it is not present).

      Parameters:
      binKey - a Binary key
      lValue - the new value to associate with the passed key
      Returns:
      true iff the key was not present in the map, and now it is present in the map associated with the passed value

    • replace

      public boolean replace(Binary binKey, long lValueOld, long lValueNew)
      Store the passed "new" value for the specified key, only if the current value associated with the specified key is the same as the specified "old" value.

      Note that replacing the value of zero is analogous to putIfAbsent, and associating the value zero with a key using this method is the same as remove passing the old value to match.

      Parameters:
      binKey - a Binary key
      lValueOld - the assumed old value to replace
      lValueNew - the new value to associate with the passed key
      Returns:
      true iff the key was associated with the passed "old" value, and now it is associated with the passed "new" value

    • remove

      public void remove(Binary binKey)
      Blindly remove the specified Binary key from the map.
      Parameters:
      binKey - a Binary key

    • remove

      public boolean remove(Binary binKey, long lValue)
      Remove the specified Binary key from the map iff it exists in the map and is associated with the specified value.

      Note that removing an association whose value is zero has no effect.

      Parameters:
      binKey - a Binary key
      lValue - the value that the key must have in order to be removed
      Returns:
      true iff the map contained the key, it was associated with the specified value, and has now been removed

    • clear

      public void clear()
      Initialize the map to an empty state.

    • size

      public int size()
      Determine the size of the map.
      Returns:
      the number of unique keys stored in the map