Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes
weakref.WeakKeyDictionary Class Reference
Inheritance diagram for weakref.WeakKeyDictionary:
Inheritance graph
[legend]
Collaboration diagram for weakref.WeakKeyDictionary:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def __delitem__
def __getitem__
def __len__
def __repr__
def __setitem__
def copy
def __deepcopy__
def get
def __contains__
def items
def keys
def values
def keyrefs
def popitem
def pop
def setdefault
def update
def clear
def update
def __eq__
def __ne__
def __subclasshook__
def __subclasshook__
def __subclasshook__
def __new__
def __new__
def __new__
def register
def register
def register
def __instancecheck__
def __instancecheck__
def __instancecheck__
def __subclasscheck__
def __subclasscheck__
def __subclasscheck__
def __iter__

Public Attributes

 data

Private Member Functions

def _commit_removals

Private Attributes

 _remove
 _pending_removals
 _iterating

Static Private Attributes

 __copy__ = copy
 __iter__ = keys

Detailed Description

Mapping class that references keys weakly.

Entries in the dictionary will be discarded when there is no
longer a strong reference to the key. This can be used to
associate additional data with an object owned by other parts of
an application without adding attributes to those objects. This
can be especially useful with objects that override attribute
accesses.

Definition at line 246 of file weakref.py.


Constructor & Destructor Documentation

def weakref.WeakKeyDictionary.__init__ (   self,
  dict = None 
)

Definition at line 257 of file weakref.py.

00257 
00258     def __init__(self, dict=None):
00259         self.data = {}
00260         def remove(k, selfref=ref(self)):
00261             self = selfref()
00262             if self is not None:
00263                 if self._iterating:
00264                     self._pending_removals.append(k)
00265                 else:
00266                     del self.data[k]
00267         self._remove = remove
00268         # A list of dead weakrefs (keys to be removed)
00269         self._pending_removals = []
00270         self._iterating = set()
00271         if dict is not None:
00272             self.update(dict)

Here is the caller graph for this function:


Member Function Documentation

def weakref.WeakKeyDictionary.__contains__ (   self,
  key 
)

Reimplemented from _abcoll.Mapping.

Definition at line 323 of file weakref.py.

00323 
00324     def __contains__(self, key):
00325         try:
00326             wr = ref(key)
00327         except TypeError:
00328             return False
00329         return wr in self.data

def weakref.WeakKeyDictionary.__deepcopy__ (   self,
  memo 
)

Definition at line 311 of file weakref.py.

00311 
00312     def __deepcopy__(self, memo):
00313         from copy import deepcopy
00314         new = self.__class__()
00315         for key, value in self.data.items():
00316             o = key()
00317             if o is not None:
00318                 new[o] = deepcopy(value, memo)
00319         return new

Here is the call graph for this function:

def weakref.WeakKeyDictionary.__delitem__ (   self,
  key 
)

Reimplemented from _abcoll.MutableMapping.

Definition at line 286 of file weakref.py.

00286 
00287     def __delitem__(self, key):
00288         del self.data[ref(key)]

def _abcoll.Mapping.__eq__ (   self,
  other 
) [inherited]

Definition at line 380 of file _abcoll.py.

00380 
00381     def __eq__(self, other):
00382         if not isinstance(other, Mapping):
00383             return NotImplemented
00384         return dict(self.items()) == dict(other.items())

Here is the call graph for this function:

Here is the caller graph for this function:

def weakref.WeakKeyDictionary.__getitem__ (   self,
  key 
)

Reimplemented from _abcoll.Mapping.

Definition at line 289 of file weakref.py.

00289 
00290     def __getitem__(self, key):
00291         return self.data[ref(key)]

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def abc.ABCMeta.__instancecheck__ (   cls,
  instance 
) [inherited]
Override for isinstance(instance, cls).

Definition at line 158 of file abc.py.

