[apt.git] / apt-private / private-cacheset.h

#ifndef APT_PRIVATE_CACHESET_H
#define APT_PRIVATE_CACHESET_H

#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/cachefile.h>
#include <apt-pkg/cacheset.h>
#include <apt-pkg/sptr.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/error.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/macros.h>

#include <algorithm>
#include <vector>
#include <string.h>
#include <list>
#include <ostream>
#include <set>
#include <string>
#include <utility>

#include "private-output.h"

#include <apti18n.h>

class OpProgress;

struct VersionSortDescriptionLocality
{
   bool operator () (const pkgCache::VerIterator &v_lhs, 
                     const pkgCache::VerIterator &v_rhs)
    {
       pkgCache::DescFile const *A = NULL;
       pkgCache::DescFile const *B = NULL;
       if (v_lhs->DescriptionList != 0)
	  A = v_lhs.TranslatedDescription().FileList();
       if (v_rhs->DescriptionList != 0)
	  B = v_rhs.TranslatedDescription().FileList();

       if (A == 0 && B == 0)
	  return false;

       if (A == 0)
          return true;

       if (B == 0)
          return false;

       if (A->File == B->File)
          return A->Offset < B->Offset;

       return A->File < B->File;
    }
};

// sorted by locality which makes iterating much faster
typedef APT::VersionContainer<
   std::set<pkgCache::VerIterator,
            VersionSortDescriptionLocality> > LocalitySortedVersionSet;

class Matcher {
public:
    virtual bool operator () (const pkgCache::PkgIterator &/*P*/) {
        return true;}
};

// FIXME: add default argument for OpProgress (or overloaded function)
bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
                                    APT::VersionContainerInterface * const vci,
                                    Matcher &matcher,
                                    OpProgress * const progress);
bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
                                    APT::VersionContainerInterface * const vci,
                                    OpProgress * const progress);


// CacheSetHelper saving virtual packages				/*{{{*/
class CacheSetHelperVirtuals: public APT::CacheSetHelper {
public:
   APT::PackageSet virtualPkgs;

   virtual pkgCache::VerIterator canNotGetVersion(enum CacheSetHelper::VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
      if (select == NEWEST || select == CANDIDATE || select == ALL)
	 virtualPkgs.insert(Pkg);
      return CacheSetHelper::canNotGetVersion(select, Cache, Pkg);
   }

   virtual void canNotFindVersion(enum CacheSetHelper::VerSelector const select, APT::VersionContainerInterface * vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
      if (select == NEWEST || select == CANDIDATE || select == ALL)
	 virtualPkgs.insert(Pkg);
      return CacheSetHelper::canNotFindVersion(select, vci, Cache, Pkg);
   }

   CacheSetHelperVirtuals(bool const ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
};
									/*}}}*/

// CacheSetHelperAPTGet - responsible for message telling from the CacheSets/*{{{*/
class CacheSetHelperAPTGet : public APT::CacheSetHelper {
	/** \brief stream message should be printed to */
	std::ostream &out;
	/** \brief were things like Task or RegEx used to select packages? */
	bool explicitlyNamed;

	APT::PackageSet virtualPkgs;

public:
	std::list<std::pair<pkgCache::VerIterator, std::string> > selectedByRelease;

	CacheSetHelperAPTGet(std::ostream &out) : APT::CacheSetHelper(true), out(out) {
		explicitlyNamed = true;
	}

