Browse Source

* apt-pkg/cacheset.cc:

- make the cachesets real containers which can embedding any container
    to be able to use the same interface regardless of set or list usage
debian/1.8.y
David Kalnischkies 10 years ago
parent
commit
15fc8636b3
  1. 381
      apt-pkg/cacheset.cc
  2. 524
      apt-pkg/cacheset.h
  3. 4
      apt-pkg/edsp.h
  4. 8
      cmdline/apt-cache.cc
  5. 20
      cmdline/apt-get.cc
  6. 5
      debian/changelog

381
apt-pkg/cacheset.cc

@ -29,7 +29,7 @@
/*}}}*/
namespace APT {
// FromTask - Return all packages in the cache from a specific task /*{{{*/
PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
bool PackageContainerInterface::FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
size_t const archfound = pattern.find_last_of(':');
std::string arch = "native";
if (archfound != std::string::npos) {
@ -38,13 +38,16 @@ PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheS
}
if (pattern[pattern.length() -1] != '^')
return APT::PackageSet(TASK);
return false;
pattern.erase(pattern.length()-1);
if (unlikely(Cache.GetPkgCache() == 0 || Cache.GetDepCache() == 0))
return APT::PackageSet(TASK);
return false;
bool const wasEmpty = pci->empty();
if (wasEmpty == true)
pci->setConstructor(TASK);
PackageSet pkgset(TASK);
// get the records
pkgRecords Recs(Cache);
@ -54,9 +57,10 @@ PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheS
snprintf(S, sizeof(S), "^Task:.*[, ]%s([, ]|$)", pattern.c_str());
if(regcomp(&Pattern,S, REG_EXTENDED | REG_NOSUB | REG_NEWLINE) != 0) {
_error->Error("Failed to compile task regexp");
return pkgset;
return false;
}
bool found = false;
for (pkgCache::GrpIterator Grp = Cache->GrpBegin(); Grp.end() == false; ++Grp) {
pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
if (Pkg.end() == true)
@ -75,22 +79,33 @@ PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheS
if (regexec(&Pattern, buf, 0, 0, 0) != 0)
continue;
pkgset.insert(Pkg);
pci->insert(Pkg);
helper.showTaskSelection(Pkg, pattern);
found = true;
}
regfree(&Pattern);
if (pkgset.empty() == true)
return helper.canNotFindTask(Cache, pattern);
if (found == false) {
helper.canNotFindTask(pci, Cache, pattern);
pci->setConstructor(UNKNOWN);
return false;
}
if (wasEmpty == false && pci->getConstructor() != UNKNOWN)
pci->setConstructor(UNKNOWN);
helper.showTaskSelection(pkgset, pattern);
return pkgset;
return true;
}
/*}}}*/
// FromRegEx - Return all packages in the cache matching a pattern /*{{{*/
PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
bool PackageContainerInterface::FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
static const char * const isregex = ".?+*|[^$";
if (pattern.find_first_of(isregex) == std::string::npos)
return PackageSet(REGEX);
return false;
bool const wasEmpty = pci->empty();
if (wasEmpty == true)
pci->setConstructor(REGEX);
size_t archfound = pattern.find_last_of(':');
std::string arch = "native";
@ -103,11 +118,11 @@ PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, Cache
}
if (unlikely(Cache.GetPkgCache() == 0))
return PackageSet(REGEX);
return false;
APT::CacheFilter::PackageNameMatchesRegEx regexfilter(pattern);
PackageSet pkgset(REGEX);
bool found = false;
for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp) {
if (regexfilter(Grp) == false)
continue;
@ -123,18 +138,25 @@ PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, Cache
continue;
}
pkgset.insert(Pkg);
pci->insert(Pkg);
helper.showRegExSelection(Pkg, pattern);
found = true;
}
if (pkgset.empty() == true)
return helper.canNotFindRegEx(Cache, pattern);
if (found == false) {
helper.canNotFindRegEx(pci, Cache, pattern);
pci->setConstructor(UNKNOWN);
return false;
}
if (wasEmpty == false && pci->getConstructor() != UNKNOWN)
pci->setConstructor(UNKNOWN);
helper.showRegExSelection(pkgset, pattern);
return pkgset;
return true;
}
/*}}}*/
// FromName - Returns the package defined by this string /*{{{*/
pkgCache::PkgIterator PackageSet::FromName(pkgCacheFile &Cache,
pkgCache::PkgIterator PackageContainerInterface::FromName(pkgCacheFile &Cache,
std::string const &str, CacheSetHelper &helper) {
std::string pkg = str;
size_t archfound = pkg.find_last_of(':');
@ -160,144 +182,131 @@ pkgCache::PkgIterator PackageSet::FromName(pkgCacheFile &Cache,
return Pkg;
}
/*}}}*/
// 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, CacheSetHelper &helper) {
std::map<unsigned short, PackageSet> pkgsets;
for (const char **I = cmdline; *I != 0; ++I) {
unsigned short modID = fallback;
std::string str = *I;
bool modifierPresent = false;
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;
}
modifierPresent = true;
break;
}
if (modifierPresent == true) {
bool const errors = helper.showErrors(false);
pkgCache::PkgIterator Pkg = FromName(Cache, *I, helper);
helper.showErrors(errors);
if (Pkg.end() == false) {
pkgsets[fallback].insert(Pkg);
continue;
}
}
pkgsets[modID].insert(PackageSet::FromString(Cache, str, helper));
}
return pkgsets;
}
/*}}}*/
// FromCommandLine - Return all packages specified on commandline /*{{{*/
PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
PackageSet pkgset;
for (const char **I = cmdline; *I != 0; ++I) {
PackageSet pset = FromString(Cache, *I, helper);
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, CacheSetHelper &helper) {
bool PackageContainerInterface::FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str, CacheSetHelper &helper) {
bool found = true;
_error->PushToStack();
PackageSet pkgset;
pkgCache::PkgIterator Pkg = FromName(Cache, str, helper);
if (Pkg.end() == false)
pkgset.insert(Pkg);
else {
pkgset = FromTask(Cache, str, helper);
if (pkgset.empty() == true) {
pkgset = FromRegEx(Cache, str, helper);
if (pkgset.empty() == true)
pkgset = helper.canNotFindPackage(Cache, str);
}
pci->insert(Pkg);
else if (FromTask(pci, Cache, str, helper) == false &&
FromRegEx(pci, Cache, str, helper) == false)
{
helper.canNotFindPackage(pci, Cache, str);
found = false;
}
if (pkgset.empty() == false)
if (found == true)
_error->RevertToStack();
else
_error->MergeWithStack();
return pkgset;
return found;
}
/*}}}*/
// GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
std::map<unsigned short, VersionSet> VersionSet::GroupedFromCommandLine(
pkgCacheFile &Cache, const char **cmdline,
std::list<VersionSet::Modifier> const &mods,
unsigned short const &fallback, CacheSetHelper &helper) {
std::map<unsigned short, VersionSet> versets;
for (const char **I = cmdline; *I != 0; ++I) {
unsigned short modID = fallback;
VersionSet::Version select = VersionSet::NEWEST;
std::string str = *I;
bool modifierPresent = false;
for (std::list<VersionSet::Modifier>::const_iterator mod = mods.begin();
mod != mods.end(); ++mod) {
if (modID == fallback && mod->ID == fallback)
select = mod->SelectVersion;
size_t const alength = strlen(mod->Alias);
switch(mod->Pos) {
case VersionSet::Modifier::POSTFIX:
if (str.compare(str.length() - alength, alength,
mod->Alias, 0, alength) != 0)
continue;
str.erase(str.length() - alength);
modID = mod->ID;
select = mod->SelectVersion;
break;
case VersionSet::Modifier::PREFIX:
continue;
case VersionSet::Modifier::NONE:
// FromCommandLine - Return all packages specified on commandline /*{{{*/
bool PackageContainerInterface::FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
bool found = false;
for (const char **I = cmdline; *I != 0; ++I)
found |= PackageContainerInterface::FromString(pci, Cache, *I, helper);
return found;
}
/*}}}*/
// FromModifierCommandLine - helper doing the work for PKG:GroupedFromCommandLine /*{{{*/
bool PackageContainerInterface::FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
pkgCacheFile &Cache, const char * cmdline,
std::list<Modifier> const &mods, CacheSetHelper &helper) {
std::string str = cmdline;
bool modifierPresent = false;
for (std::list<Modifier>::const_iterator mod = mods.begin();
mod != mods.end(); ++mod) {
size_t const alength = strlen(mod->Alias);
switch(mod->Pos) {
case Modifier::POSTFIX:
if (str.compare(str.length() - alength, alength,
mod->Alias, 0, alength) != 0)
continue;
}
modifierPresent = true;
str.erase(str.length() - alength);
modID = mod->ID;
break;
case Modifier::PREFIX:
continue;
case Modifier::NONE:
continue;
}
if (modifierPresent == true) {
bool const errors = helper.showErrors(false);
VersionSet const vset = VersionSet::FromString(Cache, std::string(*I), select, helper, true);
helper.showErrors(errors);
if (vset.empty() == false) {
versets[fallback].insert(vset);
modifierPresent = true;
break;
}
if (modifierPresent == true) {
bool const errors = helper.showErrors(false);
pkgCache::PkgIterator Pkg = FromName(Cache, cmdline, helper);
helper.showErrors(errors);
if (Pkg.end() == false) {
pci->insert(Pkg);
return true;
}
}
return FromString(pci, Cache, str, helper);
}
/*}}}*/
// FromModifierCommandLine - helper doing the work for VER:GroupedFromCommandLine /*{{{*/
bool VersionContainerInterface::FromModifierCommandLine(unsigned short &modID,
VersionContainerInterface * const vci,
pkgCacheFile &Cache, const char * cmdline,
std::list<Modifier> const &mods,
CacheSetHelper &helper) {
Version select = NEWEST;
std::string str = cmdline;
bool modifierPresent = false;
unsigned short fallback = modID;
for (std::list<Modifier>::const_iterator mod = mods.begin();
mod != mods.end(); ++mod) {
if (modID == fallback && mod->ID == fallback)
select = mod->SelectVersion;
size_t const alength = strlen(mod->Alias);
switch(mod->Pos) {
case Modifier::POSTFIX:
if (str.compare(str.length() - alength, alength,
mod->Alias, 0, alength) != 0)
continue;
}
str.erase(str.length() - alength);
modID = mod->ID;
select = mod->SelectVersion;
break;
case Modifier::PREFIX:
continue;
case Modifier::NONE:
continue;
}
versets[modID].insert(VersionSet::FromString(Cache, str, select , helper));
modifierPresent = true;
break;
}
return versets;
if (modifierPresent == true) {
bool const errors = helper.showErrors(false);
bool const found = VersionContainerInterface::FromString(vci, Cache, cmdline, select, helper, true);
helper.showErrors(errors);
if (found == true)
return true;
}
return FromString(vci, Cache, str, select, helper);
}
/*}}}*/
// FromCommandLine - Return all versions specified on commandline /*{{{*/
APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
APT::VersionSet::Version const &fallback, CacheSetHelper &helper) {
VersionSet verset;
bool VersionContainerInterface::FromCommandLine(VersionContainerInterface * const vci,
pkgCacheFile &Cache, const char **cmdline,
Version const &fallback, CacheSetHelper &helper) {
bool found = false;
for (const char **I = cmdline; *I != 0; ++I)
verset.insert(VersionSet::FromString(Cache, *I, fallback, helper));
return verset;
found |= VersionContainerInterface::FromString(vci, Cache, *I, fallback, helper);
return found;
}
/*}}}*/
// FromString - Returns all versions spedcified by a string /*{{{*/
APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,
APT::VersionSet::Version const &fallback, CacheSetHelper &helper,
bool const &onlyFromName) {
bool VersionContainerInterface::FromString(VersionContainerInterface * const vci,
pkgCacheFile &Cache, std::string pkg,
Version const &fallback, CacheSetHelper &helper,
bool const onlyFromName) {
std::string ver;
bool verIsRel = false;
size_t const vertag = pkg.find_last_of("/=");
@ -308,19 +317,20 @@ APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,
}
PackageSet pkgset;
if (onlyFromName == false)
pkgset = PackageSet::FromString(Cache, pkg, helper);
PackageContainerInterface::FromString(&pkgset, Cache, pkg, helper);
else {
pkgset.insert(PackageSet::FromName(Cache, pkg, helper));
pkgset.insert(PackageContainerInterface::FromName(Cache, pkg, helper));
}
VersionSet verset;
bool errors = true;
if (pkgset.getConstructor() != PackageSet::UNKNOWN)
errors = helper.showErrors(false);
bool found = false;
for (PackageSet::const_iterator P = pkgset.begin();
P != pkgset.end(); ++P) {
if (vertag == std::string::npos) {
verset.insert(VersionSet::FromPackage(Cache, P, fallback, helper));
found |= VersionContainerInterface::FromPackage(vci, Cache, P, fallback, helper);
continue;
}
pkgCache::VerIterator V;
@ -350,75 +360,78 @@ APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,
if (V.end() == true)
continue;
helper.showSelectedVersion(P, V, ver, verIsRel);
verset.insert(V);
vci->insert(V);
found = true;
}
if (pkgset.getConstructor() != PackageSet::UNKNOWN)
helper.showErrors(errors);
return verset;
return found;
}
/*}}}*/
// FromPackage - versions from package based on fallback /*{{{*/
VersionSet VersionSet::FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
VersionSet::Version const &fallback, CacheSetHelper &helper) {
VersionSet verset;
bool VersionContainerInterface::FromPackage(VersionContainerInterface * const vci,
pkgCacheFile &Cache,
pkgCache::PkgIterator const &P,
Version const &fallback,
CacheSetHelper &helper) {
pkgCache::VerIterator V;
bool showErrors;
bool found = false;
switch(fallback) {
case VersionSet::ALL:
case ALL:
if (P->VersionList != 0)
for (V = P.VersionList(); V.end() != true; ++V)
verset.insert(V);
found |= vci->insert(V);
else
verset.insert(helper.canNotFindAllVer(Cache, P));
helper.canNotFindAllVer(vci, Cache, P);
break;
case VersionSet::CANDANDINST:
verset.insert(getInstalledVer(Cache, P, helper));
verset.insert(getCandidateVer(Cache, P, helper));
case CANDANDINST:
found |= vci->insert(getInstalledVer(Cache, P, helper));
found |= vci->insert(getCandidateVer(Cache, P, helper));
break;
case VersionSet::CANDIDATE:
verset.insert(getCandidateVer(Cache, P, helper));
case CANDIDATE:
found |= vci->insert(getCandidateVer(Cache, P, helper));
break;
case VersionSet::INSTALLED:
verset.insert(getInstalledVer(Cache, P, helper));
case INSTALLED:
found |= vci->insert(getInstalledVer(Cache, P, helper));
break;
case VersionSet::CANDINST:
case CANDINST:
showErrors = helper.showErrors(false);
V = getCandidateVer(Cache, P, helper);
if (V.end() == true)
V = getInstalledVer(Cache, P, helper);
helper.showErrors(showErrors);
if (V.end() == false)
verset.insert(V);
found |= vci->insert(V);
else
verset.insert(helper.canNotFindInstCandVer(Cache, P));
helper.canNotFindInstCandVer(vci, Cache, P);
break;
case VersionSet::INSTCAND:
case INSTCAND:
showErrors = helper.showErrors(false);
V = getInstalledVer(Cache, P, helper);
if (V.end() == true)
V = getCandidateVer(Cache, P, helper);
helper.showErrors(showErrors);
if (V.end() == false)
verset.insert(V);
found |= vci->insert(V);
else
verset.insert(helper.canNotFindInstCandVer(Cache, P));
helper.canNotFindInstCandVer(vci, Cache, P);
break;
case VersionSet::NEWEST:
case NEWEST:
if (P->VersionList != 0)
verset.insert(P.VersionList());
found |= vci->insert(P.VersionList());
else
verset.insert(helper.canNotFindNewestVer(Cache, P));
helper.canNotFindNewestVer(Cache, P);
break;
}
return verset;
return found;
}
/*}}}*/
// getCandidateVer - Returns the candidate version of the given package /*{{{*/
pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
pkgCache::VerIterator VersionContainerInterface::getCandidateVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
pkgCache::VerIterator Cand;
if (Cache.IsPolicyBuilt() == true || Cache.IsDepCacheBuilt() == false)
{
if (Cache.IsPolicyBuilt() == true || Cache.IsDepCacheBuilt() == false) {
if (unlikely(Cache.GetPolicy() == 0))
return pkgCache::VerIterator(Cache);
Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
@ -431,13 +444,14 @@ pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
}
/*}}}*/
// getInstalledVer - Returns the installed version of the given package /*{{{*/
pkgCache::VerIterator VersionSet::getInstalledVer(pkgCacheFile &Cache,
pkgCache::VerIterator VersionContainerInterface::getInstalledVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
if (Pkg->CurrentVer == 0)
return helper.canNotFindInstalledVer(Cache, Pkg);
return Pkg.CurrentVer();
}
/*}}}*/
// canNotFindPkgName - handle the case no package has this name /*{{{*/
pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache,
std::string const &str) {
@ -447,46 +461,40 @@ pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache,
}
/*}}}*/
// canNotFindTask - handle the case no package is found for a task /*{{{*/
PackageSet CacheSetHelper::canNotFindTask(pkgCacheFile &Cache, std::string pattern) {
void CacheSetHelper::canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) {
if (ShowError == true)
_error->Insert(ErrorType, _("Couldn't find task '%s'"), pattern.c_str());
return PackageSet();
}
/*}}}*/
// canNotFindRegEx - handle the case no package is found by a regex /*{{{*/
PackageSet CacheSetHelper::canNotFindRegEx(pkgCacheFile &Cache, std::string pattern) {
void CacheSetHelper::canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern) {
if (ShowError == true)
_error->Insert(ErrorType, _("Couldn't find any package by regex '%s'"), pattern.c_str());
return PackageSet();
}
/*}}}*/
// canNotFindPackage - handle the case no package is found from a string/*{{{*/
PackageSet CacheSetHelper::canNotFindPackage(pkgCacheFile &Cache, std::string const &str) {
return PackageSet();
void CacheSetHelper::canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str) {
}
/*}}}*/
// canNotFindAllVer /*{{{*/
VersionSet CacheSetHelper::canNotFindAllVer(pkgCacheFile &Cache,
void CacheSetHelper::canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg) {
if (ShowError == true)
_error->Insert(ErrorType, _("Can't select versions from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str());
return VersionSet();
}
/*}}}*/
// canNotFindInstCandVer /*{{{*/
VersionSet CacheSetHelper::canNotFindInstCandVer(pkgCacheFile &Cache,
void CacheSetHelper::canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg) {
if (ShowError == true)
_error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str());
return VersionSet();
}
/*}}}*/
// canNotFindInstCandVer /*{{{*/
VersionSet CacheSetHelper::canNotFindCandInstVer(pkgCacheFile &Cache,
void CacheSetHelper::canNotFindCandInstVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg) {
if (ShowError == true)
_error->Insert(ErrorType, _("Can't select installed nor candidate version from package '%s' as it has neither of them"), Pkg.FullName(true).c_str());
return VersionSet();
}
/*}}}*/
// canNotFindNewestVer /*{{{*/
@ -513,4 +521,21 @@ pkgCache::VerIterator CacheSetHelper::canNotFindInstalledVer(pkgCacheFile &Cache
return pkgCache::VerIterator(Cache, 0);
}
/*}}}*/
// showTaskSelection /*{{{*/
void CacheSetHelper::showTaskSelection(pkgCache::PkgIterator const &pkg,
std::string const &pattern) {
}
/*}}}*/
// showRegExSelection /*{{{*/
void CacheSetHelper::showRegExSelection(pkgCache::PkgIterator const &pkg,
std::string const &pattern) {
}
/*}}}*/
// showSelectedVersion /*{{{*/
void CacheSetHelper::showSelectedVersion(pkgCache::PkgIterator const &Pkg,
pkgCache::VerIterator const Ver,
std::string const &ver,
bool const verIsRel) {
}
/*}}}*/
}

524
apt-pkg/cacheset.h

@ -15,6 +15,7 @@
#include <map>
#include <set>
#include <string>
#include <iterator>
#include <apt-pkg/error.h>
#include <apt-pkg/pkgcache.h>
@ -23,8 +24,9 @@
class pkgCacheFile;
namespace APT {
class PackageSet;
class VersionSet;
class PackageContainerInterface;
class VersionContainerInterface;
class CacheSetHelper { /*{{{*/
/** \class APT::CacheSetHelper
Simple base class with a lot of virtual methods which can be overridden
@ -35,25 +37,28 @@ class CacheSetHelper { /*{{{*/
printed out.
*/
public: /*{{{*/
CacheSetHelper(bool const &ShowError = true,
CacheSetHelper(bool const ShowError = true,
GlobalError::MsgType ErrorType = GlobalError::ERROR) :
ShowError(ShowError), ErrorType(ErrorType) {};
virtual ~CacheSetHelper() {};
virtual void showTaskSelection(PackageSet const &pkgset, std::string const &pattern) {};
virtual void showRegExSelection(PackageSet const &pkgset, std::string const &pattern) {};
virtual void showTaskSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
virtual void showRegExSelection(pkgCache::PkgIterator const &pkg, std::string const &pattern);
virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
std::string const &ver, bool const &verIsRel) {};
std::string const &ver, bool const verIsRel);
virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
virtual PackageSet canNotFindTask(pkgCacheFile &Cache, std::string pattern);
virtual PackageSet canNotFindRegEx(pkgCacheFile &Cache, std::string pattern);
virtual PackageSet canNotFindPackage(pkgCacheFile &Cache, std::string const &str);
virtual VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
virtual VersionSet canNotFindInstCandVer(pkgCacheFile &Cache,
virtual void canNotFindTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
virtual void canNotFindRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern);
virtual void canNotFindPackage(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &str);
virtual void canNotFindAllVer(VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg);
virtual void canNotFindInstCandVer(VersionContainerInterface * const vci, pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg);
virtual VersionSet canNotFindCandInstVer(pkgCacheFile &Cache,
virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg);
virtual pkgCache::PkgIterator canNotFindPkgName(pkgCacheFile &Cache, std::string const &str);
virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg);
virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache,
@ -62,7 +67,7 @@ public: /*{{{*/
pkgCache::PkgIterator const &Pkg);
bool showErrors() const { return ShowError; };
bool showErrors(bool const &newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
bool showErrors(bool const newValue) { if (ShowError == newValue) return ShowError; else return ((ShowError = newValue) == false); };
GlobalError::MsgType errorType() const { return ErrorType; };
GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
{
@ -79,53 +84,117 @@ protected:
bool ShowError;
GlobalError::MsgType ErrorType;
}; /*}}}*/
class PackageSet : public std::set<pkgCache::PkgIterator> { /*{{{*/
/** \class APT::PackageSet
Simple wrapper around a std::set to provide a similar interface to
a set of packages as to the complete set of all packages in the
pkgCache. */
public: /*{{{*/
/** \brief smell like a pkgCache::PkgIterator */
class const_iterator : public std::set<pkgCache::PkgIterator>::const_iterator {/*{{{*/
class PackageContainerInterface { /*{{{*/
/** \class PackageContainerInterface
* Interface ensuring that all operations can be executed on the yet to
* define concrete PackageContainer - access to all methods is possible,
* but in general the wrappers provided by the PackageContainer template
* are nicer to use.
* This class mostly protects use from the need to write all implementation
* of the methods working on containers in the template */
public:
class const_iterator { /*{{{*/
public:
const_iterator(std::set<pkgCache::PkgIterator>::const_iterator x) :
std::set<pkgCache::PkgIterator>::const_iterator(x) {}
operator pkgCache::PkgIterator(void) { return **this; }
inline const char *Name() const {return (**this).Name(); }
inline std::string FullName(bool const &Pretty) const { return (**this).FullName(Pretty); }
inline std::string FullName() const { return (**this).FullName(); }
inline const char *Section() const {return (**this).Section(); }
inline bool Purge() const {return (**this).Purge(); }
inline const char *Arch() const {return (**this).Arch(); }
inline pkgCache::GrpIterator Group() const { return (**this).Group(); }
inline pkgCache::VerIterator VersionList() const { return (**this).VersionList(); }
inline pkgCache::VerIterator CurrentVer() const { return (**this).CurrentVer(); }
inline pkgCache::DepIterator RevDependsList() const { return (**this).RevDependsList(); }
inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); }
inline pkgCache::PkgIterator::OkState State() const { return (**this).State(); }
inline const char *CandVersion() const { return (**this).CandVersion(); }
inline const char *CurVersion() const { return (**this).CurVersion(); }
inline pkgCache *Cache() const { return (**this).Cache(); };
inline unsigned long Index() const {return (**this).Index();};
virtual pkgCache::PkgIterator getPkg() const = 0;
operator pkgCache::PkgIterator(void) const { return getPkg(); }
inline const char *Name() const {return getPkg().Name(); }
inline std::string FullName(bool const Pretty) const { return getPkg().FullName(Pretty); }
inline std::string FullName() const { return getPkg().FullName(); }
inline const char *Section() const {return getPkg().Section(); }
inline bool Purge() const {return getPkg().Purge(); }
inline const char *Arch() const {return getPkg().Arch(); }
inline pkgCache::GrpIterator Group() const { return getPkg().Group(); }
inline pkgCache::VerIterator VersionList() const { return getPkg().VersionList(); }
inline pkgCache::VerIterator CurrentVer() const { return getPkg().CurrentVer(); }
inline pkgCache::DepIterator RevDependsList() const { return getPkg().RevDependsList(); }
inline pkgCache::PrvIterator ProvidesList() const { return getPkg().ProvidesList(); }
inline pkgCache::PkgIterator::OkState State() const { return getPkg().State(); }
inline const char *CandVersion() const { return getPkg().CandVersion(); }
inline const char *CurVersion() const { return getPkg().CurVersion(); }
inline pkgCache *Cache() const { return getPkg().Cache(); };
inline unsigned long Index() const {return getPkg().Index();};
// we have only valid iterators here
inline bool end() const { return false; };
friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, (*i)); }
inline pkgCache::Package const * operator->() const {return &*getPkg();};
};
/*}}}*/
virtual bool insert(pkgCache::PkgIterator const &P) = 0;
virtual bool empty() const = 0;
virtual void clear() = 0;
enum Constructor { UNKNOWN, REGEX, TASK };
virtual void setConstructor(Constructor const &con) = 0;
virtual Constructor getConstructor() const = 0;
static bool FromTask(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
static bool FromRegEx(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
static bool FromString(PackageContainerInterface * const pci, pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper);
static bool FromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
struct Modifier {
enum Position { NONE, PREFIX, POSTFIX };
unsigned short ID;
const char * const Alias;
Position Pos;
Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
};
static bool FromModifierCommandLine(unsigned short &modID, PackageContainerInterface * const pci,
pkgCacheFile &Cache, const char * cmdline,
std::list<Modifier> const &mods, CacheSetHelper &helper);
};
/*}}}*/
template<class Container> class PackageContainer : public PackageContainerInterface {/*{{{*/
/** \class APT::PackageContainer
inline pkgCache::Package const * operator->() const {
return &***this;
};
Simple wrapper around a container class like std::set to provide a similar
interface to a set of packages as to the complete set of all packages in the
pkgCache. */
Container _cont;
public: /*{{{*/
/** \brief smell like a pkgCache::PkgIterator */
class const_iterator : public PackageContainerInterface::const_iterator,
public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
typename Container::const_iterator _iter;
public:
const_iterator(typename Container::const_iterator i) : _iter(i) {}
pkgCache::PkgIterator getPkg(void) const { return *_iter; }
inline pkgCache::PkgIterator operator*(void) const { return *_iter; };
operator typename Container::const_iterator(void) const { return _iter; }
inline void operator++(void) { ++_iter; };
inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
};
// 103. set::iterator is required to be modifiable, but this allows modification of keys
typedef APT::PackageSet::const_iterator iterator;
// we are not going to allow modify our pkgiterators (it doesn't make sense)…
typedef APT::PackageContainer<Container>::const_iterator iterator;
/*}}}*/
using std::set<pkgCache::PkgIterator>::insert;
inline void insert(pkgCache::PkgIterator const &P) { if (P.end() == false) std::set<pkgCache::PkgIterator>::insert(P); };
inline void insert(PackageSet const &pkgset) { insert(pkgset.begin(), pkgset.end()); };
bool insert(pkgCache::PkgIterator const &P) { if (P.end() == true) return false; _cont.insert(P); return true; };
template<class Cont> void insert(PackageContainer<Cont> const &pkgcont) { _cont.insert((typename Cont::const_iterator)pkgcont.begin(), (typename Cont::const_iterator)pkgcont.end()); };
void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
bool empty() const { return _cont.empty(); };
void clear() { return _cont.clear(); };
void erase(iterator position) { _cont.erase((typename Container::const_iterator)position); };
size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); };
void erase(iterator first, iterator last) { _cont.erase(first, last); };
size_t size() const { return _cont.size(); };
const_iterator begin() const { return const_iterator(_cont.begin()); };
const_iterator end() const { return const_iterator(_cont.end()); };
const_iterator find(pkgCache::PkgIterator const &P) const { return const_iterator(_cont.find(P)); };
void setConstructor(Constructor const &by) { ConstructedBy = by; };
Constructor getConstructor() const { return ConstructedBy; };
PackageContainer() : ConstructedBy(UNKNOWN) {};
PackageContainer(Constructor const &by) : ConstructedBy(by) {};
/** \brief returns all packages in the cache who belong to the given task
@ -135,8 +204,12 @@ public: /*{{{*/
\param Cache the packages are in
\param pattern name of the task
\param helper responsible for error and message handling */
static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
static APT::PackageSet FromTask(pkgCacheFile &Cache, std::string const &pattern) {
static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
PackageContainer cont(TASK);
PackageContainerInterface::FromTask(&cont, Cache, pattern, helper);
return cont;
}
static PackageContainer FromTask(pkgCacheFile &Cache, std::string const &pattern) {
CacheSetHelper helper;
return FromTask(Cache, pattern, helper);
}
@ -149,32 +222,43 @@ public: /*{{{*/
\param Cache the packages are in
\param pattern regular expression for package names
\param helper responsible for error and message handling */
static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper);
static APT::PackageSet FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
PackageContainer cont(REGEX);
PackageContainerInterface::FromRegEx(&cont, Cache, pattern, helper);
return cont;
}
static PackageContainer FromRegEx(pkgCacheFile &Cache, std::string const &pattern) {
CacheSetHelper helper;
return FromRegEx(Cache, pattern, helper);
}
/** \brief returns all packages specified by a string
/** \brief returns a package specified by a string
\param Cache the packages are in
\param string String the package name(s) should be extracted from
\param Cache the package is in
\param pattern String the package name should be extracted from
\param helper responsible for error and message handling */
static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
static APT::PackageSet FromString(pkgCacheFile &Cache, std::string const &string) {
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
return PackageContainerInterface::FromName(Cache, pattern, helper);
}
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &pattern) {
CacheSetHelper helper;
return FromString(Cache, string, helper);
return PackageContainerInterface::FromName(Cache, pattern, helper);
}
/** \brief returns a package specified by a string
/** \brief returns all packages specified by a string
\param Cache the package is in
\param string String the package name should be extracted from
\param Cache the packages are in
\param pattern String the package name(s) should be extracted from
\param helper responsible for error and message handling */
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string) {
static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern, CacheSetHelper &helper) {
PackageContainer cont;
PackageContainerInterface::FromString(&cont, Cache, pattern, helper);
return cont;
}
static PackageContainer FromString(pkgCacheFile &Cache, std::string const &pattern) {
CacheSetHelper helper;
return FromName(Cache, string, helper);
return FromString(Cache, pattern, helper);
}
/** \brief returns all packages specified on the commandline
@ -184,20 +268,16 @@ public: /*{{{*/
\param Cache the packages are in
\param cmdline Command line the package names should be extracted from
\param helper responsible for error and message handling */
static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper);
static APT::PackageSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline, CacheSetHelper &helper) {
PackageContainer cont;
PackageContainerInterface::FromCommandLine(&cont, Cache, cmdline, helper);
return cont;
}
static PackageContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
CacheSetHelper helper;
return FromCommandLine(Cache, cmdline, helper);
}
struct Modifier {
enum Position { NONE, PREFIX, POSTFIX };
unsigned short ID;
const char * const Alias;
Position Pos;
Modifier (unsigned short const &id, const char * const alias, Position const &pos) : ID(id), Alias(alias), Pos(pos) {};
};
/** \brief group packages by a action modifiers
At some point it is needed to get from the same commandline
@ -209,76 +289,75 @@ public: /*{{{*/
\param mods list of modifiers the method should accept
\param fallback the default modifier group for a package
\param helper responsible for error and message handling */
static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
pkgCacheFile &Cache, const char **cmdline,
std::list<PackageSet::Modifier> const &mods,
unsigned short const &fallback, CacheSetHelper &helper);
static std::map<unsigned short, PackageSet> GroupedFromCommandLine(
pkgCacheFile &Cache, const char **cmdline,
std::list<PackageSet::Modifier> const &mods,
unsigned short const &fallback) {
static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
pkgCacheFile &Cache,
const char **cmdline,
std::list<Modifier> const &mods,
unsigned short const &fallback,
CacheSetHelper &helper) {
std::map<unsigned short, PackageContainer> pkgsets;
for (const char **I = cmdline; *I != 0; ++I) {
unsigned short modID = fallback;
PackageContainer pkgset;
PackageContainerInterface::FromModifierCommandLine(modID, &pkgset, Cache, *I, mods, helper);
pkgsets[modID].insert(pkgset);
}
return pkgsets;
}
static std::map<unsigned short, PackageContainer> GroupedFromCommandLine(
pkgCacheFile &Cache,
const char **cmdline,
std::list<Modifier> const &mods,
unsigned short const &fallback) {
CacheSetHelper helper;
return GroupedFromCommandLine(Cache, cmdline,
mods, fallback, helper);
}
enum Constructor { UNKNOWN, REGEX, TASK };
Constructor getConstructor() const { return ConstructedBy; };
PackageSet() : ConstructedBy(UNKNOWN) {};
PackageSet(Constructor const &by) : ConstructedBy(by) {};
/*}}}*/
private: /*{{{*/
Constructor ConstructedBy;
/*}}}*/
}; /*}}}*/
class VersionSet : public std::set<pkgCache::VerIterator> { /*{{{*/
/** \class APT::VersionSet
typedef PackageContainer<std::set<pkgCache::PkgIterator> > PackageSet;
Simple wrapper around a std::set to provide a similar interface to
a set of versions as to the complete set of all versions in the
pkgCache. */
public: /*{{{*/
class VersionContainerInterface { /*{{{*/
/** \class APT::VersionContainerInterface
Same as APT::PackageContainerInterface, just for Versions */
public:
/** \brief smell like a pkgCache::VerIterator */
class const_iterator : public std::set<pkgCache::VerIterator>::const_iterator {/*{{{*/
class const_iterator { /*{{{*/
public:
const_iterator(std::set<pkgCache::VerIterator>::const_iterator x) :
std::set<pkgCache::VerIterator>::const_iterator(x) {}
operator pkgCache::VerIterator(void) { return **this; }
inline pkgCache *Cache() const { return (**this).Cache(); };
inline unsigned long Index() const {return (**this).Index();};
virtual pkgCache::VerIterator getVer() const = 0;
operator pkgCache::VerIterator(void) { return getVer(); }
inline pkgCache *Cache() const { return getVer().Cache(); };
inline unsigned long Index() const {return getVer().Index();};
inline int CompareVer(const pkgCache::VerIterator &B) const { return getVer().CompareVer(B); };
inline const char *VerStr() const { return getVer().VerStr(); };
inline const char *Section() const { return getVer().Section(); };
inline const char *Arch() const { return getVer().Arch(); };
inline pkgCache::PkgIterator ParentPkg() const { return getVer().ParentPkg(); };
inline pkgCache::DescIterator DescriptionList() const { return getVer().DescriptionList(); };
inline pkgCache::DescIterator TranslatedDescription() const { return getVer().TranslatedDescription(); };
inline pkgCache::DepIterator DependsList() const { return getVer().DependsList(); };
inline pkgCache::PrvIterator ProvidesList() const { return getVer().ProvidesList(); };
inline pkgCache::VerFileIterator FileList() const { return getVer().FileList(); };
inline bool Downloadable() const { return getVer().Downloadable(); };
inline const char *PriorityType() const { return getVer().PriorityType(); };
inline std::string RelStr() const { return getVer().RelStr(); };
inline bool Automatic() const { return getVer().Automatic(); };
inline pkgCache::VerFileIterator NewestFile() const { return getVer().NewestFile(); };
// we have only valid iterators here
inline bool end() const { return false; };
inline pkgCache::Version const * operator->() const {
return &***this;
};
inline int CompareVer(const pkgCache::VerIterator &B) const { return (**this).CompareVer(B); };
inline const char *VerStr() const { return (**this).VerStr(); };
inline const char *Section() const { return (**this).Section(); };
inline const char *Arch() const { return (**this).Arch(); };
inline pkgCache::PkgIterator ParentPkg() const { return (**this).ParentPkg(); };
inline pkgCache::DescIterator DescriptionList() const { return (**this).DescriptionList(); };
inline pkgCache::DescIterator TranslatedDescription() const { return (**this).TranslatedDescription(); };
inline pkgCache::DepIterator DependsList() const { return (**this).DependsList(); };
inline pkgCache::PrvIterator ProvidesList() const { return (**this).ProvidesList(); };
inline pkgCache::VerFileIterator FileList() const { return (**this).FileList(); };
inline bool Downloadable() const { return (**this).Downloadable(); };
inline const char *PriorityType() const { return (**this).PriorityType(); };
inline std::string RelStr() const { return (**this).RelStr(); };
inline bool Automatic() const { return (**this).Automatic(); };
inline pkgCache::VerFileIterator NewestFile() const { return (**this).NewestFile(); };
inline pkgCache::Version const * operator->() const { return &*getVer(); };
};
/*}}}*/
// 103. set::iterator is required to be modifiable, but this allows modification of keys
typedef APT::VersionSet::const_iterator iterator;
using std::set<pkgCache::VerIterator>::insert;
inline void insert(pkgCache::VerIterator const &V) { if (V.end() == false) std::set<pkgCache::VerIterator>::insert(V); };
inline void insert(VersionSet const &verset) { insert(verset.begin(), verset.end()); };
virtual bool insert(pkgCache::VerIterator const &V) = 0;
virtual bool empty() const = 0;
virtual void clear() = 0;
/** \brief specifies which version(s) will be returned if non is given */
enum Version {
@ -298,6 +377,93 @@ public: /*{{{*/
NEWEST
};
struct Modifier {
enum Position { NONE, PREFIX, POSTFIX };
unsigned short ID;
const char * const Alias;
Position Pos;
Version SelectVersion;
Modifier (unsigned short const &id, const char * const alias, Position const &pos,
Version const &select) : ID(id), Alias(alias), Pos(pos),
SelectVersion(select) {};
};
static bool FromCommandLine(VersionContainerInterface * const vci, pkgCacheFile &Cache,
const char **cmdline, Version const &fallback,
CacheSetHelper &helper);
static bool FromString(VersionContainerInterface * const vci, pkgCacheFile &Cache,
std::string pkg, Version const &fallback, CacheSetHelper &helper,
bool const onlyFromName = false);
static bool FromPackage(VersionContainerInterface * const vci, pkgCacheFile &Cache,
pkgCache::PkgIterator const &P, Version const &fallback,
CacheSetHelper &helper);
static bool FromModifierCommandLine(unsigned short &modID,
VersionContainerInterface * const vci,
pkgCacheFile &Cache, const char * cmdline,
std::list<Modifier> const &mods,
CacheSetHelper &helper);
protected: /*{{{*/
/** \brief returns the candidate version of the package
\param Cache to be used to query for information
\param Pkg we want the candidate version from this package */
static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
/** \brief returns the installed version of the package
\param Cache to be used to query for information
\param Pkg we want the installed version from this package */
static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
/*}}}*/
};
/*}}}*/
template<class Container> class VersionContainer : public VersionContainerInterface {/*{{{*/
/** \class APT::PackageContainer
Simple wrapper around a container class like std::set to provide a similar
interface to a set of versions as to the complete set of all versions in the
pkgCache. */
Container _cont;
public: /*{{{*/
/** \brief smell like a pkgCache::VerIterator */
class const_iterator : public VersionContainerInterface::const_iterator,
public std::iterator<std::forward_iterator_tag, typename Container::const_iterator> {/*{{{*/
typename Container::const_iterator _iter;
public:
const_iterator(typename Container::const_iterator i) : _iter(i) {}
pkgCache::VerIterator getVer(void) const { return *_iter; }
inline pkgCache::VerIterator operator*(void) const { return *_iter; };
operator typename Container::const_iterator(void) const { return _iter; }
inline void operator++(void) { ++_iter; };
inline bool operator!=(const_iterator const &i) const { return _iter != i._iter; };
inline bool operator==(const_iterator const &i) const { return _iter == i._iter; };
friend std::ostream& operator<<(std::ostream& out, const_iterator i) { return operator<<(out, *i); }
};
// we are not going to allow modify our veriterators (it doesn't make sense)…
typedef APT::VersionContainer<Container>::const_iterator iterator;
/*}}}*/
bool insert(pkgCache::VerIterator const &V) { if (V.end() == true) return false; _cont.insert(V); return true; };
template<class Cont> void insert(VersionContainer<Cont> const &vercont) { _cont.insert((typename Cont::const_iterator)vercont.begin(), (typename Cont::const_iterator)vercont.end()); };
void insert(const_iterator begin, const_iterator end) { _cont.insert(begin, end); };
bool empty() const { return _cont.empty(); };
void clear() { return _cont.clear(); };
void erase(iterator position) { _cont.erase((typename Container::const_iterator)position); };
size_t erase(const pkgCache::PkgIterator x) { return _cont.erase(x); };
void erase(iterator first, iterator last) { _cont.erase(first, last); };
size_t size() const { return _cont.size(); };
const_iterator begin() const { return const_iterator(_cont.begin()); };
const_iterator end() const { return const_iterator(_cont.end()); };
const_iterator find(pkgCache::VerIterator const &V) const { return const_iterator(_cont.find(V)); };
/** \brief returns all versions specified on the commandline
Get all versions from the commandline, uses given default version if
@ -305,26 +471,34 @@ public: /*{{{*/
\param Cache the packages and versions are in
\param cmdline Command line the versions should be extracted from
\param helper responsible for error and message handling */
static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
APT::VersionSet::Version const &fallback) {
static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
Version const &fallback, CacheSetHelper &helper) {
VersionContainer vercon;
VersionContainerInterface::FromCommandLine(&vercon, Cache, cmdline, fallback, helper);
return vercon;
}
static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
Version const &fallback) {
CacheSetHelper helper;
return FromCommandLine(Cache, cmdline, fallback, helper);
}
static APT::VersionSet FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
static VersionContainer FromCommandLine(pkgCacheFile &Cache, const char **cmdline) {
return FromCommandLine(Cache, cmdline, CANDINST);
}
static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
APT::VersionSet::Version const &fallback, CacheSetHelper &helper,
bool const &onlyFromName = false);
static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
APT::VersionSet::Version const &fallback) {
static VersionContainer FromString(pkgCacheFile &Cache, std::string const &pkg,
Version const &fallback, CacheSetHelper &helper,
bool const onlyFromName = false) {
VersionContainer vercon;
VersionContainerInterface::FromString(&vercon, Cache, pkg, fallback, helper);
return vercon;
}
static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg,
Version const &fallback) {
CacheSetHelper helper;
return FromString(Cache, pkg, fallback, helper);
}
static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg) {
static VersionContainer FromString(pkgCacheFile &Cache, std::string pkg) {
return FromString(Cache, pkg, CANDINST);
}
@ -334,57 +508,47 @@ public: /*{{{*/
\param P the package in question
\param fallback the version(s) you want to get
\param helper the helper used for display and error handling */
static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
VersionSet::Version const &fallback, CacheSetHelper &helper);
static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
APT::VersionSet::Version const &fallback) {
static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
Version const &fallback, CacheSetHelper &helper) {
VersionContainer vercon;
VersionContainerInterface::FromPackage(&vercon, Cache, P, fallback, helper);
return vercon;
}
static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P,
Version const &fallback) {
CacheSetHelper helper;
return FromPackage(Cache, P, fallback, helper);
}
static APT::VersionSet FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
static VersionContainer FromPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &P) {
return FromPackage(Cache, P, CANDINST);
}
struct Modifier {
enum Position { NONE, PREFIX, POSTFIX };
unsigned short ID;
const char * const Alias;
Position Pos;
VersionSet::Version SelectVersion;
Modifier (unsigned short const &id, const char * const alias, Position const &pos,
VersionSet::Version const &select) : ID(id), Alias(alias), Pos(pos),
SelectVersion(select) {};
};
static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
pkgCacheFile &Cache,
const char **cmdline,
std::list<Modifier> const &mods,
unsigned short const fallback,
CacheSetHelper &helper) {
std::map<unsigned short, VersionContainer> versets;
for (const char **I = cmdline; *I != 0; ++I) {
unsigned short modID = fallback;
VersionContainer verset;
VersionContainerInterface::FromModifierCommandLine(modID, &verset, Cache, *I, mods, helper);
versets[modID].insert(verset);
}
return versets;
static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
pkgCacheFile &Cache, const char **cmdline,
std::list<VersionSet::Modifier> const &mods,
unsigned short const &fallback, CacheSetHelper &helper);
static std::map<unsigned short, VersionSet> GroupedFromCommandLine(
}
static std::map<unsigned short, VersionContainer> GroupedFromCommandLine(
pkgCacheFile &Cache, const char **cmdline,
std::list<VersionSet::Modifier> const &mods,
unsigned short const &fallback) {
std::list<Modifier> const &mods,
unsigned short const fallback) {
CacheSetHelper helper;
return GroupedFromCommandLine(Cache, cmdline,
mods, fallback, helper);
}
/*}}}*/
protected: /*{{{*/
/** \brief returns the candidate version of the package
\param Cache to be used to query for information
\param Pkg we want the candidate version from this package */
static pkgCache::VerIterator getCandidateVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
/** \brief returns the installed version of the package
\param Cache to be used to query for information
\param Pkg we want the installed version from this package */
static pkgCache::VerIterator getInstalledVer(pkgCacheFile &Cache,
pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper);
/*}}}*/
}; /*}}}*/
typedef VersionContainer<std::set<pkgCache::VerIterator> > VersionSet;
}
#endif

