summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--pym/portage.py77
-rw-r--r--pym/portage_util.py27
2 files changed, 58 insertions, 46 deletions
diff --git a/pym/portage.py b/pym/portage.py
index e986b4c92..11877a861 100644
--- a/pym/portage.py
+++ b/pym/portage.py
@@ -6472,28 +6472,23 @@ def getvirtuals(myroot):
return settings.getvirtuals(myroot)
def do_vartree(mysettings):
- class LazyVirtualsDict(dict):
+ class LazyVirtualsItem(object):
def __init__(self, myroot):
- super(LazyVirtualsDict, self).__init__()
- self.myroot = myroot
- self["virtuals"] = None
- def __getitem__(self, key):
- if "virtuals" == key:
- if "virtuals" in self:
- virtuals = super(LazyVirtualsDict, self).__getitem__("virtuals")
- if virtuals is not None:
- return virtuals
- else:
- global settings
- virtuals = settings.getvirtuals(self.myroot)
- self["virtuals"] = virtuals
- return virtuals
- return super(LazyVirtualsDict, self).__getitem__(key)
+ self._myroot = myroot
+ self._virtuals = None
+ def __call__(self):
+ if self._virtuals is None:
+ global settings
+ self._virtuals = settings.getvirtuals(self._myroot)
+ return self._virtuals
+
global db, root
- db["/"] = LazyVirtualsDict("/")
+ db["/"] = portage_util.LazyItemsDict()
+ db["/"].addLazyItem("virtuals", LazyVirtualsItem("/"))
db["/"]["vartree"] = vartree("/")
if root!="/":
- db[root] = LazyVirtualsDict(root)
+ db[root] = portage_util.LazyItemsDict()
+ db[root].addLazyItem("virtuals", LazyVirtualsItem(root))
db[root]["vartree"] = vartree(root)
#We need to create the vartree first, then load our settings, and then set up our other trees
@@ -6807,35 +6802,25 @@ if (secpass==2) and (not os.environ.has_key("SANDBOX_ACTIVE")):
global_updates()
#continue setting up other trees
-class LazyDatabasesDict(dict):
- """This class implements lazy construction of the global databases
- db[root]["porttree"] and db[root]["bintree"]."""
- def __init__(self, myroot, items):
- dict.__init__(self)
- self.update(items)
- self.myroot = myroot
- self.lazy_keys = ("porttree", "bintree")
- for x in self.lazy_keys:
- self[x] = None
- def __getitem__(self, item_key):
- if item_key in self.lazy_keys and item_key in self:
- myvalue = dict.__getitem__(self, item_key)
- if myvalue is None:
- if "porttree" == item_key:
- myvalue = portagetree(self.myroot)
- elif "bintree" == item_key:
- global settings
- myvalue = binarytree(self.myroot, settings["PKGDIR"])
- # The binarytree likely needs to be populated now, so we
- # do it now to make sure that all method calls are safe.
- myvalue.populate()
- self[item_key] = myvalue
- return myvalue
- return dict.__getitem__(self, item_key)
-
-db["/"] = LazyDatabasesDict("/", db["/"])
+class LazyBintreeItem(object):
+ """This class implements lazy construction of db[root]["bintree"]."""
+ def __init__(self, myroot):
+ self._myroot = myroot
+ self._bintree = None
+ def __call__(self):
+ if self._bintree is None:
+ global settings
+ self._bintree = binarytree(self._myroot, settings["PKGDIR"])
+ # The binarytree likely needs to be populated now, so we
+ # do it now to make sure that all method calls are safe.
+ self._bintree.populate()
+ return self._bintree
+
+db["/"]["porttree"] = portagetree("/")
+db["/"].addLazyItem("bintree", LazyBintreeItem("/"))
if root!="/":
- db[root] = LazyDatabasesDict(root, db[root])
+ db[root]["porttree"] = portagetree(root)
+ db[root].addLazyItem("bintree", LazyBintreeItem(root))
profileroots = [settings["PORTDIR"]+"/profiles/"]
for x in settings["PORTDIR_OVERLAY"].split():
diff --git a/pym/portage_util.py b/pym/portage_util.py
index 46a7d1052..6fd76090c 100644
--- a/pym/portage_util.py
+++ b/pym/portage_util.py
@@ -710,3 +710,30 @@ def ensure_dirs(dir_path, *args, **kwargs):
raise
perms_modified = apply_permissions(dir_path, *args, **kwargs)
return created_dir or perms_modified
+
+class LazyItemsDict(dict):
+ """A mapping object that behaves like a standard dict except that it allows
+ for lazy initialization of values via callable objects. Lazy items can be
+ overwritten and deleted just as normal items."""
+ def __init__(self):
+ dict.__init__(self)
+ self.lazy_items = {}
+ def addLazyItem(self, item_key, value_callable):
+ """Add a lazy item for the given key. When the item is requested,
+ value_callable will be called with no arguments."""
+ self.lazy_items[item_key] = value_callable
+ # make it show up in self.keys(), etc...
+ dict.__setitem__(self, item_key, None)
+ def __getitem__(self, item_key):
+ if item_key in self.lazy_items:
+ return self.lazy_items[item_key]()
+ 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]
+ dict.__setitem__(self, item_key, value)
+ def __delitem__(self, item_key):
+ if item_key in self.lazy_items:
+ del self.lazy_items[item_key]
+ dict.__delitem__(self, item_key)