	virtual void showTaskSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
		ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
				Pkg.FullName(true).c_str(), pattern.c_str());
		explicitlyNamed = false;
	}
        virtual void showFnmatchSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
		ioprintf(out, _("Note, selecting '%s' for glob '%s'\n"),
				Pkg.FullName(true).c_str(), pattern.c_str());
		explicitlyNamed = false;
	}
	virtual void showRegExSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
		ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
				Pkg.FullName(true).c_str(), pattern.c_str());
		explicitlyNamed = false;
	}
	virtual void showSelectedVersion(pkgCache::PkgIterator const &/*Pkg*/, pkgCache::VerIterator const Ver,
				 std::string const &ver, bool const /*verIsRel*/) APT_OVERRIDE {
		if (ver == Ver.VerStr())
			return;
		selectedByRelease.push_back(make_pair(Ver, ver));
	}

	bool showVirtualPackageErrors(pkgCacheFile &Cache) {
		if (virtualPkgs.empty() == true)
			return true;
		for (APT::PackageSet::const_iterator Pkg = virtualPkgs.begin();
		     Pkg != virtualPkgs.end(); ++Pkg) {
			if (Pkg->ProvidesList != 0) {
				ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
					 Pkg.FullName(true).c_str());

				pkgCache::PrvIterator I = Pkg.ProvidesList();
				unsigned short provider = 0;
				for (; I.end() == false; ++I) {
					pkgCache::PkgIterator Pkg = I.OwnerPkg();

					if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
						c1out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
						if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
							c1out << _(" [Installed]");
						c1out << std::endl;
						++provider;
					}
				}
				// if we found no candidate which provide this package, show non-candidates
				if (provider == 0)
					for (I = Pkg.ProvidesList(); I.end() == false; ++I)
						c1out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
                                                      << _(" [Not candidate version]") << std::endl;
				else
                                   out << _("You should explicitly select one to install.") << std::endl;
			} else {
				ioprintf(c1out,
					_("Package %s is not available, but is referred to by another package.\n"
					  "This may mean that the package is missing, has been obsoleted, or\n"
					  "is only available from another source\n"),Pkg.FullName(true).c_str());

				std::string List;
				std::string VersionsList;
				SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];
				memset(Seen,0,Cache.GetPkgCache()->Head().PackageCount*sizeof(*Seen));
				for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
				     Dep.end() == false; ++Dep) {
					if (Dep->Type != pkgCache::Dep::Replaces)
						continue;
					if (Seen[Dep.ParentPkg()->ID] == true)
						continue;
					Seen[Dep.ParentPkg()->ID] = true;
					List += Dep.ParentPkg().FullName(true) + " ";
					//VersionsList += std::string(Dep.ParentPkg().CurVersion) + "\n"; ???
				}
				ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
			}
			c1out << std::endl;
		}
		return false;
	}

	virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
		APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::CANDIDATE);
		if (verset.empty() == false)
			return *(verset.begin());
		else if (ShowError == true) {
			_error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
			virtualPkgs.insert(Pkg);
		}
		return pkgCache::VerIterator(Cache, 0);
	}

	virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
		if (Pkg->ProvidesList != 0)
		{
			APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::NEWEST);
			if (verset.empty() == false)
				return *(verset.begin());
			if (ShowError == true)
				ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
		}
		else
		{
			pkgCache::GrpIterator Grp = Pkg.Group();
			pkgCache::PkgIterator P = Grp.PackageList();
			for (; P.end() != true; P = Grp.NextPkg(P))
			{
				if (P == Pkg)
					continue;
				if (P->CurrentVer != 0) {
					// TRANSLATORS: Note, this is not an interactive question
					ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
						 Pkg.FullName(true).c_str(), P.FullName(true).c_str());
					break;
				}
			}
			if (P.end() == true)
				ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
		}
		return pkgCache::VerIterator(Cache, 0);
	}

	APT::VersionSet tryVirtualPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg,
						CacheSetHelper::VerSelector const select) {
		/* This is a pure virtual package and there is a single available
		   candidate providing it. */
		if (unlikely(Cache[Pkg].CandidateVer != 0) || Pkg->ProvidesList == 0)
			return APT::VersionSet();

		pkgCache::PkgIterator Prov;
		bool found_one = false;
		for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; ++P) {
			pkgCache::VerIterator const PVer = P.OwnerVer();
			pkgCache::PkgIterator const PPkg = PVer.ParentPkg();

			/* Ignore versions that are not a candidate. */
			if (Cache[PPkg].CandidateVer != PVer)
				continue;

			if (found_one == false) {
				Prov = PPkg;
				found_one = true;
			} else if (PPkg != Prov) {
				// same group, so it's a foreign package
				if (PPkg->Group == Prov->Group) {
					// do we already have the requested arch?
					if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 ||
					    strcmp(Prov.Arch(), "all") == 0 ||
					    unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
						continue;
					// see which architecture we prefer more and switch to it
					std::vector<std::string> archs = APT::Configuration::getArchitectures();
					if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
						Prov = PPkg;
					continue;
				}
				found_one = false; // we found at least two
				break;
			}
		}

		if (found_one == true) {
			ioprintf(out, _("Note, selecting '%s' instead of '%s'\n"),
				 Prov.FullName(true).c_str(), Pkg.FullName(true).c_str());
			return APT::VersionSet::FromPackage(Cache, Prov, select, *this);
		}
		return APT::VersionSet();
	}

	inline bool allPkgNamedExplicitly() const { return explicitlyNamed; }

};
									/*}}}*/