00158 
00159     def __instancecheck__(cls, instance):
00160         """Override for isinstance(instance, cls)."""
00161         # Inline the cache checking
00162         subclass = instance.__class__
00163         if subclass in cls._abc_cache:
00164             return True
00165         subtype = type(instance)
00166         if subtype is subclass:
00167             if (cls._abc_negative_cache_version ==
00168                 ABCMeta._abc_invalidation_counter and
00169                 subclass in cls._abc_negative_cache):
00170                 return False
00171             # Fall back to the subclass check.
00172             return cls.__subclasscheck__(subclass)
00173         return any(cls.__subclasscheck__(c) for c in {subclass, subtype})

Here is the call graph for this function:

def _abcoll.Iterable.__iter__ (   self) [inherited]

Reimplemented in collections.UserDict, test.support.EnvironmentVarGuard, collections._ChainMap, _abcoll.Sequence, os._Environ, _abcoll.ItemsView, _abcoll.KeysView, shelve.Shelf, and _abcoll.Iterator.

Definition at line 69 of file _abcoll.py.

00069 
00070     def __iter__(self):
00071         while False:
00072             yield None

Reimplemented from _abcoll.Sized.

Definition at line 292 of file weakref.py.

00292 
00293     def __len__(self):
00294         return len(self.data)

def _abcoll.Mapping.__ne__ (   self,
  other 
) [inherited]

Definition at line 385 of file _abcoll.py.

00385 
00386     def __ne__(self, other):
00387         return not (self == other)
00388 

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

def abc.ABCMeta.__new__ (   mcls,
  name,
  bases,
  namespace 
) [inherited]

Definition at line 116 of file abc.py.

00116 
00117     def __new__(mcls, name, bases, namespace):
00118         cls = super().__new__(mcls, name, bases, namespace)
00119         # Compute set of abstract method names
00120         abstracts = {name
00121                      for name, value in namespace.items()
00122                      if getattr(value, "__isabstractmethod__", False)}
00123         for base in bases:
00124             for name in getattr(base, "__abstractmethods__", set()):
00125                 value = getattr(cls, name, None)
00126                 if getattr(value, "__isabstractmethod__", False):
00127                     abstracts.add(name)
00128         cls.__abstractmethods__ = frozenset(abstracts)
00129         # Set up inheritance registry
00130         cls._abc_registry = WeakSet()
00131         cls._abc_cache = WeakSet()
00132         cls._abc_negative_cache = WeakSet()
00133         cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00134         return cls

Here is the call graph for this function:

Definition at line 295 of file weakref.py.

00295 
00296     def __repr__(self):
00297         return "<WeakKeyDictionary at %s>" % id(self)

def weakref.WeakKeyDictionary.__setitem__ (   self,
  key,
  value 
)

Reimplemented from _abcoll.MutableMapping.

Definition at line 298 of file weakref.py.

00298 
00299     def __setitem__(self, key, value):
00300         self.data[ref(key, self._remove)] = value

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def abc.ABCMeta.__subclasscheck__ (   cls,
  subclass 
) [inherited]
Override for issubclass(subclass, cls).

Definition at line 174 of file abc.py.

00174 
00175     def __subclasscheck__(cls, subclass):
00176         """Override for issubclass(subclass, cls)."""
00177         # Check cache
00178         if subclass in cls._abc_cache:
00179             return True
00180         # Check negative cache; may have to invalidate
00181         if cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter:
00182             # Invalidate the negative cache
00183             cls._abc_negative_cache = WeakSet()
00184             cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
00185         elif subclass in cls._abc_negative_cache:
00186             return False
00187         # Check the subclass hook
00188         ok = cls.__subclasshook__(subclass)
00189         if ok is not NotImplemented:
00190             assert isinstance(ok, bool)
00191             if ok:
00192                 cls._abc_cache.add(subclass)
00193             else:
00194                 cls._abc_negative_cache.add(subclass)
00195             return ok
00196         # Check if it's a direct subclass
00197         if cls in getattr(subclass, '__mro__', ()):
00198             cls._abc_cache.add(subclass)
00199             return True
00200         # Check if it's a subclass of a registered class (recursive)
00201         for rcls in cls._abc_registry:
00202             if issubclass(subclass, rcls):
00203                 cls._abc_cache.add(subclass)
00204                 return True
00205         # Check if it's a subclass of a subclass (recursive)
00206         for scls in cls.__subclasses__():
00207             if issubclass(subclass, scls):
00208                 cls._abc_cache.add(subclass)
00209                 return True
00210         # No dice; update negative cache
00211         cls._abc_negative_cache.add(subclass)
00212         return False

