- factor out code to get a single package FromName()

  - check in Grouped* first without modifier interpretation

diff --git a/cmdline/cacheset.cc b/cmdline/cacheset.cc
index 2b00187d8b3086ec20b3313f8eb8c268d3318045..42bc79693521634aecaaca2a7265607493ea95b0 100644 (file)
--- a/cmdline/cacheset.cc
+++ b/cmdline/cacheset.cc
@@ -25,11 +25,7 @@
 namespace APT {
 // FromTask - Return all packages in the cache from a specific task    /*{{{*/
 PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
 namespace APT {
 // FromTask - Return all packages in the cache from a specific task    /*{{{*/
 PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {

-       PackageSet pkgset;
-       if (Cache.BuildCaches() == false || Cache.BuildDepCache() == false)
-               return pkgset;
-
-       size_t archfound = pattern.find_last_of(':');
+       size_t const archfound = pattern.find_last_of(':');

        std::string arch = "native";
        if (archfound != std::string::npos) {
                arch = pattern.substr(archfound+1);
        std::string arch = "native";
        if (archfound != std::string::npos) {
                arch = pattern.substr(archfound+1);


@@ -37,9 +33,13 @@ PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheS
        }
 
        if (pattern[pattern.length() -1] != '^')
        }
 
        if (pattern[pattern.length() -1] != '^')

-               return pkgset;
+               return APT::PackageSet();

        pattern.erase(pattern.length()-1);
 
        pattern.erase(pattern.length()-1);
 

+       if (unlikely(Cache.GetPkgCache() == 0 || Cache.GetDepCache() == 0))
+               return APT::PackageSet();
+
+       PackageSet pkgset;

        // get the records
        pkgRecords Recs(Cache);
 
        // get the records
        pkgRecords Recs(Cache);
 


@@ -83,11 +83,9 @@ PackageSet PackageSet::FromTask(pkgCacheFile &Cache, std::string pattern, CacheS
                                                                        /*}}}*/
 // FromRegEx - Return all packages in the cache matching a pattern     /*{{{*/
 PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {
                                                                        /*}}}*/
 // FromRegEx - Return all packages in the cache matching a pattern     /*{{{*/
 PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, CacheSetHelper &helper) {

-       PackageSet pkgset;

        static const char * const isregex = ".?+*|[^$";
        static const char * const isregex = ".?+*|[^$";

-

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

-               return pkgset;
+               return PackageSet();

 
        size_t archfound = pattern.find_last_of(':');
        std::string arch = "native";
 
        size_t archfound = pattern.find_last_of(':');
        std::string arch = "native";


@@ -105,9 +103,13 @@ PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, Cache
                char Error[300];
                regerror(Res, &Pattern, Error, sizeof(Error));
                _error->Error(_("Regex compilation error - %s"), Error);
                char Error[300];
                regerror(Res, &Pattern, Error, sizeof(Error));
                _error->Error(_("Regex compilation error - %s"), Error);

-               return pkgset;
+               return PackageSet();

        }
 
        }
 

+       if (unlikely(Cache.GetPkgCache() == 0))
+               return PackageSet();
+
+       PackageSet pkgset;

        for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp)
        {
                if (regexec(&Pattern, Grp.Name(), 0, 0, 0) != 0)
        for (pkgCache::GrpIterator Grp = Cache.GetPkgCache()->GrpBegin(); Grp.end() == false; ++Grp)
        {
                if (regexec(&Pattern, Grp.Name(), 0, 0, 0) != 0)


@@ -135,6 +137,33 @@ PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, Cache
        return pkgset;
 }
                                                                        /*}}}*/
        return pkgset;
 }
                                                                        /*}}}*/

+// FromName - Returns the package defined  by this string              /*{{{*/
+pkgCache::PkgIterator PackageSet::FromName(pkgCacheFile &Cache,
+                       std::string const &str, CacheSetHelper &helper) {
+       std::string pkg = str;
+       size_t archfound = pkg.find_last_of(':');
+       std::string arch;
+       if (archfound != std::string::npos) {
+               arch = pkg.substr(archfound+1);
+               pkg.erase(archfound);
+       }
+
+       if (Cache.GetPkgCache() == 0)
+               return pkgCache::PkgIterator(Cache, 0);
+
+       pkgCache::PkgIterator Pkg(Cache, 0);
+       if (arch.empty() == true) {
+               pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
+               if (Grp.end() == false)
+                       Pkg = Grp.FindPreferredPkg();
+       } else
+               Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);
+
+       if (Pkg.end() == true)
+               return helper.canNotFindPkgName(Cache, str);
+       return Pkg;
+}
+                                                                       /*}}}*/

 // GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
 std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
                pkgCacheFile &Cache, const char **cmdline,
 // GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
 std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
                pkgCacheFile &Cache, const char **cmdline,


@@ -144,6 +173,7 @@ std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
        for (const char **I = cmdline; *I != 0; ++I) {
                unsigned short modID = fallback;
                std::string str = *I;
        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);
                for (std::list<PackageSet::Modifier>::const_iterator mod = mods.begin();
                     mod != mods.end(); ++mod) {
                        size_t const alength = strlen(mod->Alias);


@@ -160,8 +190,18 @@ std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
                        case PackageSet::Modifier::NONE:
                                continue;
                        }
                        case PackageSet::Modifier::NONE:
                                continue;
                        }