#endif
Commit	Line	Data
b9179170 MV	1	#ifndef APT_PRIVATE_CACHESET_H
	2	#define APT_PRIVATE_CACHESET_H
	3
453b82a3	4	#include <apt-pkg/aptconfiguration.h>
b9179170 MV	5	#include <apt-pkg/cachefile.h>
	6	#include <apt-pkg/cacheset.h>
	7	#include <apt-pkg/sptr.h>
453b82a3 DK	8	#include <apt-pkg/strutl.h>
	9	#include <apt-pkg/depcache.h>
	10	#include <apt-pkg/error.h>
	11	#include <apt-pkg/pkgcache.h>
	12	#include <apt-pkg/cacheiterators.h>
	13	#include <apt-pkg/macros.h>
b9179170 MV	14
	15	#include <algorithm>
	16	#include <vector>
453b82a3 DK	17	#include <string.h>
	18	#include <list>
	19	#include <ostream>
	20	#include <set>
	21	#include <string>
	22	#include <utility>
b9179170 MV	23
	24	#include "private-output.h"
	25
	26	#include <apti18n.h>
	27
453b82a3 DK	28	class OpProgress;
453b82a3 DK	29
b9179170 MV	30	struct VersionSortDescriptionLocality
	31	{
	32	bool operator () (const pkgCache::VerIterator &v_lhs,
	33	const pkgCache::VerIterator &v_rhs)
	34	{
3d8232bf DK	35	pkgCache::DescFile const *A = NULL;
	36	pkgCache::DescFile const *B = NULL;
	37	if (v_lhs->DescriptionList != 0)
	38	A = v_lhs.TranslatedDescription().FileList();
	39	if (v_rhs->DescriptionList != 0)
	40	B = v_rhs.TranslatedDescription().FileList();
	41
	42	if (A == 0 && B == 0)
	43	return false;
b9179170 MV	44
	45	if (A == 0)
	46	return true;
	47
	48	if (B == 0)
	49	return false;
	50
	51	if (A->File == B->File)
	52	return A->Offset < B->Offset;
	53
	54	return A->File < B->File;
	55	}
	56	};
	57
	58	// sorted by locality which makes iterating much faster
	59	typedef APT::VersionContainer<
	60	std::set<pkgCache::VerIterator,
	61	VersionSortDescriptionLocality> > LocalitySortedVersionSet;
	62
	63	class Matcher {
	64	public:
65512241 DK	65	virtual bool operator () (const pkgCache::PkgIterator &/P/) {
65512241 DK	66	return true;}
b9179170 MV	67	};
	68
	69	// FIXME: add default argument for OpProgress (or overloaded function)
25594bb5 DK	70	bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
25594bb5 DK	71	APT::VersionContainerInterface * const vci,
b9179170	72	Matcher &matcher,
25594bb5 DK	73	OpProgress * const progress);
	74	bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
	75	APT::VersionContainerInterface * const vci,
	76	OpProgress * const progress);
