]> git.saurik.com Git - apt.git/commitdiff
* apt-pkg/cacheset.cc:
authorDavid Kalnischkies <kalnischkies@gmail.com>
Wed, 9 Nov 2011 16:22:57 +0000 (17:22 +0100)
committerDavid Kalnischkies <kalnischkies@gmail.com>
Wed, 9 Nov 2011 16:22:57 +0000 (17:22 +0100)
  - make the cachesets real containers which can embedding any container
    to be able to use the same interface regardless of set or list usage

apt-pkg/cacheset.cc
apt-pkg/cacheset.h
apt-pkg/edsp.h
cmdline/apt-cache.cc
cmdline/apt-get.cc
debian/changelog

index 6b95eab709c3b9234d6acb600fef9b46165cfb35..b892ab4bfd9a69964c3c0762d63c4e187347f7d2 100644 (file)
@@ -29,7 +29,7 @@
                                                                        /*}}}*/
 namespace APT {
 // FromTask - Return all packages in the cache from a specific task    /*{{{*/
                                                                        /*}}}*/
 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) {
        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] != '^')
        }
 
        if (pattern[pattern.length() -1] != '^')
-               return APT::PackageSet(TASK);
+               return false;
        pattern.erase(pattern.length()-1);
 
        if (unlikely(Cache.GetPkgCache() == 0 || Cache.GetDepCache() == 0))
        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);
 
        // 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");
        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)
        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;
 
                if (regexec(&Pattern, buf, 0, 0, 0) != 0)
                        continue;
 
-               pkgset.insert(Pkg);
+               pci->insert(Pkg);
+               helper.showTaskSelection(Pkg, pattern);
+               found = true;
        }
        regfree(&Pattern);
 
        }
        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     /*{{{*/
 }
                                                                        /*}}}*/
 // 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)
        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";
 
        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))
        }
 
        if (unlikely(Cache.GetPkgCache() == 0))
-               return PackageSet(REGEX);
+               return false;
 
        APT::CacheFilter::PackageNameMatchesRegEx regexfilter(pattern);
 
 
        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;
        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;
                }
 
                                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              /*{{{*/
 }
                                                                        /*}}}*/
 // 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(':');
                        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;
 }
                                                                        /*}}}*/
        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         /*{{{*/
 // 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();
 
        _error->PushToStack();
 
-       PackageSet pkgset;
        pkgCache::PkgIterator Pkg = FromName(Cache, str, helper);
        if (Pkg.end() == false)
        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();
                _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;
                                continue;
-                       }
-                       modifierPresent = true;
+                       str.erase(str.length() - alength);
+                       modID = mod->ID;
                        break;
                        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;
                                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      /*{{{*/
 }
                                                                        /*}}}*/
 // 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)
        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            /*{{{*/
 }
                                                                        /*}}}*/
 // 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("/=");
        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)
        }
        PackageSet pkgset;
        if (onlyFromName == false)
-               pkgset = PackageSet::FromString(Cache, pkg, helper);
+               PackageContainerInterface::FromString(&pkgset, Cache, pkg, helper);
        else {
        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 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) {
        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;
                        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);
                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);
        }
        if (pkgset.getConstructor() != PackageSet::UNKNOWN)
                helper.showErrors(errors);
-       return verset;
+       return found;
 }
                                                                        /*}}}*/
 // FromPackage - versions from package based on fallback               /*{{{*/
 }
                                                                        /*}}}*/
 // 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;
        pkgCache::VerIterator V;
        bool showErrors;
+       bool found = false;
        switch(fallback) {
        switch(fallback) {
-       case VersionSet::ALL:
+       case ALL:
                if (P->VersionList != 0)
                        for (V = P.VersionList(); V.end() != true; ++V)
                if (P->VersionList != 0)
                        for (V = P.VersionList(); V.end() != true; ++V)
-                               verset.insert(V);
+                               found |= vci->insert(V);
                else
                else
-                       verset.insert(helper.canNotFindAllVer(Cache, P));
+                       helper.canNotFindAllVer(vci, Cache, P);
                break;
                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;
                break;
-       case VersionSet::CANDIDATE:
-               verset.insert(getCandidateVer(Cache, P, helper));
+       case CANDIDATE:
+               found |= vci->insert(getCandidateVer(Cache, P, helper));
                break;
                break;
-       case VersionSet::INSTALLED:
-               verset.insert(getInstalledVer(Cache, P, helper));
+       case INSTALLED:
+               found |= vci->insert(getInstalledVer(Cache, P, helper));
                break;
                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)
                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
                else
-                       verset.insert(helper.canNotFindInstCandVer(Cache, P));
+                       helper.canNotFindInstCandVer(vci, Cache, P);
                break;
                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)
                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
                else
-                       verset.insert(helper.canNotFindInstCandVer(Cache, P));
+                       helper.canNotFindInstCandVer(vci, Cache, P);
                break;
                break;
-       case VersionSet::NEWEST:
+       case NEWEST:
                if (P->VersionList != 0)
                if (P->VersionList != 0)
-                       verset.insert(P.VersionList());
+                       found |= vci->insert(P.VersionList());
                else
                else
-                       verset.insert(helper.canNotFindNewestVer(Cache, P));
+                       helper.canNotFindNewestVer(Cache, P);
                break;
        }
                break;
        }
-       return verset;
+       return found;
 }
                                                                        /*}}}*/
 // getCandidateVer - Returns the candidate version of the given package        /*{{{*/
 }
                                                                        /*}}}*/
 // 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;
                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);
                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        /*{{{*/
 }
                                                                        /*}}}*/
 // 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();
 }
                                                                        /*}}}*/
                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) {
 // 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     /*{{{*/
 }
                                                                        /*}}}*/
 // 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());
        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    /*{{{*/
 }
                                                                        /*}}}*/
 // 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());
        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/*{{{*/
 }
                                                                        /*}}}*/
 // 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                                                    /*{{{*/
 }
                                                                        /*}}}*/
 // 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());
                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                                               /*{{{*/
 }
                                                                        /*}}}*/
 // 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());
                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                                               /*{{{*/
 }
                                                                        /*}}}*/
 // 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());
                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                                                 /*{{{*/
 }
                                                                        /*}}}*/
 // canNotFindNewestVer                                                 /*{{{*/
@@ -513,4 +521,21 @@ pkgCache::VerIterator CacheSetHelper::canNotFindInstalledVer(pkgCacheFile &Cache
        return pkgCache::VerIterator(Cache, 0);
 }
                                                                        /*}}}*/
        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) {
+}
+                                                                       /*}}}*/
 }
 }
index 3b1118bdca181b9f39cf9785d06c82f7dc524da8..411b315134da65968bc41320f2dd68a1b9fdbf94 100644 (file)
@@ -15,6 +15,7 @@
 #include <map>
 #include <set>
 #include <string>
 #include <map>
 #include <set>
 #include <string>
+#include <iterator>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
 
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
@@ -23,8 +24,9 @@
 class pkgCacheFile;
 
 namespace APT {
 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
 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:                                                                        /*{{{*/
     printed out.
 */
 public:                                                                        /*{{{*/
-       CacheSetHelper(bool const &ShowError = true,
+       CacheSetHelper(bool const ShowError = true,
                GlobalError::MsgType ErrorType = GlobalError::ERROR) :
                        ShowError(ShowError), ErrorType(ErrorType) {};
        virtual ~CacheSetHelper() {};
 
                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,
        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);
                                pkgCache::PkgIterator const &Pkg);
-       virtual VersionSet canNotFindCandInstVer(pkgCacheFile &Cache,
+       virtual void canNotFindCandInstVer(VersionContainerInterface * const vci,
+                               pkgCacheFile &Cache,
                                pkgCache::PkgIterator const &Pkg);
                                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,
        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; };
                                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)
        {
        GlobalError::MsgType errorType() const { return ErrorType; };
        GlobalError::MsgType errorType(GlobalError::MsgType const &newValue)
        {
@@ -79,53 +84,117 @@ protected:
        bool ShowError;
        GlobalError::MsgType ErrorType;
 };                                                                     /*}}}*/
        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:
        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; };
 
                // 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
 
 
        /** \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 */
            \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);
        }
                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 */
            \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);
        }
 
                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 */
            \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;
                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 */
            \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;
                CacheSetHelper helper;
-               return FromName(Cache, string, helper);
+               return FromString(Cache, pattern, helper);
        }
 
        /** \brief returns all packages specified on the commandline
        }
 
        /** \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 */
            \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);
        }
 
                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
        /** \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 */
            \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);
        }
                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;
                                                                        /*}}}*/
 };                                                                     /*}}}*/
                                                                        /*}}}*/
 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 */
        /** \brief smell like a pkgCache::VerIterator */
-       class const_iterator : public std::set<pkgCache::VerIterator>::const_iterator {/*{{{*/
+       class const_iterator {                                          /*{{{*/
        public:
        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; };
 
                // 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 {
 
        /** \brief specifies which version(s) will be returned if non is given */
        enum Version {
@@ -298,6 +377,93 @@ public:                                                                    /*{{{*/
                NEWEST
        };
 
                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
        /** \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 */
            \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);
        }
                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);
        }
 
                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);
        }
                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);
        }
 
                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 */
            \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);
        }
                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);
        }
 
                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,
                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);
        }
                                                                        /*}}}*/
                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
 }
 #endif