+                       modifierPresent = true;

                        break;
                }
                        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;
                pkgsets[modID].insert(PackageSet::FromString(Cache, str, helper));
        }
        return pkgsets;


@@ -179,42 +219,26 @@ PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline
                                                                        /*}}}*/
 // FromString - Return all packages matching a specific string         /*{{{*/
 PackageSet PackageSet::FromString(pkgCacheFile &Cache, std::string const &str, CacheSetHelper &helper) {
                                                                        /*}}}*/
 // FromString - Return all packages matching a specific string         /*{{{*/
 PackageSet PackageSet::FromString(pkgCacheFile &Cache, std::string const &str, CacheSetHelper &helper) {

-       std::string pkg = str;
-       size_t archfound = pkg.find_last_of(':');
-       std::string arch;
-       if (archfound != std::string::npos) {
-               arch = pkg.substr(archfound+1);
-               pkg.erase(archfound);
-       }
-
-       pkgCache::PkgIterator Pkg;
-       if (arch.empty() == true) {
-               pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
-               if (Grp.end() == false)
-                       Pkg = Grp.FindPreferredPkg();
-       } else
-               Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);
-
-       if (Pkg.end() == false) {
-               PackageSet pkgset;
-               pkgset.insert(Pkg);
-               return pkgset;
-       }
-

        _error->PushToStack();
 
        _error->PushToStack();
 

-       PackageSet pset = FromTask(Cache, str, helper);
-       if (pset.empty() == true) {
-               pset = FromRegEx(Cache, str, helper);
-               if (pset.empty() == true)
-                       pset = helper.canNotFindPackage(Cache, str);
+       PackageSet pkgset;
+       pkgCache::PkgIterator Pkg = FromName(Cache, str, helper);
+       if (Pkg.end() == false)
+               pkgset.insert(Pkg);
+       else {
+               pkgset = FromTask(Cache, str, helper);
+               if (pkgset.empty() == true) {
+                       pkgset = FromRegEx(Cache, str, helper);
+                       if (pkgset.empty() == true)
+                               pkgset = helper.canNotFindPackage(Cache, str);
+               }

        }
 
        }
 

-       if (pset.empty() == false)
+       if (pkgset.empty() == false)

                _error->RevertToStack();
        else
                _error->MergeWithStack();
                _error->RevertToStack();
        else
                _error->MergeWithStack();

-       return pset;
+       return pkgset;

 }
                                                                        /*}}}*/
 // GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
 }
                                                                        /*}}}*/
 // GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/


@@ -227,6 +251,7 @@ std::map<unsigned short, VersionSet> VersionSet::GroupedFromCommandLine(
                unsigned short modID = fallback;
                VersionSet::Version select = VersionSet::NEWEST;
                std::string str = *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)
                for (std::list<VersionSet::Modifier>::const_iterator mod = mods.begin();
                     mod != mods.end(); ++mod) {
                        if (modID == fallback && mod->ID == fallback)


@@ -246,8 +271,19 @@ std::map<unsigned short, VersionSet> VersionSet::GroupedFromCommandLine(
                        case VersionSet::Modifier::NONE:
                                continue;
                        }
                        case VersionSet::Modifier::NONE:
                                continue;
                        }

+                       modifierPresent = true;

                        break;
                }
                        break;
                }

+
+               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);
+                               continue;
+                       }
+               }

                versets[modID].insert(VersionSet::FromString(Cache, str, select , helper));
        }
        return versets;
                versets[modID].insert(VersionSet::FromString(Cache, str, select , helper));
        }
        return versets;


