replace emerge.AtomSet with portage.sets.InternalPackageSet

svn path=/main/trunk/; revision=7279

1 files changed, 20 insertions, 74 deletions

diff --git a/pym/emerge/__init__.py b/pym/emerge/__init__.py
index 541be2c15..ab9b683c6 100644
--- a/pym/emerge/__init__.py
+++ b/pym/emerge/__init__.py
@@ -52,6 +52,7 @@ import portage.exception
 from portage.data import secpass
 from portage.util import normalize_path as normpath
 from portage.util import writemsg
+from portage.sets import InternalPackageSet
 
 from itertools import chain, izip
 from UserDict import DictMixin
@@ -566,7 +567,7 @@ def clean_world(vardb, cpv):
 	"""Remove a package from the world file when unmerged."""
 	world_set = WorldSet(vardb.settings)
 	world_set.lock()
-	world_set.load()
+	world_set.xload()
 	worldlist = list(world_set)
 	mykey = portage.cpv_getkey(cpv)
 	newworldlist = []
@@ -591,74 +592,20 @@ def clean_world(vardb, cpv):
 	world_set.save()
 	world_set.unlock()
 
-class AtomSet(object):
-	def __init__(self, atoms=None):
-		self._atoms = {}
-		if atoms:
-			self.update(atoms)
-	def clear(self):
-		self._atoms.clear()
-	def add(self, atom):
-		cp = portage.dep_getkey(atom)
-		cp_list = self._atoms.get(cp)
-		if cp_list is None:
-			cp_list = []
-			self._atoms[cp] = cp_list
-		if atom not in cp_list:
-			cp_list.append(atom)
-	def update(self, atoms):
-		for atom in atoms:
-			self.add(atom)
-	def __contains__(self, atom):
-		cp = portage.dep_getkey(atom)
-		if cp in self._atoms and atom in self._atoms[cp]:
-			return True
-		return False
-	def findAtomForPackage(self, cpv, metadata):
-		"""Return the best match for a given package from the arguments, or
-		None if there are no matches.  This matches virtual arguments against
-		the PROVIDE metadata.  This can raise an InvalidDependString exception
-		if an error occurs while parsing PROVIDE."""
-		cpv_slot = "%s:%s" % (cpv, metadata["SLOT"])
-		cp = portage.dep_getkey(cpv)
-		atoms = self._atoms.get(cp)
-		if atoms:
-			best_match = portage.best_match_to_list(cpv_slot, atoms)
-			if best_match:
-				return best_match
-		if not metadata["PROVIDE"]:
-			return None
-		provides = portage.flatten(portage.dep.use_reduce(
-			portage.dep.paren_reduce(metadata["PROVIDE"]),
-			uselist=metadata["USE"].split()))
-		for provide in provides:
-			provided_cp = portage.dep_getkey(provide)
-			atoms = self._atoms.get(provided_cp)
-			if atoms:
-				transformed_atoms = [atom.replace(provided_cp, cp) for atom in atoms]
-				best_match = portage.best_match_to_list(cpv_slot, transformed_atoms)
-				if best_match:
-					return atoms[transformed_atoms.index(best_match)]
-		return None
-	def __iter__(self):
-		for atoms in self._atoms.itervalues():
-			for atom in atoms:
-				yield atom
-
-class SystemSet(AtomSet):
+class SystemSet(InternalPackageSet):
 	def __init__(self, settings, **kwargs):
-		AtomSet.__init__(self, **kwargs)
+		InternalPackageSet.__init__(self, **kwargs)
 		self.update(getlist(settings, "system"))
 
-class WorldSet(AtomSet):
+class WorldSet(InternalPackageSet):
 	def __init__(self, settings, **kwargs):
-		AtomSet.__init__(self, **kwargs)
+		InternalPackageSet.__init__(self, **kwargs)
 		self.world_file = os.path.join(settings["ROOT"], portage.WORLD_FILE)
 		self._lock = None
 	def _ensure_dirs(self):
 		portage.util.ensure_dirs(os.path.dirname(self.world_file),
 			gid=portage.portage_gid, mode=02750, mask=02)
-	def load(self):
+	def xload(self):
 		self.clear()
 		self.update(portage.util.grabfile_package(self.world_file))
 	def save(self):
