Package com.gentlyweb.utils

Class ObjectCache

java.lang.Object
com.gentlyweb.utils.ObjectCache
All Implemented Interfaces:
ObjectCacheManager
public class ObjectCache extends Object implements ObjectCacheManager
The ObjectCache is it's own manager which means that classes that extend this one can do so quickly and without having to implement the ObjectCacheManager interface they only have to provide their own functionality whilst client classes can rely on the interface. All operations defined with ObjectCacheManager are supported here.

  • Field Details

  • Constructor Details

  • Method Details

    • setPolicy

      public void setPolicy(int type) throws IllegalArgumentException
      Description copied from interface: ObjectCacheManager
      Set the policy for managing the cache, should be one of:
      invalid reference 
      ObjectCache.OLDEST
      ,
      invalid reference 
      ObjectCache.YOUNGEST
      ,
      invalid reference 
      ObjectCache.RANDOM
      .
      Specified by:
      setPolicy in interface ObjectCacheManager
      Parameters:
      type - The policy.
      Throws:
      IllegalArgumentException

    • getPolicy

      public int getPolicy()

    • iterator

      public Iterator iterator()

    • keys

      public List keys()
      Return a List of all the keys in the cache.
      Returns:
      The List (ArrayList) of all the keys in the cache.

    • values

      public List values()
      Return a List of all the values in the cache.
      Returns:
      The List (ArrayList) of all the values in the cache.

    • keysForFilteredValues

      public List keysForFilteredValues(GeneralFilter f) throws IllegalAccessException, InvocationTargetException, FilterException
      Return a List of keys in the cache that match the conditions imposed by the GeneralFilter AND are applied to the values NOT the keys.
      Parameters:
      f - The filter to use.
      Returns:
      A List of the keys that map to the matched values.
      Throws:
      IllegalAccessException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if we can't get access to a value defined in the GeneralFilter for the value class.
      InvocationTargetException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) an exception is thrown by a value object.
      FilterException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) the type of object returned by the field access is not of the expected type.

    • values

      public List values(GeneralFilter f) throws IllegalAccessException, InvocationTargetException, FilterException
      Return a List of all the values in the cache that match the conditions imposed by the GeneralFilter passed in. We first gain all the values in the cache and then pass them through the filter returning the values that match. Because a GeneralFilter can only filter on a single class type (but the values may not be of a single type) we ignore any values that are not of the type specified for the GeneralFilter.
      Returns:
      A List (ArrayList) of all the values in the cache.
      Throws:
      IllegalAccessException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if we can't get access to a value defined in the GeneralFilter for the value class.
      InvocationTargetException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) an exception is thrown by a value object.
      FilterException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) the type of object returned by the field access is not of the expected type.

    • keys

      public List keys(GeneralFilter f) throws IllegalAccessException, InvocationTargetException, FilterException
      Return a List of all the keys in the cache that match the conditions imposed by the GeneralFilter passed in. We first gain all the keys in the cache and then pass them through the filter returning the keys that match. Because a GeneralFilter can only filter on a single class type (but the keys may not be of a single type) we ignore any keys that are not of the type specified for the GeneralFilter.
      Returns:
      A List (ArrayList) of all the keys in the cache.
      Throws:
      IllegalAccessException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if we can't get access to a value defined in the GeneralFilter for the key class.
      InvocationTargetException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) an exception is thrown by a key object.
      FilterException - Thrown by the
      invalid @link 
      {@link GeneralFilter.accept(Object)
      } method if (as a result of accessing a field) the type of object returned by the field access is not of the expected type.

    • valuesToList

      public void valuesToList(List list)

    • keysToList

      public void keysToList(List list)

    • toMap

      public void toMap(Map map)
      Description copied from interface: ObjectCacheManager
      Get all the entries in the cache as a Map of key to value.
      Specified by:
      toMap in interface ObjectCacheManager
      Parameters:
      map - The Map that should be populated with the key/values in the cache.

    • putAll

      public void putAll(Map map)
      Description copied from interface: ObjectCacheManager
      Add all the entries in the Map to cache.
      Specified by:
      putAll in interface ObjectCacheManager
      Parameters:
      map - The Map to get key/values from.

    • containsKey

      public boolean containsKey(Object key)

    • merge

      public void merge(ObjectCache cache)
      Description copied from interface: ObjectCacheManager
      Merge the current cache with another.
      Specified by:
      merge in interface ObjectCacheManager
      Parameters:
      cache - The cache to merge.

    • cacheSliceTo

      public ObjectCache cacheSliceTo(Date to)

    • cacheSliceFrom

      public ObjectCache cacheSliceFrom(Date from)

    • cacheSlice

      public ObjectCache cacheSlice(Date from, Date to)

    • sliceFrom

      public Map sliceFrom(Date from)

    • sliceTo

      public Map sliceTo(Date to)

    • slice

      public Map slice(Date from, Date to)

    • getLastAccessTime

      public Date getLastAccessTime(Object key)

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: ObjectCacheManager
      Return whether the cache is empty or not.
      Specified by:
      isEmpty in interface ObjectCacheManager
      Returns:
      true if the cache is empty, false if it has entries.

    • capacity

      public int capacity()
      Description copied from interface: ObjectCacheManager
      Return the current capacity of the cache, it should basically be (max size - current size).
      Specified by:
      capacity in interface ObjectCacheManager
      Returns:
      The current number of items that can be added until the cache reaches it's maximum size.

    • getMaxSize

      public int getMaxSize()

    • setMaxSize

      public void setMaxSize(int size)
      Description copied from interface: ObjectCacheManager
      Set the maximum size of the cache.
      Specified by:
      setMaxSize in interface ObjectCacheManager
      Parameters:
      size - The maximum size.

    • get

      public Object get(Object key)

    • firstValue

      public Object firstValue()

    • lastValue

      public Object lastValue()

    • firstKey

      public Object firstKey()

    • size

      public int size()

    • remove

      public void remove(Object key)

    • resize

      public void resize(int size)
      Description copied from interface: ObjectCacheManager
      Resize the cache to a particular size, if the size is actually bigger than the current size then this operation should not touch the cached objects, if the size is less then the cache should be reduced in size using the current policy until the size is reached. Either way the maximum size should be set to this value.
      Specified by:
      resize in interface ObjectCacheManager
      Parameters:
      size - The new size.

    • resize

      protected void resize()

    • put

      public void put(Object key, Object value)

    • flush

      public void flush()
      Clear our data structures.
      Specified by:
      flush in interface ObjectCacheManager