@@ -257,16 +293,15 @@ std::map<unsigned short, VersionSet> VersionSet::GroupedFromCommandLine(
 APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
                APT::VersionSet::Version const &fallback, CacheSetHelper &helper) {
        VersionSet verset;
 APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline,
                APT::VersionSet::Version const &fallback, CacheSetHelper &helper) {
        VersionSet verset;

-       for (const char **I = cmdline; *I != 0; ++I) {
-               VersionSet vset = VersionSet::FromString(Cache, *I, fallback, helper);
-               verset.insert(vset.begin(), vset.end());
-       }
+       for (const char **I = cmdline; *I != 0; ++I)
+               verset.insert(VersionSet::FromString(Cache, *I, fallback, helper));

        return verset;
 }
                                                                        /*}}}*/
 // FromString - Returns all versions spedcified by a string            /*{{{*/
 APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,
        return verset;
 }
                                                                        /*}}}*/
 // FromString - Returns all versions spedcified by a string            /*{{{*/
 APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,

-               APT::VersionSet::Version const &fallback, CacheSetHelper &helper) {
+               APT::VersionSet::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("/=");


@@ -275,7 +310,13 @@ APT::VersionSet VersionSet::FromString(pkgCacheFile &Cache, std::string pkg,
                verIsRel = (pkg[vertag] == '/');
                pkg.erase(vertag);
        }
                verIsRel = (pkg[vertag] == '/');
                pkg.erase(vertag);
        }

-       PackageSet pkgset = PackageSet::FromString(Cache, pkg.c_str(), helper);
+       PackageSet pkgset;
+       if (onlyFromName == false)
+               pkgset = PackageSet::FromString(Cache, pkg, helper);
+       else {
+               pkgset.insert(PackageSet::FromName(Cache, pkg, helper));
+       }
+

        VersionSet verset;
        for (PackageSet::const_iterator P = pkgset.begin();
             P != pkgset.end(); ++P) {
        VersionSet verset;
        for (PackageSet::const_iterator P = pkgset.begin();
             P != pkgset.end(); ++P) {


@@ -372,8 +413,8 @@ pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
        if (Cache.IsDepCacheBuilt() == true)
                Cand = Cache[Pkg].CandidateVerIter(Cache);
        else {
        if (Cache.IsDepCacheBuilt() == true)
                Cand = Cache[Pkg].CandidateVerIter(Cache);
        else {

-               if (unlikely(Cache.BuildPolicy() == false))
-                       return pkgCache::VerIterator(*Cache);
+               if (unlikely(Cache.GetPolicy() == 0))
+                       return pkgCache::VerIterator(Cache);

                Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
        }
        if (Cand.end() == true)
                Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
        }
        if (Cand.end() == true)


@@ -389,6 +430,14 @@ pkgCache::VerIterator VersionSet::getInstalledVer(pkgCacheFile &Cache,
        return Pkg.CurrentVer();
 }
                                                                        /*}}}*/
        return Pkg.CurrentVer();
 }
                                                                        /*}}}*/

+// canNotFindPkgName - handle the case no package has this name                /*{{{*/
+pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache,
+                       std::string const &str) {
+       if (ShowError == true)
+               _error->Error(_("Unable to locate package %s"), str.c_str());
+       return pkgCache::PkgIterator(Cache, 0);
+}
+                                                                       /*}}}*/

 // canNotFindTask - handle the case no package is found for a task     /*{{{*/
 PackageSet CacheSetHelper::canNotFindTask(pkgCacheFile &Cache, std::string pattern) {
        if (ShowError == true)
 // canNotFindTask - handle the case no package is found for a task     /*{{{*/
 PackageSet CacheSetHelper::canNotFindTask(pkgCacheFile &Cache, std::string pattern) {
        if (ShowError == true)


@@ -405,8 +454,6 @@ PackageSet CacheSetHelper::canNotFindRegEx(pkgCacheFile &Cache, std::string patt
                                                                        /*}}}*/
 // canNotFindPackage - handle the case no package is found from a string/*{{{*/
 PackageSet CacheSetHelper::canNotFindPackage(pkgCacheFile &Cache, std::string const &str) {
                                                                        /*}}}*/
 // canNotFindPackage - handle the case no package is found from a string/*{{{*/
 PackageSet CacheSetHelper::canNotFindPackage(pkgCacheFile &Cache, std::string const &str) {

-       if (ShowError == true)
-               _error->Error(_("Unable to locate package %s"), str.c_str());

        return PackageSet();
 }
                                                                        /*}}}*/
        return PackageSet();
 }
                                                                        /*}}}*/


@@ -431,7 +478,7 @@ pkgCache::VerIterator CacheSetHelper::canNotFindNewestVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select newest version from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str());
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select newest version from package '%s' as it is purely virtual"), Pkg.FullName(true).c_str());

-       return pkgCache::VerIterator(*Cache);
+       return pkgCache::VerIterator(Cache);

 }
                                                                        /*}}}*/
 // canNotFindCandidateVer                                              /*{{{*/
 }
                                                                        /*}}}*/
 // canNotFindCandidateVer                                              /*{{{*/


