pyzim.cache.LastAccessCache

class documentation

class LastAccessCache(BaseCache):

Constructor: LastAccessCache(on_leave, max_size)

A BaseCache implementation that caches by last access.

This cache works using a double-linked list and a dictionary/hashmap. Newly accessed elements are added to the front of the list while the dictionary maps the key to the list segment, allowing O(1) access. When the list is already "full", the last element gets removed. This allows all cache operations within O(1).

Method	`__init__`	No summary
Method	`clear`	Empty this cache.
Method	`get`	Return the element that has been cached for this key.
Method	`has`	Return True if an element is cached for the specific key.
Method	`push`	Push an element for this key into this cache.
Method	`remove`	If an element is cached for key, remove it from the cache.
Instance Variable	`lock`	thread-safety lock
Instance Variable	`max_size`	maximum size of cache in number of elements
Instance Variable	`_key2element`	Undocumented
Instance Variable	`_list`	Undocumented

Inherited from BaseCache:

Instance Variable on_leave a callable expecting two arguments (key, value) that will be called when an element leaves the cache

def __init__(self, on_leave=None, max_size=8): ¶

overrides pyzim.cache.BaseCache.__init__

Parameters
on_leave:callable or `None`	See `BaseCache.__init__`
max_size:`int`	maximum size of cache in number of elements

def clear(self, call_on_leave=True): ¶

overrides pyzim.cache.BaseCache.clear

Empty this cache.

Parameters
call_on_leave:`bool`	if nonzero (default), call `BaseCache.on_leave` for each element cleared

def get(self, key): ¶

overrides pyzim.cache.BaseCache.get

Return the element that has been cached for this key.

Parameters
key:hashable	key for the element that should be returned

Returns
same as passed to `BaseCache.push`	the element

Raises
`KeyError`	if no element was cached for this key

def has(self, key): ¶

overrides pyzim.cache.BaseCache.has

Return True if an element is cached for the specific key.

Parameters
key:hashable	key of element that should be checked

Returns
`bool`	True if an element has been cached for this key

def push(self, key, element, allow_replacement=True): ¶

overrides pyzim.cache.BaseCache.push

Push an element for this key into this cache.

It is up for the cache to decide whether the element will actually be cached or not. If allow_replacement=False is set, no other element should be kicked from the cache.

Re-pushing an already cached element will not update the cached element.

Parameters
key:hashable	key which will be used to identify the element
element:any	element to cache
allow_replacement:`bool`	if this value is false, do not cache if this would kick another element from the cache

Returns
`bool`	True if the element is now cached, False otherwise

def remove(self, key, call_on_leave=True): ¶

overrides pyzim.cache.BaseCache.remove

If an element is cached for key, remove it from the cache.

Parameters
key:hashable	key of element to remove
call_on_leave:`bool`	if nonzero (default), call `BaseCache.on_leave` on the removed element

lock: threading.Lock = ¶

thread-safety lock

max_size: int = ¶

maximum size of cache in number of elements

_key2element: dict = ¶

Undocumented

_list = ¶

Undocumented