@@ -681,7 +628,7 @@ class RootConfig(object):
 		self.root = self.settings["ROOT"]
 		self.sets = {}
 		world_set = WorldSet(self.settings)
-		world_set.load()
+		world_set.xload()
 		self.sets["world"] = world_set
 		system_set = SystemSet(self.settings)
 		self.sets["system"] = system_set
@@ -1144,10 +1091,10 @@ class depgraph(object):
 		# contains all sets added to the graph
 		self._sets = {}
 		# contains atoms given as arguments
-		self._sets["args"] = AtomSet()
+		self._sets["args"] = InternalPackageSet()
 		# contains all atoms from all sets added to the graph, including
 		# atoms given as arguments
-		self._set_atoms = AtomSet()
+		self._set_atoms = InternalPackageSet()
 		# contains all nodes pulled in by self._set_atoms
 		self._set_nodes = set()
 		self.blocker_digraph = digraph()
@@ -2588,8 +2535,7 @@ class depgraph(object):
 		if verbosity is None:
 			verbosity = ("--quiet" in self.myopts and 1 or \
 				"--verbose" in self.myopts and 3 or 2)
-		favorites_set = AtomSet()
-		favorites_set.update(favorites)
+		favorites_set = InternalPackageSet(favorites)
 		changelogs=[]
 		p=[]
 		blockers = []
@@ -3069,10 +3015,10 @@ class depgraph(object):
 				pkg_system = False
 				pkg_world = False
 				try:
-					pkg_system = system_set.findAtomForPackage(pkg_key, metadata)
-					pkg_world  = world_set.findAtomForPackage(pkg_key, metadata)
+					pkg_system = system_set.containsCPV(pkg_key)
+					pkg_world  = world_set.containsCPV(pkg_key)
 					if not pkg_world and myroot == self.target_root and \
-						favorites_set.findAtomForPackage(pkg_key, metadata):
+						favorites_set.containsCPV(pkg_key):
 						# Maybe it will be added to world now.
 						if create_world_atom(pkg_key, metadata,
 							favorites_set, root_config):
@@ -3278,7 +3224,7 @@ class depgraph(object):
 		root_config = self.roots[self.target_root]
 		world_set = root_config.sets["world"]
 		world_set.lock()
-		world_set.load()
+		world_set.xload()
 		args_set = self._sets["args"]
 		portdb = self.trees[self.target_root]["porttree"].dbapi
 		added_favorites = set()
@@ -3537,7 +3483,7 @@ class MergeTask(object):
 
 		root_config = RootConfig(self.trees[self.target_root])
 		system_set = root_config.sets["system"]
-		args_set = AtomSet(favorites)
+		args_set = InternalPackageSet(favorites)
 		world_set = root_config.sets["world"]
 		if "--resume" not in self.myopts:
 			mymergelist = mylist
@@ -3634,7 +3580,7 @@ class MergeTask(object):
 			#buildsyspkg: Check if we need to _force_ binary package creation
 			issyspkg = ("buildsyspkg" in myfeat) \
 					and x[0] != "blocks" \
-					and system_set.findAtomForPackage(pkg_key, metadata) \
+					and system_set.containsCPV(pkg_key) \
 					and "--buildpkg" not in self.myopts
 			if x[0] in ["ebuild","blocks"]:
 				if x[0] == "blocks" and "--fetchonly" not in self.myopts:
@@ -3826,9 +3772,9 @@ class MergeTask(object):
 				self.trees[x[1]]["vartree"].inject(x[2])
 				myfavkey = portage.cpv_getkey(x[2])
 				if not fetchonly and not pretend and \
-					args_set.findAtomForPackage(pkg_key, metadata):
+					args_set.containsCPV(pkg_key):
 					world_set.lock()
-					world_set.load()
+					world_set.xload()
 					myfavkey = create_world_atom(pkg_key, metadata,
 						args_set, root_config)
 					if myfavkey:
@@ -5352,7 +5298,7 @@ def action_depclean(settings, trees, ldpath_mtimes,
 	system_set = SystemSet(settings)
 	syslist = list(system_set)
 	world_set = WorldSet(settings)
-	world_set.load()
+	world_set.xload()
 	worldlist = list(world_set)
 	fakedb = portage.fakedbapi(settings=settings)
 	myvarlist = vardb.cpv_all()