| | |
- dict(object)
-
- Cache
- object
-
- CacheHolder
class Cache(dict) |
| |
Trivial sub-class of a dict which has some convenience methods
Maps id(client): {
key="": CacheHolder()
}
That is, for each client node, a dictionary
holds opaque key(normally strings) to CacheHolder
instances. The CacheHolder is responsible for
most of the implementation of the cache.
|
| |
- Method resolution order:
- Cache
- dict
- object
Methods defined here:
- getData(self, client, key='', default=None)
- Return the data for given client and key, default otherwise
- getHolder(self, client, key='')
- Return the cache holder for the given client and key
- holder(self, client, data, key='')
- Create a new CacheHolder in this cache
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Methods inherited from dict:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __contains__(...)
- D.__contains__(k) -> True if D has a key k, else False
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __init__(...)
- x.__init__(...) initializes x; see x.__class__.__doc__ for signature
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __repr__(...)
- x.__repr__() <==> repr(x)
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __sizeof__(...)
- D.__sizeof__() -> size of D in memory, in bytes
- clear(...)
- D.clear() -> None. Remove all items from D.
- copy(...)
- D.copy() -> a shallow copy of D
- get(...)
- D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
- has_key(...)
- D.has_key(k) -> True if D has a key k, else False
- items(...)
- D.items() -> list of D's (key, value) pairs, as 2-tuples
- iteritems(...)
- D.iteritems() -> an iterator over the (key, value) items of D
- iterkeys(...)
- D.iterkeys() -> an iterator over the keys of D
- itervalues(...)
- D.itervalues() -> an iterator over the values of D
- keys(...)
- D.keys() -> list of D's keys
- pop(...)
- D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
- popitem(...)
- D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
- setdefault(...)
- D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
- update(...)
- D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
- values(...)
- D.values() -> list of D's values
Data and other attributes inherited from dict:
- __hash__ = None
- __new__ = <built-in method __new__ of type object at 0x81a1e0>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
- fromkeys = <built-in method fromkeys of type object at 0x37f9b30>
- dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
|
class CacheHolder(object) |
| |
Holder for data values within a cache
The CacheHolder provides the bulk of the cache
implementation. It associates an opaque data value
with a client node and an opaque key. The key
value allows multiple dimensions of storage, to
allow, for instance storing compiled shadow
information separate from compiled geometry
information.
The depend method uses the dispatcher module
to invalidate this CacheHolder when the given
fields for the given nodes are changed.
Attributes:
client -- weak reference to the client node
key -- strong reference to the opaque key value
data -- strong reference to the opaque data value
cache -- weak reference to the cache in which
we are storing ourselves
|
| |
Methods defined here:
- __call__(self, signal=None, sender=None)
- Delete the cached value (this object)
This de-registers ourselves from our cache object,
with suitable checks for whether our cache is still
alive itself, and whether it still has an entry
for our client and our key.
If this is the last registered cache object
for our client, deletes the overall cache dictionary
for the client.
- __init__(self, client, data, key='', cache={})
- Initialise the cache-deletion callable
client -- the node doing the caching, if gc'd,
then the entire cache for the node is deleted
key -- opaque key into the cache's per-node storage
cache -- the particular cache in which to store
ourselves.
- clear(self, signal=None, sender=None)
- Clear this object's held value (only)
- depend(self, node, field=None)
- Add a dependency on given node's field value
source -- the node being watched
field -- the field on the node being watched
Dependency on the node means that this cache
holder will be invalidated if the field value
changes. This does not create a dependency
on the existence of node, so you should set
the dependency for the field holding any
nodes which should invalidate this CacheHolder
Note:
This does not affect any other CacheHolder
for our client node.
- depend_object(self, node)
- Depend on node's existence
- depend_signal(self, signal, sender=_Any)
- Depend on signal from sender
- set(self, data)
- Set data after instantiation
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
| |