b9179170 MV	77
	78
	79	// CacheSetHelper saving virtual packages /{{{/
	80	class CacheSetHelperVirtuals: public APT::CacheSetHelper {
	81	public:
	82	APT::PackageSet virtualPkgs;
	83
3b302846	84	virtual pkgCache::VerIterator canNotGetVersion(enum CacheSetHelper::VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
e6f0c9bc DK	85	if (select == NEWEST \|\| select == CANDIDATE \|\| select == ALL)
	86	virtualPkgs.insert(Pkg);
	87	return CacheSetHelper::canNotGetVersion(select, Cache, Pkg);
b9179170 MV	88	}
b9179170 MV	89
3b302846	90	virtual void canNotFindVersion(enum CacheSetHelper::VerSelector const select, APT::VersionContainerInterface * vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
e6f0c9bc DK	91	if (select == NEWEST \|\| select == CANDIDATE \|\| select == ALL)
	92	virtualPkgs.insert(Pkg);
	93	return CacheSetHelper::canNotFindVersion(select, vci, Cache, Pkg);
b9179170 MV	94	}
	95
	96	CacheSetHelperVirtuals(bool const ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
	97	};
	98	/}}}/
	99
	100	// CacheSetHelperAPTGet - responsible for message telling from the CacheSets/{{{/
	101	class CacheSetHelperAPTGet : public APT::CacheSetHelper {
	102	/** \brief stream message should be printed to */
	103	std::ostream &out;
	104	/** \brief were things like Task or RegEx used to select packages? */
	105	bool explicitlyNamed;
	106
	107	APT::PackageSet virtualPkgs;
	108
	109	public:
	110	std::list<std::pair<pkgCache::VerIterator, std::string> > selectedByRelease;
	111
	112	CacheSetHelperAPTGet(std::ostream &out) : APT::CacheSetHelper(true), out(out) {
	113	explicitlyNamed = true;
	114	}
	115
3b302846	116	virtual void showTaskSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
b9179170 MV	117	ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
	118	Pkg.FullName(true).c_str(), pattern.c_str());
	119	explicitlyNamed = false;
	120	}
3b302846	121	virtual void showFnmatchSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
16724b66 MV	122	ioprintf(out, _("Note, selecting '%s' for glob '%s'\n"),
	123	Pkg.FullName(true).c_str(), pattern.c_str());
	124	explicitlyNamed = false;
	125	}
3b302846	126	virtual void showRegExSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern) APT_OVERRIDE {
b9179170 MV	127	ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
	128	Pkg.FullName(true).c_str(), pattern.c_str());
	129	explicitlyNamed = false;
	130	}
65512241	131	virtual void showSelectedVersion(pkgCache::PkgIterator const &/Pkg/, pkgCache::VerIterator const Ver,
3b302846	132	std::string const &ver, bool const /verIsRel/) APT_OVERRIDE {
b9179170 MV	133	if (ver == Ver.VerStr())
	134	return;
	135	selectedByRelease.push_back(make_pair(Ver, ver));
	136	}
	137
	138	bool showVirtualPackageErrors(pkgCacheFile &Cache) {
	139	if (virtualPkgs.empty() == true)
	140	return true;
	141	for (APT::PackageSet::const_iterator Pkg = virtualPkgs.begin();
	142	Pkg != virtualPkgs.end(); ++Pkg) {
	143	if (Pkg->ProvidesList != 0) {
	144	ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
	145	Pkg.FullName(true).c_str());
	146
	147	pkgCache::PrvIterator I = Pkg.ProvidesList();
	148	unsigned short provider = 0;
	149	for (; I.end() == false; ++I) {
	150	pkgCache::PkgIterator Pkg = I.OwnerPkg();
	151
	152	if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
	153	c1out << " " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
	154	if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
	155	c1out << _(" [Installed]");
	156	c1out << std::endl;
	157	++provider;
	158	}
	159	}
	160	// if we found no candidate which provide this package, show non-candidates
	161	if (provider == 0)
	162	for (I = Pkg.ProvidesList(); I.end() == false; ++I)
	163	c1out << " " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
	164	<< _(" [Not candidate version]") << std::endl;
	165	else
	166	out << _("You should explicitly select one to install.") << std::endl;
	167	} else {
	168	ioprintf(c1out,
	169	_("Package %s is not available, but is referred to by another package.\n"
	170	"This may mean that the package is missing, has been obsoleted, or\n"
	171	"is only available from another source\n"),Pkg.FullName(true).c_str());
	172
	173	std::string List;
	174	std::string VersionsList;
	175	SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];
	176	memset(Seen,0,Cache.GetPkgCache()->Head().PackageCountsizeof(Seen));
	177	for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
	178	Dep.end() == false; ++Dep) {
	179	if (Dep->Type != pkgCache::Dep::Replaces)
	180	continue;
	181	if (Seen[Dep.ParentPkg()->ID] == true)
	182	continue;
	183	Seen[Dep.ParentPkg()->ID] = true;
	184	List += Dep.ParentPkg().FullName(true) + " ";
	185	//VersionsList += std::string(Dep.ParentPkg().CurVersion) + "\n"; ???
	186	}
	187	ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
	188	}
	189	c1out << std::endl;
	190	}
	191	return false;
	192	}
	193
