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

list sub-class which holds weak references to objects

 
Modules
       
weakref

 
Classes
       
list(object)
WeakList

 
class WeakList(list)
    list sub-class holding weakrefs to items
 
The weak reference list is intended to allow you
to store references to a list of objects without
needing to manage weak references directly.
 
For the most part, the WeakList operates just
like a list object, in that it allows for all
of the standard list operations.  The difference
is that the WeakList class only stores weak
references to its items. As a result, adding
an object to the list does not necessarily mean
that it will still be there later on during
execution (if the referent has been garbage
collected).
 
 
Method resolution order:
WeakList
list
object

Methods defined here:
__contains__(self, item)
Return boolean indicating whether the item is in the list
__eq__(self, sequence)
Compare the list to another (==)
__ge__(self, sequence)
Compare the list to another (>=)
__getitem__(self, index)
Get the item at the given index
__getslice__(self, start, stop)
Get the items in the range start to stop
__gt__(self, sequence)
Compare the list to another (>)
__iadd__ = extend(self, sequence)
__init__(self, sequence=())
Initialize the list, with an optional sequence of objects
 
The WeakList will store weak references to objects
within the sequence.
__iter__(self)
Iterate over the list, yielding strong references
__le__(self, sequence)
Compare the list to another (<=)
__lt__(self, sequence)
Compare the list to another (<)
__ne__(self, sequence)
Compare the list to another (!=)
__repr__(self)
Return a code-like representation of the weak list
__setitem__(self, index, item)
Set the item at the given index
__setslice__(self, start, stop, sequence)
Set a sequence of items from the start to the stop index
append(self, item)
Append a single item to the list
count(self, item)
Return integer count of instances of item in list
extend(self, sequence)
Extend this list with another sequence
get(self)
Get all items as a list of strong references
index(self, item)
Return integer index of item in list
insert(self, index, item)
Insert an item at the given index
pop(self, index=-1)
Pop an item from the list, removing it and returning it
remove(self, item)
Remove the given item from the list
sort(self, function=None)
Sort the list of objects
 
This sorts the objects referenced,
then rebuilds the list of references!
unwrap(self, item)
Unwrap an individual item
 
This is a fairly trivial operation at the moment,
it merely calls the item with no arguments and
returns the result.
wrap(self, item)
Wrap an individual item in a weak-reference
 
If the item is already a weak reference, we store
a reference to the original item.  We use approximately
the same weak reference callback mechanism as the
standard weakref.WeakKeyDictionary object.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from list:
__add__(...)
x.__add__(y) <==> x+y
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__imul__(...)
x.__imul__(y) <==> x*=y
__len__(...)
x.__len__() <==> len(x)
__mul__(...)
x.__mul__(n) <==> x*n
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(...)
x.__rmul__(n) <==> n*x
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
reverse(...)
L.reverse() -- reverse *IN PLACE*

Data and other attributes inherited from list:
__hash__ = None
__new__ = <built-in method __new__ of type object at 0x8187c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
Data
        __file__ = '/home/mcfletch/pylive/vrml/weaklist.pyc'
__name__ = 'vrml.weaklist'
__package__ = 'vrml'
generators = _Feature((2, 2, 0, 'alpha', 1), (2, 3, 0, 'final', 0), 0)