Package com.tangosol.net.cache

Class CompactSerializationCache

    • Field Detail

      • DEFAULT_PRUNE

        public static final double DEFAULT_PRUNE
        By default, when the cache prunes, it reduces its entries to this percentage.
        See Also:
        Constant Field Values

      • m_blmExpiry

        protected BinaryLongMap m_blmExpiry
        The BinaryLongMap holding the expiry information for the entries in the Cache Map.

      • m_blmTouchTime

        protected BinaryLongMap m_blmTouchTime
        The BinaryLongMap holding the touch-time information for the entries in the Cache Map.

      • m_blmTouchCount

        protected BinaryLongMap m_blmTouchCount
        The BinaryLongMap holding the touch-count information for the entries in the Cache Map.

      • m_blmUnits

        protected BinaryLongMap m_blmUnits
        The BinaryLongMap holding the units for each entry in the Cache Map.

      • f_store

        protected final BinaryStore.KeySetAware f_store
        The BinaryStore.KeySetAware that this CompactSerializationCache uses to store data.

      • m_cMaxUnits

        protected long m_cMaxUnits
        Maximum number of units to manage in the cache.

      • m_dflPruneLevel

        protected double m_dflPruneLevel
        The percentage of the total number of units that will remain after the cache manager prunes the cache (i.e. this is the "low water mark" value); this value is in the range 0.0 to 1.0.

      • m_cPruneUnits

        protected long m_cPruneUnits
        The number of units to prune the cache down to.

      • f_atomicCurUnits

        protected final AtomicLong f_atomicCurUnits
        Current number of units to in the cache.

      • m_nUnitFactor

        protected int m_nUnitFactor
        The unit factor.

      • m_cExpiryDelay

        protected int m_cExpiryDelay
        The default expiry int milliseconds, or 0 for no timeout.

      • m_ldtNextExpiryCheck

        protected long m_ldtNextExpiryCheck
        The time that the last cache-wide expiry check was performed.

      • m_listenerSupport

        protected MapListenerSupport m_listenerSupport
        The MapListenerSupport object.

      • m_fBlind

        protected boolean m_fBlind
        True iff this Map should operate in blind mode. Blind mode allows a Map implementation to forgo the often costly parts of the Map API, in particular returning the previous value for both remove and put operations. Additionally, for CCMs that dispatch events fetching the previous value can also be avoided.

      • f_mblm

        protected final MultiBinaryLongMap f_mblm
        The MultiBinaryLongMap used for compact key (and entry-attribute) storage.

      • f_atomicExpiringMutex

        protected final AtomicBoolean f_atomicExpiringMutex
        The mutex acquired by the thread performing the cache-wide expiration.

      • f_atomicEvictingMutex

        protected final AtomicBoolean f_atomicEvictingMutex
        The mutex acquired by the thread performing the cache eviction.

      • f_fBinary

        protected final boolean f_fBinary
        True iff the keys and values are known to be Binary (and not require conversion).

      • f_loader

        protected final ClassLoader f_loader
        The ClassLoader to use for deserialization of non-Binary keys/values.

      • f_ldtEpoch

        protected final long f_ldtEpoch
        The time of the start of the "epoch", relative to which internal time-offsets are stored.

    • Constructor Detail

      • CompactSerializationCache

        public CompactSerializationCache​(BinaryStoreManager mgr,
                                 ClassLoader loader)
        Construct a CompactSerializationCache using the specified BinaryStoreManager and classloader.
        Parameters:
        mgr - the BinaryStoreManager to use to create the BinaryStore
        loader - the ClassLoader to use for deserialization

      • CompactSerializationCache

        public CompactSerializationCache​(BinaryStoreManager mgr,
                                 boolean fBinary)
        Construct a CompactSerializationCache using the specified BinaryStoreManager, optionally storing only Binary keys and values
        Parameters:
        mgr - the BinaryStoreManager to use to create the BinaryStore
        fBinary - true iff only Binary keys and values are to be stored

      • CompactSerializationCache

        protected CompactSerializationCache​(BinaryStoreManager mgr,
                                    ClassLoader loader,
                                    boolean fBinary)
        Construct a CompactSerializationCache using the specified BinaryStoreManager.
        Parameters:
        mgr - the BinaryStoreManager to use to create the BinaryStore
        loader - the ClassLoader to use for deserialization
        fBinary - true iff only Binary keys and values are to be stored

    • Method Detail

      • getBinaryStore

        public BinaryStore.KeySetAware getBinaryStore()
        Returns the BinaryStore that this map uses for its storage.
        Returns:
        the BinaryStore

      • getClassLoader

        public ClassLoader getClassLoader()
        Return the configured ClassLoader, or null if none is configured.
        Returns:
        the classloader to use for deserialization, or null

      • isBinaryMap

        public boolean isBinaryMap()
        Determine if the keys and values in this map are known to be all Binary.
        Returns:
        true if all keys and values will be Binary to start with, and thus will not require conversion

      • getExpiryMap

        public BinaryLongMap getExpiryMap()
        Return the BinaryLongMap associating the entries in this cache map with their corresponding expiry.

        Note: it is legal for an expiry to be 0 (meaning no-expiry), but the contract of the BinaryLongMap considers 0 to be missing, so operations such as size() and keys() on the returned BLM will not reflect the entire set of keys in this cache

        Returns:
        the BinaryLongMap holding the expiry information

      • setExpiryMap

        protected void setExpiryMap​(BinaryLongMap blmExpiry)
        Set the BinaryLongMap to use to associate the entries in this cache map with their corresponding expiry.
        Parameters:
        blmExpiry - the BinaryLongMap to use to hold the expiry information

      • getKeyMap

        protected BinaryLongMap getKeyMap()
        Return a BinaryLongMap whose values have no meaning, but whose keys can be used internally to detect the presence of an entry in the cache map.

        Note: the returned BinaryLongMap may not be mutated.

        Returns:
        a BinaryLongMap containing all keys in this CacheMap, mapped to an unspecified value

      • getTouchTimeMap

        public BinaryLongMap getTouchTimeMap()
        Return the BinaryLongMap associating the entries in this cache map with their corresponding last "touch" time. A "touch" is any access (read or write) to an entry.
        Returns:
        the BinaryLongMap holding the touch-time information

      • setTouchTimeMap

        protected void setTouchTimeMap​(BinaryLongMap blmTouch)
        Return the BinaryLongMap to use to associate the entries in this cache map with their corresponding last "touch" time. A "touch" is any access (read or write) to an entry.
        Parameters:
        blmTouch - the BinaryLongMap holding the touch-time information

      • getTouchCountMap

        public BinaryLongMap getTouchCountMap()
        Return the BinaryLongMap associating the entries in this cache map with their corresponding touch count. A "touch" is any access (read or write) to an entry.
        Returns:
        the BinaryLongMap holding the touch count information

      • setTouchCountMap

        protected void setTouchCountMap​(BinaryLongMap blmTouch)
        Return the BinaryLongMap to use to associate the entries in this cache map with their corresponding "touch" count. A "touch" is any access (read or write) to an entry.
        Parameters:
        blmTouch - the BinaryLongMap holding the touch count information

      • getUnitsMap

        public BinaryLongMap getUnitsMap()
        Return the BinaryLongMap associating the entries in this cache map with their size in "units".
        Returns:
        the BinaryLongMap holding the units

      • setUnitsMap

        protected void setUnitsMap​(BinaryLongMap blmUnits)
        Set the BinaryLongMap to use to associate the entries in this cache map with their size in "units".
        Parameters:
        blmUnits - the BinaryLongMap to use for storing the units

      • hasListeners

        protected boolean hasListeners()
        Determine if the cache map has any listeners at all.
        Returns:
        true iff this cache map has at least one MapListener

      • getCacheStatistics

        public CacheStatistics getCacheStatistics()
        Returns the CacheStatistics for this cache.

        Note: this method is invoked reflectively by the CacheModel

        Returns:
        a CacheStatistics object

      • isBlind

        public boolean isBlind()
        Return whether this CompactSerializationCache instance is in blind mode. Blind mode allows this Map implementation to forgo the often costly parts of the Map API, in particular returning the previous value for both remove and put operations.
        Returns:
        whether this CompactSerializationCache is operating in a blind mode

      • setBlind

        public void setBlind​(boolean fBlind)
        Set whether this CompactSerializationCache instance should operate under a blind mode.
        Parameters:
        fBlind - whether this CompactSerializationCache should operate under a blind mode

      • size

        public int size()
        Returns the number of key-value mappings in this map.
        Specified by:
        size in interface Map
        Overrides:
        size in class AbstractKeyBasedMap
        Returns:
        the number of key-value mappings in this map

      • containsKey

        public boolean containsKey​(Object oKey)
        Returns true if this map contains a mapping for the specified key.
        Specified by:
        containsKey in interface Map
        Overrides:
        containsKey in class AbstractKeyBasedMap
        Returns:
        true if this map contains a mapping for the specified key, false otherwise.

      • containsValue

        public boolean containsValue​(Object oValue)
        Returns true if this Map maps one or more keys to the specified value.
        Specified by:
        containsValue in interface Map
        Overrides:
        containsValue in class AbstractKeyBasedMap
        Returns:
        true if this Map maps one or more keys to the specified value, false otherwise

      • get

        public Object get​(Object oKey)
        Returns the value to which this map maps the specified key.
        Specified by:
        get in interface Map
        Specified by:
        get in class AbstractKeyBasedMap
        Parameters:
        oKey - the key object
        Returns:
        the value to which this map maps the specified key, or null if the map contains no mapping for this key

      • remove

        public Object remove​(Object oKey)
        Removes the mapping for this key from this map if present. Expensive: updates both the underlying cache and the local cache.
        Specified by:
        remove in interface Map
        Overrides:
        remove in class AbstractKeyBasedMap
        Parameters:
        oKey - key whose mapping is to be removed from the map
        Returns:
        previous value associated with specified key, or null if there was no mapping for key. A null return can also indicate that the map previously associated null with the specified key, if the implementation supports null values.

      • put

        public Object put​(Object oKey,
                  Object oValue)
        Associates the specified value with the specified key in this map.
        Specified by:
        put in interface CacheMap
        Specified by:
        put in interface Map
        Overrides:
        put in class AbstractKeyBasedMap
        Parameters:
        oKey - key with which the specified value is to be associated
        oValue - value to be associated with the specified key
        Returns:
        previous value associated with specified key, or null if there was no mapping for key

      • put

        public Object put​(Object oKey,
                  Object oValue,
                  long cExpiry)
        Associates the specified value with the specified key in this cache. If the cache previously contained a mapping for this key, the old value is replaced. This variation of the CacheMap.put(Object oKey, Object oValue) method allows the caller to specify an expiry (or "time to live") for the cache entry.
        Specified by:
        put in interface CacheMap
        Parameters:
        oKey - key with which the specified value is to be associated
        oValue - value to be associated with the specified key
        cExpiry - the number of milliseconds until the cache entry will expire, also referred to as the entry's "time to live"; pass CacheMap.EXPIRY_DEFAULT to use the cache's default time-to-live setting; pass CacheMap.EXPIRY_NEVER to indicate that the cache entry should never expire; this milliseconds value is not a date/time value, such as is returned from System.currentTimeMillis()
        Returns:
        previous value associated with specified key, or null if there was no mapping for key. A null return can also indicate that the map previously associated null with the specified key, if the implementation supports null values

      • instantiateKeySet

        protected Set instantiateKeySet()
        Factory pattern: Create a Set that represents the keys in the Map
        Overrides:
        instantiateKeySet in class AbstractKeyBasedMap
        Returns:
        a new instance of Set that represents the keys in the Map

      • iterateKeys

        protected Iterator iterateKeys()
        Create an iterator over the keys in this Map. The Iterator must support remove() if the Map supports removal.
        Specified by:
        iterateKeys in class AbstractKeyBasedMap
        Returns:
        a new instance of an Iterator over the keys in this Map

      • removeBlind

        protected boolean removeBlind​(Object oKey)
        Removes the mapping for this key from this map if present. This method exists to allow sub-classes to optimize remove functionality for situations in which the original value is not required.
        Overrides:
        removeBlind in class AbstractKeyBasedMap
        Parameters:
        oKey - key whose mapping is to be removed from the map
        Returns:
        true iff the Map changed as the result of this operation

      • getUnits

        public int getUnits()
        Determine the number of units that the cache currently stores.

        Note: It is expected that the return type will be widened to a long in Coherence 4.

        Specified by:
        getUnits in interface ConfigurableCacheMap
        Returns:
        the current size of the cache in units

      • getHighUnits

        public int getHighUnits()
        Determine the limit of the cache size in units. The cache will prune itself automatically once it reaches its maximum unit level. This is often referred to as the "high water mark" of the cache.

        Note: It is expected that the return type will be widened to a long in Coherence 4.

        Specified by:
        getHighUnits in interface ConfigurableCacheMap
        Returns:
        the limit of the cache size in units

      • setHighUnits

        public void setHighUnits​(int cMax)
        Update the maximum size of the cache in units. This is often referred to as the "high water mark" of the cache.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        setHighUnits in interface ConfigurableCacheMap
        Parameters:
        cMax - the new maximum size of the cache, in units

      • getLowUnits

        public int getLowUnits()
        Determine the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache. If the cache incrementally prunes, then this setting will have no effect.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        getLowUnits in interface ConfigurableCacheMap
        Returns:
        the number of units that the cache prunes to

      • setLowUnits

        public void setLowUnits​(int cUnits)
        Specify the point to which the cache will shrink when it prunes. This is often referred to as a "low water mark" of the cache.

        Note: It is expected that the parameter will be widened to a long in Coherence 4.

        Specified by:
        setLowUnits in interface ConfigurableCacheMap
        Parameters:
        cUnits - the number of units that the cache prunes to

      • getUnitFactor

        public int getUnitFactor()
        Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

        Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.

        Specified by:
        getUnitFactor in interface ConfigurableCacheMap
        Returns:
        the units factor; the default is 1

      • setUnitFactor

        public void setUnitFactor​(int nFactor)
        Determine the factor by which the Units, LowUnits and HighUnits properties are adjusted. Using a binary unit calculator, for example, the factor 1048576 could be used to count megabytes instead of bytes.

        Note: This property exists only to avoid changing the type of the units, low units and high units properties from 32-bit values to 64-bit values. It is expected that the parameter will be dropped in Coherence 4.

        Specified by:
        setUnitFactor in interface ConfigurableCacheMap
        Parameters:
        nFactor - the units factor; the default is 1

      • evict

        public void evict​(Object oKey)
        Evict a specified key from the cache, as if it had expired from the cache. If the key is not in the cache, then the method has no effect.
        Specified by:
        evict in interface ConfigurableCacheMap
        Parameters:
        oKey - the key to evict from the cache

      • evictAll

        public void evictAll​(Collection colKeys)
        Evict the specified keys from the cache, as if they had each expired from the cache.

        The result of this method is defined to be semantically the same as the following implementation: 

        
 for (Iterator iter = colKeys.iterator(); iter.hasNext(); )
     {
     Object oKey = iter.next();
     evict(oKey);
     }

        Specified by:
        evictAll in interface ConfigurableCacheMap
        Parameters:
        colKeys - a collection of keys to evict from the cache

      • evict

        public void evict()
        Evict all entries from the cache that are no longer valid, and potentially prune the cache size if the cache is size-limited and its size is above the caching low water mark.
        Specified by:
        evict in interface ConfigurableCacheMap

      • getExpiryDelay

        public int getExpiryDelay()
        Determine the default "time to live" for each individual cache entry.
        Specified by:
        getExpiryDelay in interface ConfigurableCacheMap
        Returns:
        the number of milliseconds that a cache entry value will live, or zero if cache entries are never automatically expired

      • setExpiryDelay

        public void setExpiryDelay​(int cMillis)
        Specify the default "time to live" for cache entries. This does not affect the already-scheduled expiry of existing entries.
        Specified by:
        setExpiryDelay in interface ConfigurableCacheMap
        Parameters:
        cMillis - the number of milliseconds that cache entries will live, or zero to disable automatic expiry

      • getNextExpiryTime

        public long getNextExpiryTime()
        Determine the next expiry time for the cache entries. This value is supposed to be used only by the "active" expiry algorithms, so for implementations that choose to return the value of zero the entries will be evicted as with pre-existing "passive" expiry approach.
        Specified by:
        getNextExpiryTime in interface ConfigurableCacheMap
        Returns:
        the earliest time (using the SafeClock) that one or more cache entries will expire or zero if the cache is empty, its entries never expire or the implementation chooses to avoid the pro-active eviction

      • getInternalEvictionPolicy

        protected CompactSerializationCache.InternalEvictionPolicy getInternalEvictionPolicy()
        Return the InternalEvictionPolicy used by this CompactSerializationCache.

        Note: this method returns the actual instance of EvictionPolicy being used by this cache, which may differ in implementation from the configured policy returned by getEvictionPolicy().

        Returns:
        the internal eviction policy

      • addMapListener

        public void addMapListener​(MapListener listener)
        Add a standard map listener that will receive all events (inserts, updates, deletes) that occur against the map, with the key, old-value and new-value included. This has the same result as the following call: 
           addMapListener(listener, (Filter) null, false);
        Specified by:
        addMapListener in interface ObservableMap
        Parameters:
        listener - the MapEvent listener to add

      • removeMapListener

        public void removeMapListener​(MapListener listener)
        Remove a standard map listener that previously signed up for all events. This has the same result as the following call: 
           removeMapListener(listener, (Filter) null);
        Specified by:
        removeMapListener in interface ObservableMap
        Parameters:
        listener - the listener to remove

      • addMapListener

        public void addMapListener​(MapListener listener,
                           Object oKey,
                           boolean fLite)
        Add a map listener for a specific key.

        The listeners will receive MapEvent objects, but if fLite is passed as true, they might not contain the OldValue and NewValue properties.

        To unregister the MapListener, use the ObservableMap.removeMapListener(MapListener, Object) method.

        Specified by:
        addMapListener in interface ObservableMap
        Parameters:
        listener - the MapEvent listener to add
        oKey - the key that identifies the entry for which to raise events
        fLite - true to indicate that the MapEvent objects do not have to include the OldValue and NewValue property values in order to allow optimizations

      • removeMapListener

        public void removeMapListener​(MapListener listener,
                              Object oKey)
        Remove a map listener that previously signed up for events about a specific key.
        Specified by:
        removeMapListener in interface ObservableMap
        Parameters:
        listener - the listener to remove
        oKey - the key that identifies the entry for which to raise events

      • addMapListener

        public void addMapListener​(MapListener listener,
                           Filter filter,
                           boolean fLite)
        Add a map listener that receives events based on a filter evaluation.

        The listeners will receive MapEvent objects, but if fLite is passed as true, they might not contain the OldValue and NewValue properties.

        To unregister the MapListener, use the ObservableMap.removeMapListener(MapListener, Filter) method.

        Specified by:
        addMapListener in interface ObservableMap
        Parameters:
        listener - the MapEvent listener to add
        filter - a filter that will be passed MapEvent objects to select from; a MapEvent will be delivered to the listener only if the filter evaluates to true for that MapEvent (see MapEventFilter); null is equivalent to a filter that alway returns true
        fLite - true to indicate that the MapEvent objects do not have to include the OldValue and NewValue property values in order to allow optimizations

      • removeMapListener

        public void removeMapListener​(MapListener listener,
                              Filter filter)
        Remove a map listener that previously signed up for events based on a filter evaluation.
        Specified by:
        removeMapListener in interface ObservableMap
        Parameters:
        listener - the listener to remove
        filter - the filter that was passed into the corresponding addMapListener() call

      • dispose

        public void dispose()
        Invoked when all resources owned by the implementer can safely be released.

        Once disposed of the object should no longer be considered to be usable.

        Note the Disposable interface is compatible with try-with-resources which will automatically invoke this method.

        Specified by:
        dispose in interface Disposable

      • instantiateDeferredCacheEvent

        protected AbstractKeyBasedMap.DeferredCacheEvent instantiateDeferredCacheEvent​(int nId,
                                                                               Binary binKey,
                                                                               Object oKey,
                                                                               Object oValueOld,
                                                                               Object oValueNew,
                                                                               boolean fSynthetic)
        Create a DeferredCacheEvent object with the provided arguments. The oValueOld may be null as the deferred event may call load upon request.
        Parameters:
        nId - this event's id, one of MapEvent.ENTRY_INSERTED, MapEvent.ENTRY_UPDATED or MapEvent.ENTRY_DELETED
        binKey - the binary key into the map
        oKey - the key into the map
        oValueOld - optional old value (for update and delete events); if not provided a call to getOldValue will load the old value from the BinaryStore
        oValueNew - the new value (for insert and update events)
        fSynthetic - true iff the event is caused by the cache internal processing such as eviction or loading
        Returns:
        a DeferredCacheEvent object

      • dispatchEvent

        protected void dispatchEvent​(int nId,
                             Binary binKey,
                             Object oKey,
                             Object oValueOld,
                             Object oValueNew,
                             boolean fSynthetic)
        Dispatch the passed event.
        Parameters:
        nId - this event's id, one of MapEvent.ENTRY_INSERTED, MapEvent.ENTRY_UPDATED or MapEvent.ENTRY_DELETED
        binKey - the binary key into the map
        oKey - the key into the map
        oValueOld - optional old value (for update and delete events); if not provided a call to getOldValue will load the old value from the BinaryStore
        oValueNew - the new value (for insert and update events)
        fSynthetic - true iff the event is caused by the cache internal processing such as eviction or loading

      • toString

        public String toString()
        Returns a string representation of this Map. The string representation consists of a list of key-value mappings in the order returned by the Map's entrySet view's iterator, enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by String.valueOf(Object).
        Overrides:
        toString in class AbstractKeyBasedMap
        Returns:
        a String representation of this Map

      • removeInternal

        protected Object removeInternal​(Object oKey,
                                Binary binKey,
                                boolean fBlind)
        Remove the given key from the BinaryStore only loading the value if necessary.
        Parameters:
        oKey - the key to be removed
        binKey - the binary key to be removed
        fBlind - whether the remove should be blind
        Returns:
        the previous value or an indicator (OBJECT_EXISTS) to suggest the object did exist if fBlind is true

      • configureEviction

        protected void configureEviction()
        Ensure that the BinaryLongMaps required for eviction support are configured.

      • ensureExpiryMap

        protected BinaryLongMap ensureExpiryMap()
        Ensure that the expiry-map is initialized.
        Returns:
        the expiry map

      • checkExpiry

        protected void checkExpiry​(boolean fForce)
        Check the cache entries for expiration, removing expired entries as necessary.
        Parameters:
        fForce - pass true to force the expiry check, or false to only run it if it hasn't been run in a while

      • checkExpiry

        protected void checkExpiry​(Binary binKey)
        Check the specified key to see if it is expired, removing it if necessary. This method will also ensure that other cache entries which are ripe for expiration will eventually be expired before too many accumulate.
        Parameters:
        binKey - the key to check for expiration

      • checkSize

        protected void checkSize​(boolean fCheckExpiry)
        Check the current size of the cache to see that it is within the configured high-units, evicting entries according to the configured ConfigurableCacheMap.EvictionPolicy if necessary.
        Parameters:
        fCheckExpiry - true iff the expiry should be checked if eviction is called for

      • touch

        protected void touch​(Binary binKey)
        Register a "touch" of the specified key.
        Parameters:
        binKey - the key that was touched

      • evictInternal

        protected int evictInternal​(Binary binKey)
        Attempt to evict the cache entry for the specified key from the cache as a result of either expiration or size-triggered eviction, returning the unit-size of the evicted entry, or 0 if the eviction was disallowed by the ConfigurableCacheMap.EvictionApprover.
        Parameters:
        binKey - the key to evict
        Returns:
        the number of units evicted

      • registerExpiry

        protected void registerExpiry​(Binary binKey,
                              long cExpiry)
        Register the expiry for the specified key.
        Parameters:
        binKey - the key
        cExpiry - the number of milliseconds until the cache entry will expire, also referred to as the entry's "time to live" or 0 to indicate that the cache entry should never expire

      • getEntryUnits

        protected int getEntryUnits​(Binary binKey)
        Return the unit-size of the entry associated with the specified key, or 0 if the key does not exist.
        Parameters:
        binKey - the key
        Returns:
        the unit-size of the entry associated with the specified key

      • calculateUnits

        protected int calculateUnits​(Binary binKey,
                             Binary binValue)
        Calculate the unit cost of the specified cache entry, according to the configured unit-calculator.
        Parameters:
        binKey - the key
        binValue - the value
        Returns:
        the unit cost of the cache entry

      • updateUnits

        protected void updateUnits​(Binary binKey,
                           int cUnits)
        Update the units associated with the specified key.
        Parameters:
        binKey - the key
        cUnits - the units

      • toBinary

        protected Binary toBinary​(Object o)
        Translate the passed Object object into an Binary object.
        Parameters:
        o - the Object to serialize into a Binary object
        Returns:
        the Binary object

      • fromBinary

        protected Object fromBinary​(Binary bin)
        Translate the passed Binary object into an Object object.
        Parameters:
        bin - the Binary object to deserialize
        Returns:
        the deserialized object

      • getCacheEntryInternal

        protected ConfigurableCacheMap.Entry getCacheEntryInternal​(Binary binKey,
                                                           Object oKey)
        Return a ConfigurableCacheMap.Entry for the specified key.
        Parameters:
        binKey - the binary or "raw" form of the key
        oKey - the Object or "natural" form of the key
        Returns:
        an Entry representing the specified key

      • toExternalUnits

        protected static int toExternalUnits​(long cUnits,
                                     int nFactor)
        Convert from an internal 64-bit unit value to an external 32-bit unit value using the configured units factor.
        Parameters:
        cUnits - an internal 64-bit units value
        nFactor - the unit factor
        Returns:
        an external 32-bit units value

      • toInternalUnits

        protected static long toInternalUnits​(int cUnits,
                                      int nFactor)
        Convert from an external 32-bit unit value to an internal 64-bit unit value using the configured units factor.
        Parameters:
        cUnits - an external 32-bit units value
        nFactor - the unit factor
        Returns:
        an internal 64-bit units value

      • encodeExpiry

        protected long encodeExpiry​(long cExpiryDelay)
        Encode the specified expiry delay (relative to current time) into the internal format. The value can be decoded to yield an absolute date-time that is approximately equivalent to the the specified delay from the current time.
        Parameters:
        cExpiryDelay - the relative delay from the current time; must be >= 0
        Returns:
        the encoded expiry value

      • decodeExpiry

        protected long decodeExpiry​(long cExpiryEncoded)
        Decode the specified encoded expiry value into an absolute time.
        Parameters:
        cExpiryEncoded - the encoded expiry value
        Returns:
        the absolute expiry time

      • encodeTime

        protected int encodeTime​(long ldt)
        Encode the specified time into an opaque 32-bit value.
        Parameters:
        ldt - the time to encode
        Returns:
        the encoded time

      • decodeTime

        protected long decodeTime​(int cEncoded)
        Decode the specified encoded time into an absolute ldt.
        Parameters:
        cEncoded - the 32-bit encoded time
        Returns:
        the absolute date-time