home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / weakref.py < prev    next >
Text File  |  2003-12-30  |  8KB  |  303 lines
  1. """Weak reference support for Python.
  2.  
  3. This module is an implementation of PEP 205:
  4.  
  5. http://python.sourceforge.net/peps/pep-0205.html
  6. """
  7.  
  8. # Naming convention: Variables named "wr" are weak reference objects;
  9. # they are called this instead of "ref" to avoid name collisions with
  10. # the module-global ref() function imported from _weakref.
  11.  
  12. import UserDict
  13.  
  14. from _weakref import \
  15.      getweakrefcount, \
  16.      getweakrefs, \
  17.      ref, \
  18.      proxy, \
  19.      CallableProxyType, \
  20.      ProxyType, \
  21.      ReferenceType
  22.  
  23. from exceptions import ReferenceError
  24.  
  25.  
  26. ProxyTypes = (ProxyType, CallableProxyType)
  27.  
  28. __all__ = ["ref", "proxy", "getweakrefcount", "getweakrefs",
  29.            "WeakKeyDictionary", "ReferenceType", "ProxyType",
  30.            "CallableProxyType", "ProxyTypes", "WeakValueDictionary"]
  31.  
  32.  
  33. class WeakValueDictionary(UserDict.UserDict):
  34.     """Mapping class that references values weakly.
  35.  
  36.     Entries in the dictionary will be discarded when no strong
  37.     reference to the value exists anymore
  38.     """
  39.     # We inherit the constructor without worrying about the input
  40.     # dictionary; since it uses our .update() method, we get the right
  41.     # checks (if the other dictionary is a WeakValueDictionary,
  42.     # objects are unwrapped on the way out, and we always wrap on the
  43.     # way in).
  44.  
  45.     def __getitem__(self, key):
  46.         o = self.data[key]()
  47.         if o is None:
  48.             raise KeyError, key
  49.         else:
  50.             return o
  51.  
  52.     def __repr__(self):
  53.         return "<WeakValueDictionary at %s>" % id(self)
  54.  
  55.     def __setitem__(self, key, value):
  56.         self.data[key] = ref(value, self.__makeremove(key))
  57.  
  58.     def copy(self):
  59.         new = WeakValueDictionary()
  60.         for key, wr in self.data.items():
  61.             o = wr()
  62.             if o is not None:
  63.                 new[key] = o
  64.         return new
  65.  
  66.     def get(self, key, default=None):
  67.         try:
  68.             wr = self.data[key]
  69.         except KeyError:
  70.             return default
  71.         else:
  72.             o = wr()
  73.             if o is None:
  74.                 # This should only happen
  75.                 return default
  76.             else:
  77.                 return o
  78.  
  79.     def items(self):
  80.         L = []
  81.         for key, wr in self.data.items():
  82.             o = wr()
  83.             if o is not None:
  84.                 L.append((key, o))
  85.         return L
  86.  
  87.     def iteritems(self):
  88.         return WeakValuedItemIterator(self)
  89.  
  90.     def iterkeys(self):
  91.         return self.data.iterkeys()
  92.     __iter__ = iterkeys
  93.  
  94.     def itervalues(self):
  95.         return WeakValuedValueIterator(self)
  96.  
  97.     def popitem(self):
  98.         while 1:
  99.             key, wr = self.data.popitem()
  100.             o = wr()
  101.             if o is not None:
  102.                 return key, o
  103.  
  104.     def pop(self, key, *args):
  105.         try:
  106.             o = self.data.pop(key)()
  107.         except KeyError:
  108.             if args:
  109.                 return args[0]
  110.             raise
  111.         if o is None:
  112.             raise KeyError, key
  113.         else:
  114.             return o
  115.  
  116.     def setdefault(self, key, default):
  117.         try:
  118.             wr = self.data[key]
  119.         except KeyError:
  120.             self.data[key] = ref(default, self.__makeremove(key))
  121.             return default
  122.         else:
  123.             return wr()
  124.  
  125.     def update(self, dict):
  126.         d = self.data
  127.         for key, o in dict.items():
  128.             d[key] = ref(o, self.__makeremove(key))
  129.  
  130.     def values(self):
  131.         L = []
  132.         for wr in self.data.values():
  133.             o = wr()
  134.             if o is not None:
  135.                 L.append(o)
  136.         return L
  137.  
  138.     def __makeremove(self, key):
  139.         def remove(o, selfref=ref(self), key=key):
  140.             self = selfref()
  141.             if self is not None:
  142.                 del self.data[key]
  143.         return remove
  144.  
  145.  
  146. class WeakKeyDictionary(UserDict.UserDict):
  147.     """ Mapping class that references keys weakly.
  148.  
  149.     Entries in the dictionary will be discarded when there is no
  150.     longer a strong reference to the key. This can be used to
  151.     associate additional data with an object owned by other parts of
  152.     an application without adding attributes to those objects. This
  153.     can be especially useful with objects that override attribute
  154.     accesses.
  155.     """
  156.  
  157.     def __init__(self, dict=None):
  158.         self.data = {}
  159.         def remove(k, selfref=ref(self)):
  160.             self = selfref()
  161.             if self is not None:
  162.                 del self.data[k]
  163.         self._remove = remove
  164.         if dict is not None: self.update(dict)
  165.  
  166.     def __delitem__(self, key):
  167.         del self.data[ref(key)]
  168.  
  169.     def __getitem__(self, key):
  170.         return self.data[ref(key)]
  171.  
  172.     def __repr__(self):
  173.         return "<WeakKeyDictionary at %s>" % id(self)
  174.  
  175.     def __setitem__(self, key, value):
  176.         self.data[ref(key, self._remove)] = value
  177.  
  178.     def copy(self):
  179.         new = WeakKeyDictionary()
  180.         for key, value in self.data.items():
  181.             o = key()
  182.             if o is not None:
  183.                 new[o] = value
  184.         return new
  185.  
  186.     def get(self, key, default=None):
  187.         return self.data.get(ref(key),default)
  188.  
  189.     def has_key(self, key):
  190.         try:
  191.             wr = ref(key)
  192.         except TypeError:
  193.             return 0
  194.         return wr in self.data
  195.  
  196.     def __contains__(self, key):
  197.         try:
  198.             wr = ref(key)
  199.         except TypeError:
  200.             return 0
  201.         return wr in self.data
  202.  
  203.     def items(self):
  204.         L = []
  205.         for key, value in self.data.items():
  206.             o = key()
  207.             if o is not None:
  208.                 L.append((o, value))
  209.         return L
  210.  
  211.     def iteritems(self):
  212.         return WeakKeyedItemIterator(self)
  213.  
  214.     def iterkeys(self):
  215.         return WeakKeyedKeyIterator(self)
  216.     __iter__ = iterkeys
  217.  
  218.     def itervalues(self):
  219.         return self.data.itervalues()
  220.  
  221.     def keys(self):
  222.         L = []
  223.         for wr in self.data.keys():
  224.             o = wr()
  225.             if o is not None:
  226.                 L.append(o)
  227.         return L
  228.  
  229.     def popitem(self):
  230.         while 1:
  231.             key, value = self.data.popitem()
  232.             o = key()
  233.             if o is not None:
  234.                 return o, value
  235.  
  236.     def pop(self, key, *args):
  237.         return self.data.pop(ref(key), *args)
  238.  
  239.     def setdefault(self, key, default):
  240.         return self.data.setdefault(ref(key, self._remove),default)
  241.  
  242.     def update(self, dict):
  243.         d = self.data
  244.         for key, value in dict.items():
  245.             d[ref(key, self._remove)] = value
  246.  
  247.  
  248. class BaseIter:
  249.     def __iter__(self):
  250.         return self
  251.  
  252.  
  253. class WeakKeyedKeyIterator(BaseIter):
  254.     def __init__(self, weakdict):
  255.         self._next = weakdict.data.iterkeys().next
  256.  
  257.     def next(self):
  258.         while 1:
  259.             wr = self._next()
  260.             obj = wr()
  261.             if obj is not None:
  262.                 return obj
  263.  
  264.  
  265. class WeakKeyedItemIterator(BaseIter):
  266.     def __init__(self, weakdict):
  267.         self._next = weakdict.data.iteritems().next
  268.  
  269.     def next(self):
  270.         while 1:
  271.             wr, value = self._next()
  272.             key = wr()
  273.             if key is not None:
  274.                 return key, value
  275.  
  276.  
  277. class WeakValuedValueIterator(BaseIter):
  278.     def __init__(self, weakdict):
  279.         self._next = weakdict.data.itervalues().next
  280.  
  281.     def next(self):
  282.         while 1:
  283.             wr = self._next()
  284.             obj = wr()
  285.             if obj is not None:
  286.                 return obj
  287.  
  288.  
  289. class WeakValuedItemIterator(BaseIter):
  290.     def __init__(self, weakdict):
  291.         self._next = weakdict.data.iteritems().next
  292.  
  293.     def next(self):
  294.         while 1:
  295.             key, wr = self._next()
  296.             value = wr()
  297.             if value is not None:
  298.                 return key, value
  299.  
  300.  
  301. # no longer needed
  302. del UserDict
  303.