Simplify LazyItemsDict internals. (trunk r12773)

svn path=/main/branches/2.1.6/; revision=13017

diff --git a/pym/portage/util.py b/pym/portage/util.py
index 98a01c791cb5cc31718b59b6fb121cc28bbadcb5..c84f351beb2ecf00c14870a5e54beb6b380b86e6 100644 (file)
--- a/pym/portage/util.py
+++ b/pym/portage/util.py
@@ -1071,19 +1071,18 @@ class LazyItemsDict(dict):
        def addLazyItem(self, item_key, value_callable, *pargs, **kwargs):
                """Add a lazy item for the given key.  When the item is requested,
                value_callable will be called with *pargs and **kwargs arguments."""
-               if not pargs:
-                       pargs = None
-               if not kwargs:
-                       kwargs = None
-               self.lazy_items[item_key] = (value_callable, pargs, kwargs)
+               self.lazy_items[item_key] = \
+                       self._LazyItem(value_callable, pargs, kwargs, False)
                # make it show up in self.keys(), etc...
                dict.__setitem__(self, item_key, None)
+
        def addLazySingleton(self, item_key, value_callable, *pargs, **kwargs):
                """This is like addLazyItem except value_callable will only be called
                a maximum of 1 time and the result will be cached for future requests."""
-               self.addLazyItem(item_key,
-                       self._SingletonWrapper(self, item_key, value_callable),
-                               *pargs, **kwargs)
+               self.lazy_items[item_key] = \
+                       self._LazyItem(value_callable, pargs, kwargs, True)
+               # make it show up in self.keys(), etc...
+               dict.__setitem__(self, item_key, None)
 
        def update(self, *args, **kwargs):
                if len(args) > 1:
@@ -1102,12 +1101,7 @@ class LazyItemsDict(dict):
                                        dict.__setitem__(self, k, None)
                                else:
                                        dict.__setitem__(self, k, map_obj[k])
-                       for k, v in map_obj.lazy_items.iteritems():
-                               if isinstance(v[0], self._SingletonWrapper):
-                                       # Create a new wrapper that references self.
-                                       v = (self._SingletonWrapper(self, k, v[0]._callable),
-                                               v[1], v[2])
-                               self.lazy_items[k] = v
+                       self.lazy_items.update(map_obj.lazy_items)
                else:
                        dict.update(self, map_obj)
                if kwargs:
@@ -1115,14 +1109,21 @@ class LazyItemsDict(dict):
 
        def __getitem__(self, item_key):
                if item_key in self.lazy_items:
-                       value_callable, pargs, kwargs = self.lazy_items[item_key]
+                       lazy_item = self.lazy_items[item_key]
+                       pargs = lazy_item.pargs
                        if pargs is None:
                                pargs = ()
+                       kwargs = lazy_item.kwargs
                        if kwargs is None:
                                kwargs = {}
-                       return value_callable(*pargs, **kwargs)
+                       result = lazy_item.func(*pargs, **kwargs)
+                       if lazy_item.singleton:
+                               self[item_key] = result
+                       return result
+
                else:
                        return dict.__getitem__(self, item_key)
+
        def __setitem__(self, item_key, value):
                if item_key in self.lazy_items:
                        del self.lazy_items[item_key]
@@ -1176,7 +1177,7 @@ class LazyItemsDict(dict):
                                except TypeError:
                                        # If deepcopy fails for a lazy singleton, try to
                                        # evaluate the singleton and deepcopy the result.
-                                       if not isinstance(lazy_item[0], self._SingletonWrapper):
+                                       if not lazy_item.singleton:
                                                raise
                                        dict.__setitem__(result, k_copy, deepcopy(self[k], memo))
                                else:
@@ -1185,19 +1186,21 @@ class LazyItemsDict(dict):
                                dict.__setitem__(result, k_copy, deepcopy(self[k], memo))
                return result
 
-       class _SingletonWrapper(object):
+       class _LazyItem(object):
+
+               __slots__ = ('func', 'pargs', 'kwargs', 'singleton')
 
-               __slots__ = ('_parent', '_key', '_callable')
+               def __init__(self, func, pargs, kwargs, singleton):
 
-               def __init__(self, parent, key, value_callable):
-                       self._parent = parent
-                       self._key = key
-                       self._callable = value_callable
+                       if not pargs:
+                               pargs = None
+                       if not kwargs:
+                               kwargs = None
 
-               def __call__(self, *pargs, **kwargs):
-                       value = self._callable(*pargs, **kwargs)
-                       self._parent[self._key] = value
-                       return value
+                       self.func = func
+                       self.pargs = pargs
+                       self.kwargs = kwargs
+                       self.singleton = singleton
 
 class ConfigProtect(object):
        def __init__(self, myroot, protect_list, mask_list):