[ntk/apt.git] / apt-pkg / cacheset.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################

   Simple wrapper around a std::set to provide a similar interface to
   a set of cache structures as to the complete set of all structures
   in the pkgCache. Currently only Package is supported.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/error.h>
#include <apt-pkg/cacheset.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/versionmatch.h>

#include <apti18n.h>

#include <vector>

#include <regex.h>
									/*}}}*/
namespace APT {
// FromRegEx - Return all packages in the cache matching a pattern	/*{{{*/
PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, std::ostream &out) {
	PackageSet pkgset;
	std::string arch = "native";
	static const char * const isregex = ".?+*|[^$";

	if (pattern.find_first_of(isregex) == std::string::npos)
		return pkgset;

	size_t archfound = pattern.find_last_of(':');
	if (archfound != std::string::npos) {
		arch = pattern.substr(archfound+1);
		if (arch.find_first_of(isregex) == std::string::npos)
			pattern.erase(archfound);
		else
			arch = "native";
	}

	regex_t Pattern;
	int Res;
	if ((Res = regcomp(&Pattern, pattern.c_str() , REG_EXTENDED | REG_ICASE | REG_NOSUB)) != 0) {
		char Error[300];
		regerror(Res, &Pattern, Error, sizeof(Error));
		_error->Error(_("Regex compilation error - %s"), Error);
		return pkgset;
	}

	for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp)
	{
		if (regexec(&Pattern, Grp.Name(), 0, 0, 0) != 0)
			continue;
		pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
		if (Pkg.end() == true) {
			if (archfound == std::string::npos) {
				std::vector<std::string> archs = APT::Configuration::getArchitectures();
				for (std::vector<std::string>::const_iterator a = archs.begin();
				     a != archs.end() && Pkg.end() != true; ++a)
					Pkg = Grp.FindPkg(*a);
			}
			if (Pkg.end() == true)
				continue;
		}

		ioprintf(out, _("Note, selecting %s for regex '%s'\n"),
			 Pkg.FullName(true).c_str(), pattern.c_str());

		pkgset.insert(Pkg);
	}

	regfree(&Pattern);

	return pkgset;
}
									/*}}}*/
// GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
		pkgCacheFile &Cache, const char **cmdline,
		std::list<PackageSet::Modifier> const &mods,
		unsigned short const &fallback, std::ostream &out) {
	std::map<unsigned short, PackageSet> pkgsets;
	for (const char **I = cmdline; *I != 0; ++I) {
		unsigned short modID = fallback;
		std::string str = *I;
		for (std::list<PackageSet::Modifier>::const_iterator mod = mods.begin();
		     mod != mods.end(); ++mod) {
			size_t const alength = strlen(mod->Alias);
			switch(mod->Pos) {
			case PackageSet::Modifier::POSTFIX:
				if (str.compare(str.length() - alength, alength,
				    mod->Alias, 0, alength) != 0)
					continue;
				str.erase(str.length() - alength);
				modID = mod->ID;
				break;
			case PackageSet::Modifier::PREFIX:
				continue;
			case PackageSet::Modifier::NONE:
				continue;
			}
			break;
		}
		PackageSet pset = PackageSet::FromString(Cache, str, out);
		pkgsets[modID].insert(pset.begin(), pset.end());
	}
	return pkgsets;
}
									/*}}}*/
// FromCommandLine - Return all packages specified on commandline	/*{{{*/
PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out) {
	PackageSet pkgset;
	for (const char **I = cmdline; *I != 0; ++I) {
		PackageSet pset = FromString(Cache, *I, out);
		pkgset.insert(pset.begin(), pset.end());
	}
	return pkgset;
}
									/*}}}*/
// FromString - Return all packages matching a specific string		/*{{{*/
PackageSet PackageSet::FromString(pkgCacheFile &Cache, std::string const &str, std::ostream &out) {
	std::string pkg = str;
	size_t archfound = pkg.find_last_of(':');
	std::string arch;
	if (archfound != std::string::npos) {
		arch = pkg.substr(archfound+1);
		pkg.erase(archfound);
	}

	pkgCache::PkgIterator Pkg;
	if (arch.empty() == true) {
		pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
		if (Grp.end() == false)
			Pkg = Grp.FindPreferredPkg();
	} else
		Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);

	if (Pkg.end() == false) {
		PackageSet pkgset;
		pkgset.insert(Pkg);
		return pkgset;
	}
	PackageSet regex = FromRegEx(Cache, str, out);
	if (regex.empty() == true)
		_error->Warning(_("Unable to locate package %s"), str.c_str());
	return regex;
}
									/*}}}*/