Here is the call graph for this function:

def _abcoll.Iterable.__subclasshook__ (   cls,
  C 
) [inherited]

Reimplemented in _abcoll.Iterator.

Definition at line 74 of file _abcoll.py.

00074 
00075     def __subclasshook__(cls, C):
00076         if cls is Iterable:
00077             if any("__iter__" in B.__dict__ for B in C.__mro__):
00078                 return True
00079         return NotImplemented
00080 

Here is the call graph for this function:

def _abcoll.Sized.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 119 of file _abcoll.py.

00119 
00120     def __subclasshook__(cls, C):
00121         if cls is Sized:
00122             if any("__len__" in B.__dict__ for B in C.__mro__):
00123                 return True
00124         return NotImplemented
00125 

Here is the call graph for this function:

def _abcoll.Container.__subclasshook__ (   cls,
  C 
) [inherited]

Definition at line 133 of file _abcoll.py.

00133 
00134     def __subclasshook__(cls, C):
00135         if cls is Container:
00136             if any("__contains__" in B.__dict__ for B in C.__mro__):
00137                 return True
00138         return NotImplemented
00139 

Here is the call graph for this function:

Definition at line 273 of file weakref.py.

00273 
00274     def _commit_removals(self):
00275         # NOTE: We don't need to call this method before mutating the dict,
00276         # because a dead weakref never compares equal to a live weakref,
00277         # even if they happened to refer to equal objects.
00278         # However, it means keys may already have been removed.
00279         l = self._pending_removals
00280         d = self.data
00281         while l:
00282             try:
00283                 del d[l.pop()]
00284             except KeyError:
00285                 pass

def _abcoll.MutableMapping.clear (   self) [inherited]

Reimplemented in collections._ChainMap.

Definition at line 486 of file _abcoll.py.

00486 
00487     def clear(self):
00488         try:
00489             while True:
00490                 self.popitem()
00491         except KeyError:
00492             pass

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 301 of file weakref.py.

00301 
00302     def copy(self):
00303         new = WeakKeyDictionary()
00304         for key, value in self.data.items():
00305             o = key()
00306             if o is not None:
00307                 new[o] = value
00308         return new

def weakref.WeakKeyDictionary.get (   self,
  key,
  default = None 
)

Reimplemented from _abcoll.Mapping.

Definition at line 320 of file weakref.py.

00320 
00321     def get(self, key, default=None):
00322         return self.data.get(ref(key),default)

Here is the caller graph for this function:

Reimplemented from _abcoll.Mapping.

Definition at line 330 of file weakref.py.

00330 
00331     def items(self):
00332         with _IterationGuard(self):
00333             for wr, value in self.data.items():
00334                 key = wr()
00335                 if key is not None:
00336                     yield key, value

Here is the caller graph for this function:

Return a list of weak references to the keys.

The references are not guaranteed to be 'live' at the time
they are used, so the result of calling the references needs
to be checked before being used.  This can be used to avoid
creating references that will cause the garbage collector to
keep the keys around longer than needed.

Definition at line 352 of file weakref.py.

00352 
00353     def keyrefs(self):
00354         """Return a list of weak references to the keys.
00355 
00356         The references are not guaranteed to be 'live' at the time
00357         they are used, so the result of calling the references needs
00358         to be checked before being used.  This can be used to avoid
00359         creating references that will cause the garbage collector to
00360         keep the keys around longer than needed.
00361 
00362         """
00363         return list(self.data)

Reimplemented from _abcoll.Mapping.