3b302846	194	virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
e6f0c9bc	195	APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::CANDIDATE);
b9179170 MV	196	if (verset.empty() == false)
	197	return *(verset.begin());
	198	else if (ShowError == true) {
	199	_error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
	200	virtualPkgs.insert(Pkg);
	201	}
	202	return pkgCache::VerIterator(Cache, 0);
	203	}
	204
3b302846	205	virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) APT_OVERRIDE {
b9179170 MV	206	if (Pkg->ProvidesList != 0)
b9179170 MV	207	{
e6f0c9bc	208	APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::NEWEST);
b9179170 MV	209	if (verset.empty() == false)
	210	return *(verset.begin());
	211	if (ShowError == true)
	212	ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
	213	}
	214	else
	215	{
	216	pkgCache::GrpIterator Grp = Pkg.Group();
	217	pkgCache::PkgIterator P = Grp.PackageList();
	218	for (; P.end() != true; P = Grp.NextPkg(P))
	219	{
	220	if (P == Pkg)
	221	continue;
	222	if (P->CurrentVer != 0) {
	223	// TRANSLATORS: Note, this is not an interactive question
	224	ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
	225	Pkg.FullName(true).c_str(), P.FullName(true).c_str());
	226	break;
	227	}
	228	}
	229	if (P.end() == true)
	230	ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
	231	}
	232	return pkgCache::VerIterator(Cache, 0);
	233	}
	234
	235	APT::VersionSet tryVirtualPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg,
e6f0c9bc	236	CacheSetHelper::VerSelector const select) {
b9179170 MV	237	/* This is a pure virtual package and there is a single available
	238	candidate providing it. */
	239	if (unlikely(Cache[Pkg].CandidateVer != 0) \|\| Pkg->ProvidesList == 0)
	240	return APT::VersionSet();
	241
	242	pkgCache::PkgIterator Prov;
	243	bool found_one = false;
	244	for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; ++P) {
	245	pkgCache::VerIterator const PVer = P.OwnerVer();
	246	pkgCache::PkgIterator const PPkg = PVer.ParentPkg();
	247
	248	/* Ignore versions that are not a candidate. */
	249	if (Cache[PPkg].CandidateVer != PVer)
	250	continue;
	251
	252	if (found_one == false) {
	253	Prov = PPkg;
	254	found_one = true;
	255	} else if (PPkg != Prov) {
	256	// same group, so it's a foreign package
	257	if (PPkg->Group == Prov->Group) {
	258	// do we already have the requested arch?
	259	if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 \|\|
	260	strcmp(Prov.Arch(), "all") == 0 \|\|
	261	unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
	262	continue;
	263	// see which architecture we prefer more and switch to it
	264	std::vector<std::string> archs = APT::Configuration::getArchitectures();
	265	if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
	266	Prov = PPkg;
	267	continue;
	268	}
	269	found_one = false; // we found at least two
	270	break;
	271	}
	272	}
	273
	274	if (found_one == true) {
	275	ioprintf(out, _("Note, selecting '%s' instead of '%s'\n"),
	276	Prov.FullName(true).c_str(), Pkg.FullName(true).c_str());
	277	return APT::VersionSet::FromPackage(Cache, Prov, select, *this);
	278	}
	279	return APT::VersionSet();
	280	}
	281
	282	inline bool allPkgNamedExplicitly() const { return explicitlyNamed; }
	283
	284	};
	285	/}}}/
	286
	287	#endif