4
apt-pkg/edsp.h

@ -10,13 +10,11 @@
#define PKGLIB_EDSP_H
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheset.h>
#include <list>
#include <string>
namespace APT {
class PackageSet;
};
class pkgDepCache;
class OpProgress;

8
cmdline/apt-cache.cc

@ -65,12 +65,12 @@ public:
return CacheSetHelper::canNotFindNewestVer(Cache, Pkg);
}
virtual APT::VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
virtual void canNotFindAllVer(APT::VersionContainerInterface * vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
virtualPkgs.insert(Pkg);
return CacheSetHelper::canNotFindAllVer(Cache, Pkg);
CacheSetHelper::canNotFindAllVer(vci, Cache, Pkg);
}
CacheSetHelperVirtuals(bool const &ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
CacheSetHelperVirtuals(bool const ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
};
/*}}}*/
// LocalitySort - Sort a version list by package file locality /*{{{*/
@ -108,7 +108,7 @@ void LocalitySort(pkgCache::DescFile **begin,
// UnMet - Show unmet dependencies /*{{{*/
// ---------------------------------------------------------------------
/* */
bool ShowUnMet(pkgCache::VerIterator const &V, bool const &Important)
bool ShowUnMet(pkgCache::VerIterator const &V, bool const Important)
{
bool Header = false;
for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)