vrml.cache
index
/home/mcfletch/pylive/vrml/cache.py

Caching mechanism for scene graph
 
Basically, the scenegraph Cache allows you to associate
data with particular nodes in the scene graph without
actually attaching the information to the particular
node being annotated.
 
This allows us to store cached information such as:
    display list objects
    texture objects
    compiled array geometry
 
The cache uses weak reference key dictionaries to clear
the cache of data associated with deleted nodes within
the scene graph.  similarly, cache is cleared when node
fields which are dependencies of the cache are changed.
 
The cache is based on the vrml.field and dispatch.dispatcher
modules.  All field objects by default provide dispatcher
notifications on set and delete, and can provide
notification on get as well.  The cache watches for these
notifications for dependent nodes where the dispatcher
messages are (type, fieldObject) for type in ("set","del").
 
There is a per-context cache, and a global cache, display-
lists, textures, etceteras should be stored in the per-
context cache, while data with dependencies only on the
node can be stored in the global cache.
 
Note:
    The cache makes extensive use of weak references, and
    was the failure case which exposed a number of problems
    with the Python 2.2.2 weakref and weakkeydictionary
    mechanisms.

 
Modules
       
pydispatch.dispatcher
vrml.field
vrml.protofunctions
traceback
weakref

 
Classes
       
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)

 
Functions
       
cleaner(cache, id)
Return callback function that cleans the given id from cache
getData(self, client, key='', default=None) method of Cache instance
Return the data for given client and key, default otherwise

 
Data
        CACHE = {}
__file__ = '/home/mcfletch/pylive/vrml/cache.pyc'
__name__ = 'vrml.cache'
__package__ = 'vrml'