@@ -439,7 +486,7 @@ pkgCache::VerIterator CacheSetHelper::canNotFindCandidateVer(pkgCacheFile &Cache
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());

-       return pkgCache::VerIterator(*Cache);
+       return pkgCache::VerIterator(Cache);

 }
                                                                        /*}}}*/
 // canNotFindInstalledVer                                              /*{{{*/
 }
                                                                        /*}}}*/
 // canNotFindInstalledVer                                              /*{{{*/


@@ -447,7 +494,7 @@ pkgCache::VerIterator CacheSetHelper::canNotFindInstalledVer(pkgCacheFile &Cache
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str());
                pkgCache::PkgIterator const &Pkg) {
        if (ShowError == true)
                _error->Error(_("Can't select installed version from package %s as it is not installed"), Pkg.FullName(true).c_str());

-       return pkgCache::VerIterator(*Cache);
+       return pkgCache::VerIterator(Cache);

 }
                                                                        /*}}}*/
 }
 }
                                                                        /*}}}*/
 }

diff --git a/cmdline/cacheset.h b/cmdline/cacheset.h
index 9c949102069be0b4853d14ae428542dc6d56c337..21c42c51109bdc5c2e7078158afc31bf57749870 100644 (file)
--- a/cmdline/cacheset.h
+++ b/cmdline/cacheset.h
@@ -40,6 +40,7 @@ public:                                                                       /*{{{*/
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
                                 string const &ver, bool const &verIsRel) {};
 
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
                                 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 PackageSet canNotFindTask(pkgCacheFile &Cache, std::string pattern);
        virtual PackageSet canNotFindRegEx(pkgCacheFile &Cache, std::string pattern);
        virtual PackageSet canNotFindPackage(pkgCacheFile &Cache, std::string const &str);


@@ -146,6 +147,17 @@ public:                                                                    /*{{{*/
                return APT::PackageSet::FromString(Cache, string, helper);
        }
 
                return APT::PackageSet::FromString(Cache, string, helper);
        }
 

+       /** \brief returns a package specified by a string
+
+           \param Cache the package is in
+           \param string String the package name should be extracted from
+           \param out stream to print various notices to */
+       static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string, CacheSetHelper &helper);
+       static pkgCache::PkgIterator FromName(pkgCacheFile &Cache, std::string const &string) {
+               CacheSetHelper helper;
+               return APT::PackageSet::FromName(Cache, string, helper);
+       }
+

        /** \brief returns all packages specified on the commandline
 
            Get all package names from the commandline and executes regex's if needed.
        /** \brief returns all packages specified on the commandline
 
            Get all package names from the commandline and executes regex's if needed.


@@ -268,7 +280,8 @@ public:                                                                     /*{{{*/
        }
 
        static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
        }
 
        static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,

-                       APT::VersionSet::Version const &fallback, CacheSetHelper &helper);
+                       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) {
                CacheSetHelper helper;
        static APT::VersionSet FromString(pkgCacheFile &Cache, std::string pkg,
                        APT::VersionSet::Version const &fallback) {
                CacheSetHelper helper;

diff --git a/debian/changelog b/debian/changelog
index 32a18cf599104edc18a7c7b85ef28c0cce67a787..d7c6b8d0c11ec5a40770e1cd2ad312555f6a0163 100644 (file)
--- a/debian/changelog
+++ b/debian/changelog
@@ -6,6 +6,8 @@ apt (0.7.26~exp8) UNRELEASED; urgency=low
       or use the policy which is a bit faster than depcache generation
     - get packages by task^ with FromTask()
     - only print errors if all tries to get a package by string failed
       or use the policy which is a bit faster than depcache generation
     - get packages by task^ with FromTask()
     - only print errors if all tries to get a package by string failed

+    - factor out code to get a single package FromName()
+    - check in Grouped* first without modifier interpretation

   * cmdline/apt-get.cc:
     - use the cachsets in the install commands
   * apt-pkg/orderlist.cc:
   * cmdline/apt-get.cc:
     - use the cachsets in the install commands
   * apt-pkg/orderlist.cc:


@@ -32,7 +34,7 @@ apt (0.7.26~exp8) UNRELEASED; urgency=low
     - add a Dir::Ignore-Files-Silently list option to control the notice
   * 
 
     - add a Dir::Ignore-Files-Silently list option to control the notice
   * 
 

- -- David Kalnischkies <kalnischkies@gmail.com>  Sat, 26 Jun 2010 21:17:08 +0200
+ -- David Kalnischkies <kalnischkies@gmail.com>  Mon, 28 Jun 2010 22:12:24 +0200

 
 apt (0.7.26~exp7) experimental; urgency=low
 
 
 apt (0.7.26~exp7) experimental; urgency=low