// FromCommandLine - Return all versions specified on commandline	/*{{{*/
APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
		APT::VersionSet::Version const &fallback, std::ostream &out) {
	VersionSet verset;
	for (const char **I = cmdline; *I != 0; ++I) {
		std::string pkg = *I;
		std::string ver;
		bool verIsRel = false;
		size_t const vertag = pkg.find_last_of("/=");
		if (vertag != string::npos) {
			ver = pkg.substr(vertag+1);
			verIsRel = (pkg[vertag] == '/');
			pkg.erase(vertag);
		}
		PackageSet pkgset = PackageSet::FromString(Cache, pkg.c_str(), out);
		for (PackageSet::const_iterator P = pkgset.begin();
		     P != pkgset.end(); ++P) {
			if (vertag == string::npos) {
				AddSelectedVersion(Cache, verset, P, fallback);
				continue;
			}
			pkgCache::VerIterator V;
			if (ver == "installed")
				V = getInstalledVer(Cache, P);
			else if (ver == "candidate")
				V = getCandidateVer(Cache, P);
			else {
				pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release :
						pkgVersionMatch::Version));
				V = Match.Find(P);
				if (V.end() == true) {
					if (verIsRel == true)
						_error->Error(_("Release '%s' for '%s' was not found"),
								ver.c_str(), P.FullName(true).c_str());
					else
						_error->Error(_("Version '%s' for '%s' was not found"),
								ver.c_str(), P.FullName(true).c_str());
					continue;
				}
			}
			if (V.end() == true)
				continue;
			if (ver == V.VerStr())
				ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
					 V.VerStr(), V.RelStr().c_str(), P.FullName(true).c_str());
			verset.insert(V);
		}
	}
	return verset;
}
									/*}}}*/
// AddSelectedVersion - add version from package based on fallback	/*{{{*/
bool VersionSet::AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
		pkgCache::PkgIterator const &P, VersionSet::Version const &fallback,
		bool const &AllowError) {
	pkgCache::VerIterator V;
	switch(fallback) {
	case VersionSet::ALL:
		if (P->VersionList != 0)
			for (V = P.VersionList(); V.end() != true; ++V)
				verset.insert(V);
		else if (AllowError == false)
			return _error->Error(_("Can't select versions from package '%s' as it purely virtual"), P.FullName(true).c_str());
		else
			return false;
		break;
	case VersionSet::CANDANDINST:
		verset.insert(getInstalledVer(Cache, P, AllowError));
		verset.insert(getCandidateVer(Cache, P, AllowError));
		break;
	case VersionSet::CANDIDATE:
		verset.insert(getCandidateVer(Cache, P, AllowError));
		break;
	case VersionSet::INSTALLED:
		verset.insert(getInstalledVer(Cache, P, AllowError));
		break;
	case VersionSet::CANDINST:
		V = getCandidateVer(Cache, P, true);
		if (V.end() == true)
			V = getInstalledVer(Cache, P, true);
		if (V.end() == false)
			verset.insert(V);
		else if (AllowError == false)
			return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
		else
			return false;
		break;
	case VersionSet::INSTCAND:
		V = getInstalledVer(Cache, P, true);
		if (V.end() == true)
			V = getCandidateVer(Cache, P, true);
		if (V.end() == false)
			verset.insert(V);
		else if (AllowError == false)
			return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
		else
			return false;
		break;
	case VersionSet::NEWEST:
		if (P->VersionList != 0)
			verset.insert(P.VersionList());
		else if (AllowError == false)
			return _error->Error(_("Can't select newest version from package '%s' as it is purely virtual"), P.FullName(true).c_str());
		else
			return false;
		break;
	}
	return true;
}
									/*}}}*/