Definition at line 337 of file weakref.py.

00337 
00338     def keys(self):
00339         with _IterationGuard(self):
00340             for wr in self.data:
00341                 obj = wr()
00342                 if obj is not None:
00343                     yield obj

def weakref.WeakKeyDictionary.pop (   self,
  key,
  args 
)

Reimplemented from _abcoll.MutableMapping.

Definition at line 371 of file weakref.py.

00371 
00372     def pop(self, key, *args):
00373         return self.data.pop(ref(key), *args)

Reimplemented from _abcoll.MutableMapping.

Definition at line 364 of file weakref.py.

00364 
00365     def popitem(self):
00366         while True:
00367             key, value = self.data.popitem()
00368             o = key()
00369             if o is not None:
00370                 return o, value

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def abc.ABCMeta.register (   cls,
  subclass 
) [inherited]
Register a virtual subclass of an ABC.

Definition at line 135 of file abc.py.

00135 
00136     def register(cls, subclass):
00137         """Register a virtual subclass of an ABC."""
00138         if not isinstance(subclass, type):
00139             raise TypeError("Can only register classes")
00140         if issubclass(subclass, cls):
00141             return  # Already a subclass
00142         # Subtle: test for cycles *after* testing for "already a subclass";
00143         # this means we allow X.register(X) and interpret it as a no-op.
00144         if issubclass(cls, subclass):
00145             # This would create a cycle, which is bad for the algorithm below
00146             raise RuntimeError("Refusing to create an inheritance cycle")
00147         cls._abc_registry.add(subclass)
00148         ABCMeta._abc_invalidation_counter += 1  # Invalidate negative cache

Here is the caller graph for this function:

def weakref.WeakKeyDictionary.setdefault (   self,
  key,
  default = None 
)

Reimplemented from _abcoll.MutableMapping.

Definition at line 374 of file weakref.py.

00374 
00375     def setdefault(self, key, default=None):
00376         return self.data.setdefault(ref(key, self._remove),default)

def weakref.WeakKeyDictionary.update (   self,
  dict = None,
  kwargs 
)

Definition at line 377 of file weakref.py.

00377 
00378     def update(self, dict=None, **kwargs):
00379         d = self.data
00380         if dict is not None:
00381             if not hasattr(dict, "items"):
00382                 dict = type({})(dict)
00383             for key, value in dict.items():
00384                 d[ref(key, self._remove)] = value
00385         if len(kwargs):
00386             self.update(kwargs)

Here is the call graph for this function:

Here is the caller graph for this function:

def _abcoll.MutableMapping.update (   args,
  kwds 
) [inherited]

Definition at line 493 of file _abcoll.py.

00493 
00494     def update(*args, **kwds):
00495         if len(args) > 2:
00496             raise TypeError("update() takes at most 2 positional "
00497                             "arguments ({} given)".format(len(args)))
00498         elif not args:
00499             raise TypeError("update() takes at least 1 argument (0 given)")
00500         self = args[0]
00501         other = args[1] if len(args) >= 2 else ()
00502 
00503         if isinstance(other, Mapping):
00504             for key in other:
00505                 self[key] = other[key]
00506         elif hasattr(other, "keys"):
00507             for key in other.keys():
00508                 self[key] = other[key]
00509         else:
00510             for key, value in other:
00511                 self[key] = value
00512         for key, value in kwds.items():
00513             self[key] = value

Here is the caller graph for this function:

Reimplemented from _abcoll.Mapping.

Definition at line 346 of file weakref.py.

00346 
00347     def values(self):
00348         with _IterationGuard(self):
00349             for wr, value in self.data.items():
00350                 if wr() is not None:
00351                     yield value

Here is the caller graph for this function:


Member Data Documentation

Definition at line 309 of file weakref.py.

Definition at line 344 of file weakref.py.

Definition at line 269 of file weakref.py.

Definition at line 268 of file weakref.py.

Definition at line 266 of file weakref.py.

Definition at line 258 of file weakref.py.


The documentation for this class was generated from the following file: