Package com.tangosol.net.cache

Interface ConfigurableCacheMap

    • Method Detail

      • getUnits

        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.

        Returns:
        the current size of the cache in units

      • getHighUnits

        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.

        Returns:
        the limit of the cache size in units

      • setHighUnits

        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.

        Parameters:
        cMax - the new maximum size of the cache, in units

      • getLowUnits

        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.

        Returns:
        the number of units that the cache prunes to

      • setLowUnits

        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.

        Parameters:
        cUnits - the number of units that the cache prunes to

      • getUnitFactor

        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.

        Returns:
        the units factor; the default is 1

      • setUnitFactor

        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.

        Parameters:
        nFactor - the units factor; the default is 1

      • evict

        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.
        Parameters:
        oKey - the key to evict from the cache

      • evictAll

        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);
     }

        Parameters:
        colKeys - a collection of keys to evict from the cache

      • evict

        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.

      • setEvictionApprover

        void setEvictionApprover​(ConfigurableCacheMap.EvictionApprover approver)
        Set the EvictionApprover for this ConfigurableCacheMap.
        Parameters:
        approver - the EvictionApprover

      • getExpiryDelay

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

      • setExpiryDelay

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

      • getNextExpiryTime

        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.
        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

      • getCacheEntry

        ConfigurableCacheMap.Entry getCacheEntry​(Object oKey)
        Locate a cache Entry in the cache based on its key.
        Parameters:
        oKey - the key object to search for
        Returns:
        the Entry or null

      • getEvictionPolicy

        ConfigurableCacheMap.EvictionPolicy getEvictionPolicy()
        Obtain the current EvictionPolicy used by the cache.
        Returns:
        the EvictionPolicy used by the cache

      • setEvictionPolicy

        void setEvictionPolicy​(ConfigurableCacheMap.EvictionPolicy policy)
        Set the EvictionPolicy for the cache to use.
        Parameters:
        policy - an EvictionPolicy

      • getUnitCalculator

        ConfigurableCacheMap.UnitCalculator getUnitCalculator()
        Obtain the current UnitCalculator used by the cache.
        Returns:
        the UnitCalculator used by the cache

      • setUnitCalculator

        void setUnitCalculator​(ConfigurableCacheMap.UnitCalculator calculator)
        Set the UnitCalculator for the cache to use.
        Parameters:
        calculator - a UnitCalculator