// getCandidateVer - Returns the candidate version of the given package	/*{{{*/
pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
		pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
	pkgCache::VerIterator Cand;
	if (Cache.IsDepCacheBuilt() == true)
		Cand = Cache[Pkg].CandidateVerIter(Cache);
	else {
		if (unlikely(Cache.BuildPolicy() == false))
			return pkgCache::VerIterator(*Cache);
		Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
	}
	if (AllowError == false && Cand.end() == true)
		_error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
	return Cand;
}
									/*}}}*/
// getInstalledVer - Returns the installed version of the given package	/*{{{*/
pkgCache::VerIterator VersionSet::getInstalledVer(pkgCacheFile &Cache,
		pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
	if (AllowError == false && Pkg->CurrentVer == 0)
		_error->Error(_("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str());
	return Pkg.CurrentVer();
}
									/*}}}*/
}
Commit	Line	Data
ffee1c2b DK	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/* ######################################################################
	4
	5	Simple wrapper around a std::set to provide a similar interface to
7959c5ed DK	6	a set of cache structures as to the complete set of all structures
7959c5ed DK	7	in the pkgCache. Currently only Package is supported.
ffee1c2b DK	8
	9	##################################################################### */
	10	/}}}/
	11	// Include Files /{{{/
78c32596	12	#include <apt-pkg/aptconfiguration.h>
ffee1c2b	13	#include <apt-pkg/error.h>
7959c5ed	14	#include <apt-pkg/cacheset.h>
ffee1c2b	15	#include <apt-pkg/strutl.h>
856d3b06	16	#include <apt-pkg/versionmatch.h>
ffee1c2b DK	17
	18	#include <apti18n.h>
	19
78c32596 DK	20	#include <vector>
78c32596 DK	21
ffee1c2b DK	22	#include <regex.h>
	23	/}}}/
	24	namespace APT {
	25	// FromRegEx - Return all packages in the cache matching a pattern /{{{/
856d3b06	26	PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, std::ostream &out) {
ffee1c2b	27	PackageSet pkgset;
6e235c66 DK	28	std::string arch = "native";
6e235c66 DK	29	static const char * const isregex = ".?+*\|[^$";
ffee1c2b	30
6e235c66	31	if (pattern.find_first_of(isregex) == std::string::npos)
ffee1c2b DK	32	return pkgset;
ffee1c2b DK	33
6e235c66 DK	34	size_t archfound = pattern.find_last_of(':');
	35	if (archfound != std::string::npos) {
	36	arch = pattern.substr(archfound+1);
	37	if (arch.find_first_of(isregex) == std::string::npos)
	38	pattern.erase(archfound);
	39	else
	40	arch = "native";
	41	}
	42
ffee1c2b DK	43	regex_t Pattern;
ffee1c2b DK	44	int Res;
6e235c66	45	if ((Res = regcomp(&Pattern, pattern.c_str() , REG_EXTENDED \| REG_ICASE \| REG_NOSUB)) != 0) {
ffee1c2b DK	46	char Error[300];
	47	regerror(Res, &Pattern, Error, sizeof(Error));
	48	_error->Error(_("Regex compilation error - %s"), Error);
	49	return pkgset;
	50	}
	51
856d3b06	52	for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp)
ffee1c2b DK	53	{
	54	if (regexec(&Pattern, Grp.Name(), 0, 0, 0) != 0)
	55	continue;
6e235c66	56	pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
78c32596	57	if (Pkg.end() == true) {
6e235c66 DK	58	if (archfound == std::string::npos) {
	59	std::vector<std::string> archs = APT::Configuration::getArchitectures();
	60	for (std::vector<std::string>::const_iterator a = archs.begin();
	61	a != archs.end() && Pkg.end() != true; ++a)
	62	Pkg = Grp.FindPkg(*a);
78c32596 DK	63	}
	64	if (Pkg.end() == true)
	65	continue;
	66	}
ffee1c2b DK	67
ffee1c2b DK	68	ioprintf(out, _("Note, selecting %s for regex '%s'\n"),
6e235c66	69	Pkg.FullName(true).c_str(), pattern.c_str());
ffee1c2b DK	70
	71	pkgset.insert(Pkg);
	72	}
	73
	74	regfree(&Pattern);
	75
78c32596 DK	76	return pkgset;
	77	}
	78	/}}}/
