Package com.tangosol.util

Class MultiBinaryLongMap.PrimaryBinaryLongMap.DelegatingPrimaryBinaryLongMap

    • Field Detail

      • f_lockXMaster

        protected final Lock f_lockXMaster
        The (exclusive) lock that protects the data-structures for the MultiBinaryLongMap.

      • f_lockSThis

        protected final Lock f_lockSThis
        The shared lock that protects the logical contents of the primary BinaryLongMap.

      • f_lockXThis

        protected final Lock f_lockXThis
        The exclusive lock that protects the logical contents of the primary BinaryLongMap.

    • Constructor Detail

      • DelegatingPrimaryBinaryLongMap

        public DelegatingPrimaryBinaryLongMap​(BinaryLongMap blmKeyTree,
                                      MultiBinaryLongMap.LongStorage store,
                                      ReentrantReadWriteLock rwLockMaster)
        Construct a DelegatingPrimaryBinaryLongMap.
        Parameters:
        blmKeyTree - the BinaryLongMap that holds the keys for this map
        store - the LongStorage that holds the values for this map
        rwLockMaster - the "master" ReentrantReadWriteLock protecting the underlying MLBM BRT and LongStorage structures

    • Method Detail

      • get

        public long get​(Binary binKey)
        Find the specified key in the map and return the value associated with it.
        Specified by:
        get in interface BinaryLongMap
        Overrides:
        get in class MultiBinaryLongMap.AbstractDelegateBinaryLongMap
        Parameters:
        binKey - a Binary key
        Returns:
        the value associated with the specified key, or 0L if the specified key is not in the map

      • 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

      • 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

      • 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

      • 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

      • doPut

        protected boolean doPut​(Binary binKey,
                        long lValue,
                        boolean fOnlyIfAbsent)
        Helper method for put(com.tangosol.util.Binary, long) and putIfAbsent(com.tangosol.util.Binary, long) operations.
        Parameters:
        binKey - the key to add to the map
        lValue - the value to be associated
        fOnlyIfAbsent - true iff the key/value should be associated only if the key was previously absent
        Returns:
        true iff the contents of the binary long map were changed

      • addValue

        protected void addValue​(Binary binKey,
                        long lValueNew)
        Add the specified key to the BinaryLongMap, and associate the specified value with it in the primary BLM.

        The caller is responsible for holding the exclusive lock protecting the key tree and LongStorage.

        Parameters:
        binKey - the key to add to the BinaryLongMap
        lValueNew - the new value to associate with the key

      • removeValue

        protected boolean removeValue​(Binary binKey,
                              long lValue)
        Remove the specified key from the BinaryLongMap, optionally performing the operation only if the value currently associated with the key matches the passed "old" value.

        The caller is responsible for holding the exclusive lock protecting the key tree and LongStorage.

        Parameters:
        binKey - the key
        lValue - the value that is assumed to be currently associated with the key, or 0 if the key should be removed unconditionally
        Returns:
        true iff the operation affected a change to the BinaryLongMap

      • checkCompaction

        protected void checkCompaction()
        Check to see whether or not the LongStorage slots should be compacted.

        The caller is responsible for holding the exclusive lock protecting the key tree and LongStorage.