Package net.sf.ehcache.store

Class LegacyStoreWrapper

  • All Implemented Interfaces:
    Store
    public class LegacyStoreWrapper
extends AbstractStore
    A wrapper to convert a legacy pair of stores into a new style compound store.
    Author:
    Chris Dennis

    • Constructor Detail

      • LegacyStoreWrapper

        public LegacyStoreWrapper​(Store memory,
                          Store disk,
                          RegisteredEventListeners eventListeners,
                          CacheConfiguration config)
        Create a correctly locked store wrapper around the supplied in-memory and on disk stores.
        Parameters:
        memory - in-memory store
        disk - on disk store
        eventListeners - event listener to fire on
        config - cache configuration

    • Method Detail

      • bufferFull

        public boolean bufferFull()
        Some store types, such as the disk stores can fill their write buffers if puts come in too fast. The thread will wait for a short time before checking again.
        Returns:
        true if the store write buffer is backed up.

      • containsKey

        public boolean containsKey​(java.lang.Object key)
        A check to see if a key is in the Store.
        Parameters:
        key - The Element key
        Returns:
        true if found. No check is made to see if the Element is expired. 1.2

      • containsKeyInMemory

        public boolean containsKeyInMemory​(java.lang.Object key)
        A check to see if a key is in the Store and is currently held in memory.
        Parameters:
        key - The Element key
        Returns:
        true if found. No check is made to see if the Element is expired.

      • containsKeyOffHeap

        public boolean containsKeyOffHeap​(java.lang.Object key)
        A check to see if a key is in the Store and is currently held off-heap.
        Parameters:
        key - The Element key
        Returns:
        true if found. No check is made to see if the Element is expired.

      • containsKeyOnDisk

        public boolean containsKeyOnDisk​(java.lang.Object key)
        A check to see if a key is in the Store and is currently held on disk.
        Parameters:
        key - The Element key
        Returns:
        true if found. No check is made to see if the Element is expired.

      • dispose

        public void dispose()
        Prepares for shutdown.

      • expireElements

        public void expireElements()
        Expire all elements.

      • flush

        public void flush()
           throws java.io.IOException
        Flush elements to persistent store.
        Throws:
        java.io.IOException - if any IO error occurs

      • get

        public Element get​(java.lang.Object key)
        Gets an item from the cache.

      • getInMemoryEvictionPolicy

        public Policy getInMemoryEvictionPolicy()
        Returns:
        the current eviction policy. This may not be the configured policy, if it has been dynamically set.
        See Also:
        Store.setInMemoryEvictionPolicy(Policy)

      • getInMemorySize

        public int getInMemorySize()
        Returns the current local in-memory store size
        Returns:
        the count of the Elements in the Store and in-memory on the local machine

      • getInMemorySizeInBytes

        public long getInMemorySizeInBytes()
        Gets the size of the in-memory portion of the store, in bytes.

        This method may be expensive to run, depending on implementation. Implementers may choose to return an approximate size.

        Returns:
        the approximate in-memory size of the store in bytes

      • getInternalContext

        public java.lang.Object getInternalContext()
        This should not be used, and will generally return null
        Returns:
        some internal context (probably null)

      • getKeys

        public java.util.List getKeys()
        Gets an Array of the keys for all elements in the disk store.
        Returns:
        An List of Serializable keys

      • getOffHeapSize

        public int getOffHeapSize()
        Returns the current local off-heap store size
        Returns:
        the count of the Elements in the Store and off-heap on the local machine

      • getOffHeapSizeInBytes

        public long getOffHeapSizeInBytes()
        Gets the size of the off-heap portion of the store, in bytes.
        Returns:
        the approximate off-heap size of the store in bytes

      • getOnDiskSize

        public int getOnDiskSize()
        Returns the current local on-disk store size
        Returns:
        the count of the Elements in the Store and on-disk on the local machine

      • getOnDiskSizeInBytes

        public long getOnDiskSizeInBytes()
        Gets the size of the on-disk portion of the store, in bytes.
        Returns:
        the on-disk size of the store in bytes

      • getQuiet

        public Element getQuiet​(java.lang.Object key)
        Gets an Element from the Store, without updating statistics
        Returns:
        The element

      • getSize

        public int getSize()
        Returns the current local store size

        The size is the number of Elements in the memory store plus the number of Elements in the disk store.

        Returns:
        the count of the Elements in the Store on the local machine

      • getStatus

        public Status getStatus()
        Returns the cache status.

      • getTerracottaClusteredSize

        public int getTerracottaClusteredSize()
        Returns the current Terracotta clustered store size
        Returns:
        the count of the Elements in the Store across the cluster

      • put

        public boolean put​(Element element)
            throws CacheException
        Puts an item into the store.
        Returns:
        true if this is a new put for the key or element is null. Returns false if it was an update.
        Throws:
        CacheException

      • putWithWriter

        public boolean putWithWriter​(Element element,
                             CacheWriterManager writerManager)
                      throws CacheException
        Puts an item into the store and the cache writer manager in an atomic operation
        Returns:
        true if this is a new put for the key or element is null. Returns false if it was an update.
        Throws:
        CacheException

      • remove

        public Element remove​(java.lang.Object key)
        Removes an item from the cache.

      • removeAll

        public void removeAll()
               throws CacheException
        Remove all of the elements from the store.

        If there are registered CacheEventListeners they are notified of the expiry or removal of the Element as each is removed.

        Throws:
        CacheException

      • setInMemoryEvictionPolicy

        public void setInMemoryEvictionPolicy​(Policy policy)
        Sets the eviction policy strategy. The Store will use a policy at startup. The store may allow changing the eviction policy strategy dynamically. Otherwise implementations will throw an exception if this method is called.
        Parameters:
        policy - the new policy

      • getMemoryStore

        public Store getMemoryStore()
        Returns the underlying memory store for this legacy wrapper.

      • putIfAbsent

        public Element putIfAbsent​(Element element)
                    throws java.lang.NullPointerException
        Put an element in the store if no element is currently mapped to the elements key.
        Parameters:
        element - element to be added
        Returns:
        the element previously cached for this key, or null if none.
        Throws:
        java.lang.NullPointerException - if the element is null, or has a null key

      • removeElement

        public Element removeElement​(Element element,
                             ElementValueComparator comparator)
                      throws java.lang.NullPointerException
        Remove the Element mapped to the key for the supplied element if the value of the supplied Element is equal to the value of the cached Element. This is a CAS operation. It is consistent even against a distributed cache that is not coherent. If the old value is stale when this operation is attempted the remove does not take place.
        Parameters:
        element - Element to be removed
        comparator - ElementValueComparator to use to compare elements
        Returns:
        the Element removed or null if no Element was removed
        Throws:
        java.lang.NullPointerException - if the element is null, or has a null key

      • replace

        public boolean replace​(Element old,
                       Element element,
                       ElementValueComparator comparator)
                throws java.lang.NullPointerException,
                       java.lang.IllegalArgumentException
        Replace the cached element only if the value of the current Element is equal to the value of the supplied old Element.
        Parameters:
        old - Element to be test against
        element - Element to be cached
        comparator - ElementValueComparator to use to compare elements
        Returns:
        true is the Element was replaced
        Throws:
        java.lang.NullPointerException - if the either Element is null or has a null key
        java.lang.IllegalArgumentException - if the two Element keys are non-null but not equal

      • replace

        public Element replace​(Element element)
                throws java.lang.NullPointerException
        Replace the cached element only if an Element is currently cached for this key
        Parameters:
        element - Element to be cached
        Returns:
        the Element previously cached for this key, or null if no Element was cached
        Throws:
        java.lang.NullPointerException - if the Element is null or has a null key

      • getMBean

        public java.lang.Object getMBean()
        Optional implementation specific MBean exposed by the store.
        Returns:
        implementation specific management bean