9cc83a6f DK	79	// GroupedFromCommandLine - Return all versions specified on commandline/{{{/
	80	std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
	81	pkgCacheFile &Cache, const char **cmdline,
	82	std::list<PackageSet::Modifier> const &mods,
	83	unsigned short const &fallback, std::ostream &out) {
	84	std::map<unsigned short, PackageSet> pkgsets;
	85	for (const char *I = cmdline; I != 0; ++I) {
	86	unsigned short modID = fallback;
	87	std::string str = *I;
	88	for (std::list<PackageSet::Modifier>::const_iterator mod = mods.begin();
	89	mod != mods.end(); ++mod) {
	90	size_t const alength = strlen(mod->Alias);
	91	switch(mod->Pos) {
	92	case PackageSet::Modifier::POSTFIX:
	93	if (str.compare(str.length() - alength, alength,
	94	mod->Alias, 0, alength) != 0)
	95	continue;
	96	str.erase(str.length() - alength);
	97	modID = mod->ID;
	98	break;
	99	case PackageSet::Modifier::PREFIX:
	100	continue;
	101	case PackageSet::Modifier::NONE:
	102	continue;
	103	}
	104	break;
	105	}
	106	PackageSet pset = PackageSet::FromString(Cache, str, out);
	107	pkgsets[modID].insert(pset.begin(), pset.end());
	108	}
	109	return pkgsets;
	110	}
	111	/}}}/
78c32596	112	// FromCommandLine - Return all packages specified on commandline /{{{/
856d3b06	113	PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out) {
78c32596	114	PackageSet pkgset;
9f1f17cc	115	for (const char *I = cmdline; I != 0; ++I) {
856d3b06 DK	116	PackageSet pset = FromString(Cache, *I, out);
	117	pkgset.insert(pset.begin(), pset.end());
	118	}
	119	return pkgset;
	120	}
	121	/}}}/
	122	// FromString - Return all packages matching a specific string /{{{/
fe870feb DK	123	PackageSet PackageSet::FromString(pkgCacheFile &Cache, std::string const &str, std::ostream &out) {
	124	std::string pkg = str;
	125	size_t archfound = pkg.find_last_of(':');
	126	std::string arch;
	127	if (archfound != std::string::npos) {
	128	arch = pkg.substr(archfound+1);
	129	pkg.erase(archfound);
	130	}
	131
	132	pkgCache::PkgIterator Pkg;
	133	if (arch.empty() == true) {
	134	pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
	135	if (Grp.end() == false)
	136	Pkg = Grp.FindPreferredPkg();
	137	} else
	138	Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);
	139
	140	if (Pkg.end() == false) {
856d3b06 DK	141	PackageSet pkgset;
	142	pkgset.insert(Pkg);
	143	return pkgset;
	144	}
	145	PackageSet regex = FromRegEx(Cache, str, out);
	146	if (regex.empty() == true)
fe870feb	147	_error->Warning(_("Unable to locate package %s"), str.c_str());
856d3b06 DK	148	return regex;
	149	}
	150	/}}}/
	151	// FromCommandLine - Return all versions specified on commandline /{{{/
	152	APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
	153	APT::VersionSet::Version const &fallback, std::ostream &out) {
	154	VersionSet verset;
9f1f17cc	155	for (const char *I = cmdline; I != 0; ++I) {
856d3b06 DK	156	std::string pkg = *I;
	157	std::string ver;
	158	bool verIsRel = false;
	159	size_t const vertag = pkg.find_last_of("/=");
	160	if (vertag != string::npos) {
	161	ver = pkg.substr(vertag+1);
	162	verIsRel = (pkg[vertag] == '/');
	163	pkg.erase(vertag);
	164	}
	165	PackageSet pkgset = PackageSet::FromString(Cache, pkg.c_str(), out);
	166	for (PackageSet::const_iterator P = pkgset.begin();
	167	P != pkgset.end(); ++P) {
84910ad5 DK	168	if (vertag == string::npos) {
	169	AddSelectedVersion(Cache, verset, P, fallback);
	170	continue;
	171	}
	172	pkgCache::VerIterator V;
	173	if (ver == "installed")
	174	V = getInstalledVer(Cache, P);
	175	else if (ver == "candidate")
	176	V = getCandidateVer(Cache, P);
	177	else {
856d3b06	178	pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release :
84910ad5 DK	179	pkgVersionMatch::Version));
84910ad5 DK	180	V = Match.Find(P);
856d3b06 DK	181	if (V.end() == true) {
	182	if (verIsRel == true)
	183	_error->Error(_("Release '%s' for '%s' was not found"),
	184	ver.c_str(), P.FullName(true).c_str());
	185	else
	186	_error->Error(_("Version '%s' for '%s' was not found"),
	187	ver.c_str(), P.FullName(true).c_str());
	188	continue;
	189	}
78c32596	190	}
84910ad5 DK	191	if (V.end() == true)
	192	continue;
	193	if (ver == V.VerStr())
	194	ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
	195	V.VerStr(), V.RelStr().c_str(), P.FullName(true).c_str());
	196	verset.insert(V);
