Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.jboss.util
Class LRUCachePolicy

    java.lang.Object
      org.jboss.util.LRUCachePolicy

All Implemented Interfaces:
  CachePolicy

public class LRUCachePolicy
extends Object
implements CachePolicy

Implementation of a Least Recently Used cache policy.

Version:
  $Revision: 1.6 $
Author:
  Simone Bordet

Nested Class Summary
`class` | `LRUCachePolicy.LRUCacheEntry` Double linked cell used as entry in the cache list.
`class` | `LRUCachePolicy.LRUList` Double queued list used to store cache entries.

Field Summary
`protected LRUCachePolicy.LRUList` | `m_list` The linked list used to implement the LRU algorithm
`protected HashMap` | `m_map` The map holding the cached objects
`protected int` | `m_maxCapacity` The maximum capacity of this cache
`protected int` | `m_minCapacity` The minimum capacity of this cache

Constructor Summary
`LRUCachePolicy()` Creates a LRU cache policy object with zero cache capacity.
`LRUCachePolicy(int min, int max)` Creates a LRU cache policy object with the specified minimum and maximum capacity.

Method Summary
`protected void` | `ageOut(LRUCachePolicy.LRUCacheEntry entry)` Callback method called when the cache algorithm ages out of the cache the given entry.
`protected void` | `cacheMiss()` Callback method called when a cache miss happens.
`void` | `create()` Initializes the cache, creating all required objects and initializing their values.
`protected LRUCachePolicy.LRUCacheEntry` | `createCacheEntry(Object key, Object value)` Factory method for cache entries
`protected LRUCachePolicy.LRUList` | `createList()` Factory method for the linked list used by this cache implementation.
`void` | `destroy()` Destroys the cache that is now unusable.
`void` | `flush()` Flushes the cached objects from the cache.
`Object` | `get(Object key)` Returns the object paired with the specified key if it's present in the cache, otherwise must return null.
`void` | `insert(Object key, Object o)` Inserts the specified object into the cache following the implemented policy.
`Object` | `peek(Object key)` Returns the object paired with the specified key if it's present in the cache, otherwise must return null.
`void` | `remove(Object key)` Remove the cached object paired with the specified key.
`int` | `size()` Get the size of the cache.
`void` | `start()` Starts this cache that is now ready to be used.
`void` | `stop()` Stops this cache thus `flush()`ing all cached objects.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### m_map

    protected HashMap m_map

  The map holding the cached objects

### m_list

    protected LRUCachePolicy.LRUList m_list

  The linked list used to implement the LRU algorithm

### m_maxCapacity

    protected int m_maxCapacity

  The maximum capacity of this cache

### m_minCapacity

    protected int m_minCapacity

  The minimum capacity of this cache

Constructor Detail

### LRUCachePolicy

    public LRUCachePolicy()

  Creates a LRU cache policy object with zero cache capacity.

See Also:
  `create()`

### LRUCachePolicy

    public LRUCachePolicy(int min,
                          int max)

  Creates a LRU cache policy object with the specified minimum and maximum capacity.

See Also:
  `create()`

Method Detail

### create

    public void create()

  Initializes the cache, creating all required objects and initializing their values.

  Specified by:
    `create` in interface `CachePolicy`
  See Also:
    `start()`, `destroy()`

### start

    public void start()

  Starts this cache that is now ready to be used.

  Specified by:
    `start` in interface `CachePolicy`
  See Also:
    `create()`, `stop()`

### stop

    public void stop()

  Stops this cache thus `flush()`ing all cached objects.
  After this method is called, a call to `start()` will restart the cache.

  Specified by:
    `stop` in interface `CachePolicy`
  See Also:
    `start()`, `destroy()`

### destroy

    public void destroy()

  Destroys the cache that is now unusable.
  To have it working again it must be re-`create()`ed and re-`start()`ed.

  Specified by:
    `destroy` in interface `CachePolicy`
  See Also:
    `create()`

### get

    public Object get(Object key)

  Description copied from interface: `CachePolicy`
  Returns the object paired with the specified key if it's present in the cache, otherwise must return null.
  Implementations of this method must have complexity of order O(1). Differently from `CachePolicy.peek(java.lang.Object)` this method not only return whether the object is present in the cache or not, but also applies the implemented policy that will "refresh" the cached object in the cache, because this cached object was really requested.

  Specified by:
    `get` in interface `CachePolicy`
  Parameters:
    `key` - the key paired with the object
  See Also:
    `CachePolicy.peek(java.lang.Object)`

### peek

    public Object peek(Object key)

  Description copied from interface: `CachePolicy`
  Returns the object paired with the specified key if it's present in the cache, otherwise must return null.
  Implementations of this method must have complexity of order O(1). This method should not apply the implemented caching policy to the object paired with the given key, so that a client can query if an object is cached without "refresh" its cache status. Real requests for the object must be done using `CachePolicy.get(java.lang.Object)`.

  Specified by:
    `peek` in interface `CachePolicy`
  Parameters:
    `key` - the key paired with the object
  See Also:
    `CachePolicy.get(java.lang.Object)`

### insert

    public void insert(Object key,
                       Object o)

  Description copied from interface: `CachePolicy`
  Inserts the specified object into the cache following the implemented policy.
  Implementations of this method must have complexity of order O(1).

  Specified by:
    `insert` in interface `CachePolicy`
  Parameters:
    `key` - the key paired with the object
    `o` - the object to cache
  See Also:
    `CachePolicy.remove(java.lang.Object)`

### remove

    public void remove(Object key)

  Description copied from interface: `CachePolicy`
  Remove the cached object paired with the specified key.
  Implementations of this method must have complexity of order O(1).

  Specified by:
    `remove` in interface `CachePolicy`
  Parameters:
    `key` - the key paired with the object
  See Also:
    `CachePolicy.insert(java.lang.Object, java.lang.Object)`

### flush

    public void flush()

  Description copied from interface: `CachePolicy`
  Flushes the cached objects from the cache.

  Specified by:
    `flush` in interface `CachePolicy`

### size

    public int size()

  Description copied from interface: `CachePolicy`
  Get the size of the cache.

  Specified by:
    `size` in interface `CachePolicy`

### createList

    protected LRUCachePolicy.LRUList createList()

  Factory method for the linked list used by this cache implementation.

### ageOut

    protected void ageOut(LRUCachePolicy.LRUCacheEntry entry)

  Callback method called when the cache algorithm ages out of the cache the given entry.
  The implementation here is removing the given entry from the cache.

### cacheMiss

    protected void cacheMiss()

  Callback method called when a cache miss happens.

### createCacheEntry

    protected LRUCachePolicy.LRUCacheEntry createCacheEntry(Object key,
                                                            Object value)

  Factory method for cache entries

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002 JBoss Group, LLC. All Rights Reserved.