index c143094222d0a5972b05d2f64d859fe7c0f98593..07bbbdd03baad1738b0c9f50d1fed3ee32305530 100644 (file)
 #define PKGLIB_EDSP_H
 
 #include <apt-pkg/pkgcache.h>
 #define PKGLIB_EDSP_H
 
 #include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheset.h>
 
 #include <list>
 #include <string>
 
 
 #include <list>
 #include <string>
 
-namespace APT {
-       class PackageSet;
-};
 class pkgDepCache;
 class OpProgress;
 
 class pkgDepCache;
 class OpProgress;
 
index 82a31c9b189c2378df0c7f436fb339064b74a983..ee3416ffbcb6d50101884527a3abe69d8a6b91a6 100644 (file)
@@ -65,12 +65,12 @@ public:
       return CacheSetHelper::canNotFindNewestVer(Cache, Pkg);
    }
 
       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);
       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         /*{{{*/
 };
                                                                        /*}}}*/
 // LocalitySort - Sort a version list by package file locality         /*{{{*/
@@ -108,7 +108,7 @@ void LocalitySort(pkgCache::DescFile **begin,
 // UnMet - Show unmet dependencies                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // 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;)
 {
         bool Header = false;
         for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
index 1925dea87102aac6082f0a61ac9b1a5a9948377c..5ead83ddf2e2e6a67dff76e1e7c55d4100879b51 100644 (file)
@@ -628,20 +628,18 @@ public:
                explicitlyNamed = true;
        }
 
                explicitlyNamed = true;
        }
 
-       virtual void showTaskSelection(APT::PackageSet const &pkgset, string const &pattern) {
-               for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
-                       ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
-                                Pkg.FullName(true).c_str(), pattern.c_str());
+       virtual void showTaskSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
+               ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
+                               Pkg.FullName(true).c_str(), pattern.c_str());
                explicitlyNamed = false;
        }
                explicitlyNamed = false;
        }
-       virtual void showRegExSelection(APT::PackageSet const &pkgset, string const &pattern) {
-               for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
-                       ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
-                                Pkg.FullName(true).c_str(), pattern.c_str());
+       virtual void showRegExSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
+               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,
                explicitlyNamed = false;
        }
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
-                                string const &ver, bool const &verIsRel) {
+                                string const &ver, bool const verIsRel) {
                if (ver == Ver.VerStr())
                        return;
                selectedByRelease.push_back(make_pair(Ver, ver));
                if (ver == Ver.VerStr())
                        return;
                selectedByRelease.push_back(make_pair(Ver, ver));
@@ -707,7 +705,7 @@ public:
                APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::CANDIDATE);
                if (verset.empty() == false)
                        return *(verset.begin());
                APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::CANDIDATE);
                if (verset.empty() == false)
                        return *(verset.begin());
-               if (ShowError == true) {
+               else if (ShowError == true) {
                        _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
                        virtualPkgs.insert(Pkg);
                }
                        _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
                        virtualPkgs.insert(Pkg);
                }
@@ -769,7 +767,7 @@ struct TryToInstall {
    unsigned long AutoMarkChanged;
    APT::PackageSet doAutoInstallLater;
 
    unsigned long AutoMarkChanged;
    APT::PackageSet doAutoInstallLater;
 
-   TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const &FixBroken) : Cache(&Cache), Fix(PM),
+   TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 
    void operator() (pkgCache::VerIterator const &Ver) {
                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 
    void operator() (pkgCache::VerIterator const &Ver) {
index df50eefbd5c8f2f9a776ebd4df6e037b102093e8..95ad736811fd9a9cbc4a0cfb26cba2fdfdf93a82 100644 (file)
@@ -9,8 +9,11 @@ apt (0.8.16~exp8) experimental; urgency=low
     - use a pointer-union to peace gcc strict-aliasing warning
   * apt-pkg/deb/deblistparser.cc:
     - M-A: foreign packages provide for other archs, too
     - use a pointer-union to peace gcc strict-aliasing warning
   * apt-pkg/deb/deblistparser.cc:
     - M-A: foreign packages provide for other archs, too
+  * 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
 
 
- -- David Kalnischkies <kalnischkies@gmail.com>  Thu, 03 Nov 2011 09:40:29 -0500
+ -- David Kalnischkies <kalnischkies@gmail.com>  Wed, 09 Nov 2011 17:21:02 +0100
 
 apt (0.8.16~exp7) experimental; urgency=low
 
 
 apt (0.8.16~exp7) experimental; urgency=low