78c32596	197	}
78c32596	198	}
856d3b06 DK	199	return verset;
	200	}
	201	/}}}/
84910ad5 DK	202	// AddSelectedVersion - add version from package based on fallback /{{{/
	203	bool VersionSet::AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
	204	pkgCache::PkgIterator const &P, VersionSet::Version const &fallback,
	205	bool const &AllowError) {
	206	pkgCache::VerIterator V;
	207	switch(fallback) {
	208	case VersionSet::ALL:
	209	if (P->VersionList != 0)
	210	for (V = P.VersionList(); V.end() != true; ++V)
	211	verset.insert(V);
	212	else if (AllowError == false)
	213	return _error->Error(_("Can't select versions from package '%s' as it purely virtual"), P.FullName(true).c_str());
	214	else
	215	return false;
	216	break;
	217	case VersionSet::CANDANDINST:
	218	verset.insert(getInstalledVer(Cache, P, AllowError));
	219	verset.insert(getCandidateVer(Cache, P, AllowError));
	220	break;
	221	case VersionSet::CANDIDATE:
	222	verset.insert(getCandidateVer(Cache, P, AllowError));
	223	break;
	224	case VersionSet::INSTALLED:
	225	verset.insert(getInstalledVer(Cache, P, AllowError));
	226	break;
	227	case VersionSet::CANDINST:
	228	V = getCandidateVer(Cache, P, true);
	229	if (V.end() == true)
	230	V = getInstalledVer(Cache, P, true);
	231	if (V.end() == false)
	232	verset.insert(V);
	233	else if (AllowError == false)
	234	return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
	235	else
	236	return false;
	237	break;
	238	case VersionSet::INSTCAND:
	239	V = getInstalledVer(Cache, P, true);
	240	if (V.end() == true)
	241	V = getCandidateVer(Cache, P, true);
	242	if (V.end() == false)
	243	verset.insert(V);
	244	else if (AllowError == false)
	245	return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
	246	else
	247	return false;
	248	break;
	249	case VersionSet::NEWEST:
	250	if (P->VersionList != 0)
	251	verset.insert(P.VersionList());
	252	else if (AllowError == false)
	253	return _error->Error(_("Can't select newest version from package '%s' as it is purely virtual"), P.FullName(true).c_str());
	254	else
	255	return false;
	256	break;
	257	}
	258	return true;
	259	}
	260	/}}}/
856d3b06 DK	261	// getCandidateVer - Returns the candidate version of the given package /{{{/
	262	pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
	263	pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
a8ef7efd DK	264	pkgCache::VerIterator Cand;
	265	if (Cache.IsDepCacheBuilt() == true)
	266	Cand = Cache[Pkg].CandidateVerIter(Cache);
	267	else {
	268	if (unlikely(Cache.BuildPolicy() == false))
	269	return pkgCache::VerIterator(*Cache);
	270	Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
	271	}
856d3b06 DK	272	if (AllowError == false && Cand.end() == true)
	273	_error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
	274	return Cand;
	275	}
	276	/}}}/
	277	// getInstalledVer - Returns the installed version of the given package /{{{/
	278	pkgCache::VerIterator VersionSet::getInstalledVer(pkgCacheFile &Cache,
	279	pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
	280	if (AllowError == false && Pkg->CurrentVer == 0)
	281	_error->Error(_("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str());
	282	return Pkg.CurrentVer();
ffee1c2b DK	283	}
	284	/}}}/
	285	}