Change InternalReadLine to always use buffer.read() return value

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

diff --git a/apt-pkg/cacheset.cc b/apt-pkg/cacheset.cc
index 76a7e717e7799a3eb183d69c156d162ca20477cb..816925c4dbc00bbbbe5b13d21fa6b969919cba00 100644 (file)
--- a/apt-pkg/cacheset.cc
+++ b/apt-pkg/cacheset.cc
@@ -37,7 +37,6 @@
 #include <apti18n.h>
                                                                        /*}}}*/
 namespace APT {
 #include <apti18n.h>
                                                                        /*}}}*/
 namespace APT {

-

 // PackageFrom - selecting the appropriate method for package selection        /*{{{*/
 bool CacheSetHelper::PackageFrom(enum PkgSelector const select, PackageContainerInterface * const pci,
       pkgCacheFile &Cache, std::string const &pattern) {
 // PackageFrom - selecting the appropriate method for package selection        /*{{{*/
 bool CacheSetHelper::PackageFrom(enum PkgSelector const select, PackageContainerInterface * const pci,
       pkgCacheFile &Cache, std::string const &pattern) {


@@ -154,12 +153,8 @@ bool CacheSetHelper::PackageFromRegEx(PackageContainerInterface * const pci, pkg
                        continue;
                pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
                if (Pkg.end() == true) {
                        continue;
                pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
                if (Pkg.end() == true) {

-                       if (archfound == std::string::npos) {
-                               std::vector<std::string> archs = APT::Configuration::getArchitectures();
-                               for (std::vector<std::string>::const_iterator a = archs.begin();
-                                    a != archs.end() && Pkg.end() != true; ++a)
-                                       Pkg = Grp.FindPkg(*a);
-                       }
+                       if (archfound == std::string::npos)
+                               Pkg = Grp.FindPreferredPkg(true);

                        if (Pkg.end() == true)
                                continue;
                }
                        if (Pkg.end() == true)
                                continue;
                }


@@ -214,12 +209,8 @@ bool CacheSetHelper::PackageFromFnmatch(PackageContainerInterface * const pci,
                        continue;
                pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
                if (Pkg.end() == true) {
                        continue;
                pkgCache::PkgIterator Pkg = Grp.FindPkg(arch);
                if (Pkg.end() == true) {

-                       if (archfound == std::string::npos) {
-                               std::vector<std::string> archs = APT::Configuration::getArchitectures();
-                               for (std::vector<std::string>::const_iterator a = archs.begin();
-                                    a != archs.end() && Pkg.end() != true; ++a)
-                                       Pkg = Grp.FindPkg(*a);
-                       }
+                       if (archfound == std::string::npos)
+                               Pkg = Grp.FindPreferredPkg(true);

                        if (Pkg.end() == true)
                                continue;
                }
                        if (Pkg.end() == true)
                                continue;
                }


@@ -274,6 +265,7 @@ bool CacheSetHelper::PackageFromPackageName(PackageContainerInterface * const pc
        if (unlikely(Cache.GetPkgCache() == 0))
                return false;
 
        if (unlikely(Cache.GetPkgCache() == 0))
                return false;
 

+       std::string const pkgstring = pkg;

        size_t const archfound = pkg.find_last_of(':');
        std::string arch;
        if (archfound != std::string::npos) {
        size_t const archfound = pkg.find_last_of(':');
        std::string arch;
        if (archfound != std::string::npos) {


@@ -310,7 +302,7 @@ bool CacheSetHelper::PackageFromPackageName(PackageContainerInterface * const pc
                }
        }
 
                }
        }
 

-       pkgCache::PkgIterator Pkg = canNotFindPkgName(Cache, pkg);
+       pkgCache::PkgIterator Pkg = canNotFindPkgName(Cache, pkgstring);

        if (Pkg.end() == true)
           return false;
 
        if (Pkg.end() == true)
           return false;
 


@@ -344,7 +336,7 @@ bool CacheSetHelper::PackageFromString(PackageContainerInterface * const pci, pk
 bool CacheSetHelper::PackageFromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline) {
        bool found = false;
        for (const char **I = cmdline; *I != 0; ++I)
 bool CacheSetHelper::PackageFromCommandLine(PackageContainerInterface * const pci, pkgCacheFile &Cache, const char **cmdline) {
        bool found = false;
        for (const char **I = cmdline; *I != 0; ++I)

-               found |= PackageFrom(CacheSetHelper::PACKAGENAME, pci, Cache, *I);
+               found |= PackageFrom(CacheSetHelper::STRING, pci, Cache, *I);

        return found;
 }
                                                                        /*}}}*/
        return found;
 }
                                                                        /*}}}*/


@@ -449,14 +441,6 @@ bool VersionContainerInterface::FromString(VersionContainerInterface * const vci
                                           CacheSetHelper::VerSelector const fallback,
                                           CacheSetHelper &helper,
                                           bool const onlyFromName) {
                                           CacheSetHelper::VerSelector const fallback,
                                           CacheSetHelper &helper,
                                           bool const onlyFromName) {

-       PackageSet pkgset;
-       if(FileExists(pkg)) {
-               helper.PackageFrom(CacheSetHelper::STRING, &pkgset, Cache, pkg);
-               if(pkgset.empty() == true)
-                       return false;
-               return VersionContainerInterface::FromPackage(vci, Cache, pkgset.begin(), fallback, helper);
-       }
-

        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("/=");


@@ -465,6 +449,8 @@ bool VersionContainerInterface::FromString(VersionContainerInterface * const vci
                verIsRel = (pkg[vertag] == '/');
                pkg.erase(vertag);
        }
                verIsRel = (pkg[vertag] == '/');
                pkg.erase(vertag);
        }

+
+       PackageSet pkgset;

        if (onlyFromName == false)
                helper.PackageFrom(CacheSetHelper::STRING, &pkgset, Cache, pkg);
        else {
        if (onlyFromName == false)
                helper.PackageFrom(CacheSetHelper::STRING, &pkgset, Cache, pkg);
        else {


@@ -583,16 +569,126 @@ bool VersionContainerInterface::FromPackage(VersionContainerInterface * const vc
        return found;
 }
                                                                        /*}}}*/
        return found;
 }
                                                                        /*}}}*/

+// FromDependency - versions satisfying a given dependency             /*{{{*/
+bool VersionContainerInterface::FromDependency(VersionContainerInterface * const vci,
+                                              pkgCacheFile &Cache,
+                                              pkgCache::DepIterator const &D,
+                                              CacheSetHelper::VerSelector const selector,
+                                              CacheSetHelper &helper)
+{
+       bool found = false;
+       switch(selector) {
+       case CacheSetHelper::ALL:
+       {
+               pkgCache::PkgIterator const T = D.TargetPkg();
+               for (pkgCache::VerIterator Ver = T.VersionList(); Ver.end() == false; ++Ver)
+               {
+                  if (D.IsSatisfied(Ver) == true)
+                  {
+                     vci->insert(Ver);
+                     found = true;
+                  }
+                  for (pkgCache::PrvIterator Prv = T.ProvidesList(); Prv.end() != true; ++Prv)
+                  {
+                     pkgCache::VerIterator const V = Prv.OwnerVer();
+                     if (unlikely(V.end() == true) || D.IsSatisfied(Prv) == false)
+                        continue;
+                     vci->insert(V);
+                     found = true;
+                  }
+               }
+               return found;
+       }
+       case CacheSetHelper::CANDANDINST:
+       {
+               found = FromDependency(vci, Cache, D, CacheSetHelper::CANDIDATE, helper);
+               found &= FromDependency(vci, Cache, D, CacheSetHelper::INSTALLED, helper);
+               return found;
+       }
+       case CacheSetHelper::CANDIDATE:
+       {
+               pkgCache::PkgIterator const T = D.TargetPkg();
+               pkgCache::VerIterator const Cand = Cache[T].CandidateVerIter(Cache);
+               if (Cand.end() == false && D.IsSatisfied(Cand) == true)
+               {
+                  vci->insert(Cand);
+                  found = true;
+               }
+               for (pkgCache::PrvIterator Prv = T.ProvidesList(); Prv.end() != true; ++Prv)
+               {
+                  pkgCache::VerIterator const V = Prv.OwnerVer();
+                  pkgCache::VerIterator const Cand = Cache[Prv.OwnerPkg()].CandidateVerIter(Cache);
+                  if (Cand.end() == true || V != Cand || D.IsSatisfied(Prv) == false)
+                     continue;
+                  vci->insert(Cand);
+                  found = true;
+               }
+               return found;
+       }
+       case CacheSetHelper::INSTALLED:
+       {
+               pkgCache::PkgIterator const T = D.TargetPkg();
+               pkgCache::VerIterator const Cand = T.CurrentVer();
+               if (Cand.end() == false && D.IsSatisfied(Cand) == true)
+               {
+                  vci->insert(Cand);
+                  found = true;
+               }
+               for (pkgCache::PrvIterator Prv = T.ProvidesList(); Prv.end() != true; ++Prv)
+               {
+                  pkgCache::VerIterator const V = Prv.OwnerVer();
+                  pkgCache::VerIterator const Cand = Prv.OwnerPkg().CurrentVer();
+                  if (Cand.end() == true || V != Cand || D.IsSatisfied(Prv) == false)
+                     continue;
+                  vci->insert(Cand);
+                  found = true;
+               }
+               return found;
+       }
+       case CacheSetHelper::CANDINST:
+               return FromDependency(vci, Cache, D, CacheSetHelper::CANDIDATE, helper) ||
+                  FromDependency(vci, Cache, D, CacheSetHelper::INSTALLED, helper);
+       case CacheSetHelper::INSTCAND:
+               return FromDependency(vci, Cache, D, CacheSetHelper::INSTALLED, helper) ||
+                  FromDependency(vci, Cache, D, CacheSetHelper::CANDIDATE, helper);
+       case CacheSetHelper::NEWEST:
+       {
+               pkgCache::PkgIterator const T = D.TargetPkg();
+               pkgCache::VerIterator const Cand = T.VersionList();
+               if (Cand.end() == false && D.IsSatisfied(Cand) == true)
+               {
+                  vci->insert(Cand);
+                  found = true;
+               }
+               for (pkgCache::PrvIterator Prv = T.ProvidesList(); Prv.end() != true; ++Prv)
+               {
+                  pkgCache::VerIterator const V = Prv.OwnerVer();
+                  pkgCache::VerIterator const Cand = Prv.OwnerPkg().VersionList();
+                  if (Cand.end() == true || V != Cand || D.IsSatisfied(Prv) == false)
+                     continue;
+                  vci->insert(Cand);
+                  found = true;
+               }
+               return found;
+       }
+       case CacheSetHelper::RELEASE:
+       case CacheSetHelper::VERSIONNUMBER:
+               // both make no sense here, so always false
+               return false;
+       }
+       return found;
+}
+                                                                       /*}}}*/

 // getCandidateVer - Returns the candidate version of the given package        /*{{{*/
 pkgCache::VerIterator VersionContainerInterface::getCandidateVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
        pkgCache::VerIterator Cand;
 // getCandidateVer - Returns the candidate version of the given package        /*{{{*/
 pkgCache::VerIterator VersionContainerInterface::getCandidateVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, CacheSetHelper &helper) {
        pkgCache::VerIterator Cand;

-       if (Cache.IsPolicyBuilt() == true || Cache.IsDepCacheBuilt() == false) {
-               if (unlikely(Cache.GetPolicy() == 0))
-                       return pkgCache::VerIterator(Cache);
-               Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);
-       } else {
+       if (Cache.IsDepCacheBuilt() == true) {

                Cand = Cache[Pkg].CandidateVerIter(Cache);
                Cand = Cache[Pkg].CandidateVerIter(Cache);

+       } else if (unlikely(Cache.GetPolicy() == nullptr)) {
+               return pkgCache::VerIterator(Cache);
+       } else {
+               Cand = Cache.GetPolicy()->GetCandidateVer(Pkg);

        }
        if (Cand.end() == true)
                return helper.canNotGetVersion(CacheSetHelper::CANDIDATE, Cache, Pkg);
        }
        if (Cand.end() == true)
                return helper.canNotGetVersion(CacheSetHelper::CANDIDATE, Cache, Pkg);


@@ -613,19 +709,14 @@ void CacheSetHelper::canNotFindPackage(enum PkgSelector const select,
       PackageContainerInterface * const pci, pkgCacheFile &Cache,
       std::string const &pattern) {
        switch (select) {
       PackageContainerInterface * const pci, pkgCacheFile &Cache,
       std::string const &pattern) {
        switch (select) {

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_PUSH

        case REGEX: canNotFindRegEx(pci, Cache, pattern); break;
        case TASK: canNotFindTask(pci, Cache, pattern); break;
        case FNMATCH: canNotFindFnmatch(pci, Cache, pattern); break;
        case PACKAGENAME: canNotFindPackage(pci, Cache, pattern); break;
        case STRING: canNotFindPackage(pci, Cache, pattern); break;
        case UNKNOWN: break;
        case REGEX: canNotFindRegEx(pci, Cache, pattern); break;
        case TASK: canNotFindTask(pci, Cache, pattern); break;
        case FNMATCH: canNotFindFnmatch(pci, Cache, pattern); break;
        case PACKAGENAME: canNotFindPackage(pci, Cache, pattern); break;
        case STRING: canNotFindPackage(pci, Cache, pattern); break;
        case UNKNOWN: break;

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+APT_IGNORE_DEPRECATED_POP

        }
 }
 // canNotFindTask - handle the case no package is found for a task     /*{{{*/
        }
 }
 // canNotFindTask - handle the case no package is found for a task     /*{{{*/


@@ -663,19 +754,14 @@ pkgCache::PkgIterator CacheSetHelper::canNotFindPkgName(pkgCacheFile &Cache,
 void CacheSetHelper::canNotFindVersion(enum VerSelector const select, VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
 {
        switch (select) {
 void CacheSetHelper::canNotFindVersion(enum VerSelector const select, VersionContainerInterface * const vci, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
 {
        switch (select) {

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_PUSH

        case ALL: canNotFindAllVer(vci, Cache, Pkg); break;
        case INSTCAND: canNotFindInstCandVer(vci, Cache, Pkg); break;
        case CANDINST: canNotFindCandInstVer(vci, Cache, Pkg); break;
        case NEWEST: canNotFindNewestVer(Cache, Pkg); break;
        case CANDIDATE: canNotFindCandidateVer(Cache, Pkg); break;
        case INSTALLED: canNotFindInstalledVer(Cache, Pkg); break;
        case ALL: canNotFindAllVer(vci, Cache, Pkg); break;
        case INSTCAND: canNotFindInstCandVer(vci, Cache, Pkg); break;
        case CANDINST: canNotFindCandInstVer(vci, Cache, Pkg); break;
        case NEWEST: canNotFindNewestVer(Cache, Pkg); break;
        case CANDIDATE: canNotFindCandidateVer(Cache, Pkg); break;
        case INSTALLED: canNotFindInstalledVer(Cache, Pkg); break;

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+APT_IGNORE_DEPRECATED_POP

        case CANDANDINST: canNotGetCandInstVer(Cache, Pkg); break;
        case RELEASE:
        case VERSIONNUMBER:
        case CANDANDINST: canNotGetCandInstVer(Cache, Pkg); break;
        case RELEASE:
        case VERSIONNUMBER:


@@ -706,16 +792,11 @@ void CacheSetHelper::canNotFindCandInstVer(VersionContainerInterface * const /*v
 // canNotGetVersion - for package by selector                          /*{{{*/
 pkgCache::VerIterator CacheSetHelper::canNotGetVersion(enum VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
        switch (select) {
 // canNotGetVersion - for package by selector                          /*{{{*/
 pkgCache::VerIterator CacheSetHelper::canNotGetVersion(enum VerSelector const select, pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
        switch (select) {

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_PUSH

        case NEWEST: return canNotFindNewestVer(Cache, Pkg);
        case CANDIDATE: return canNotFindCandidateVer(Cache, Pkg);
        case INSTALLED: return canNotFindInstalledVer(Cache, Pkg);
        case NEWEST: return canNotFindNewestVer(Cache, Pkg);
        case CANDIDATE: return canNotFindCandidateVer(Cache, Pkg);
        case INSTALLED: return canNotFindInstalledVer(Cache, Pkg);

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+APT_IGNORE_DEPRECATED_POP

        case CANDINST: return canNotGetCandInstVer(Cache, Pkg);
        case INSTCAND: return canNotGetInstCandVer(Cache, Pkg);
        case ALL:
        case CANDINST: return canNotGetCandInstVer(Cache, Pkg);
        case INSTCAND: return canNotGetInstCandVer(Cache, Pkg);
        case ALL:


@@ -769,19 +850,14 @@ pkgCache::VerIterator CacheSetHelper::canNotGetCandInstVer(pkgCacheFile &Cache,
                                                                        /*}}}*/
                                                                        /*}}}*/
 // showPackageSelection - by selector and given pattern                        /*{{{*/
                                                                        /*}}}*/
                                                                        /*}}}*/
 // showPackageSelection - by selector and given pattern                        /*{{{*/

-APT_CONST void CacheSetHelper::showPackageSelection(pkgCache::PkgIterator const &pkg, enum PkgSelector const select,
+void CacheSetHelper::showPackageSelection(pkgCache::PkgIterator const &pkg, enum PkgSelector const select,

                                       std::string const &pattern) {
        switch (select) {
                                       std::string const &pattern) {
        switch (select) {

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_PUSH

        case REGEX: showRegExSelection(pkg, pattern); break;
        case TASK: showTaskSelection(pkg, pattern); break;
        case FNMATCH: showFnmatchSelection(pkg, pattern); break;
        case REGEX: showRegExSelection(pkg, pattern); break;
        case TASK: showTaskSelection(pkg, pattern); break;
        case FNMATCH: showFnmatchSelection(pkg, pattern); break;

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+APT_IGNORE_DEPRECATED_POP

        case PACKAGENAME: /* no suprises here */ break;
        case STRING: /* handled by the special cases */ break;
        case UNKNOWN: break;
        case PACKAGENAME: /* no suprises here */ break;
        case STRING: /* handled by the special cases */ break;
        case UNKNOWN: break;


@@ -804,23 +880,17 @@ APT_CONST void CacheSetHelper::showFnmatchSelection(pkgCache::PkgIterator const
                                                                        /*}}}*/
                                                                        /*}}}*/
 // showVersionSelection                                                        /*{{{*/
                                                                        /*}}}*/
                                                                        /*}}}*/
 // showVersionSelection                                                        /*{{{*/

-APT_CONST void CacheSetHelper::showVersionSelection(pkgCache::PkgIterator const &Pkg,
+void CacheSetHelper::showVersionSelection(pkgCache::PkgIterator const &Pkg,

       pkgCache::VerIterator const &Ver, enum VerSelector const select, std::string const &pattern) {
        switch (select) {
       pkgCache::VerIterator const &Ver, enum VerSelector const select, std::string const &pattern) {
        switch (select) {

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_PUSH

        case RELEASE:
                showSelectedVersion(Pkg, Ver, pattern, true);
                break;
        case VERSIONNUMBER:
                showSelectedVersion(Pkg, Ver, pattern, false);
                break;
        case RELEASE:
                showSelectedVersion(Pkg, Ver, pattern, true);
                break;
        case VERSIONNUMBER:
                showSelectedVersion(Pkg, Ver, pattern, false);
                break;

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
+APT_IGNORE_DEPRECATED_POP

        case NEWEST:
        case CANDIDATE:
        case INSTALLED:
        case NEWEST:
        case CANDIDATE:
        case INSTALLED:


@@ -838,4 +908,28 @@ APT_CONST void CacheSetHelper::showSelectedVersion(pkgCache::PkgIterator const &
                                         bool const /*verIsRel*/) {
 }
                                                                        /*}}}*/
                                         bool const /*verIsRel*/) {
 }
                                                                        /*}}}*/

+
+CacheSetHelper::CacheSetHelper(bool const ShowError, GlobalError::MsgType ErrorType) :
+   ShowError(ShowError), ErrorType(ErrorType), d(NULL) {}
+CacheSetHelper::~CacheSetHelper() {}
+
+PackageContainerInterface::PackageContainerInterface() : ConstructedBy(CacheSetHelper::UNKNOWN), d(NULL) {}
+PackageContainerInterface::PackageContainerInterface(CacheSetHelper::PkgSelector const by) : ConstructedBy(by), d(NULL) {}
+PackageContainerInterface& PackageContainerInterface::operator=(PackageContainerInterface const &other) {
+   if (this != &other)
+      this->ConstructedBy = other.ConstructedBy;
+   return *this;
+}
+PackageContainerInterface::~PackageContainerInterface() {}
+
+PackageUniverse::PackageUniverse(pkgCache * const Owner) : _cont(Owner), d(NULL) {}
+PackageUniverse::PackageUniverse(pkgCacheFile * const Owner) : _cont(Owner->GetPkgCache()), d(NULL) {}
+PackageUniverse::~PackageUniverse() {}
+
+VersionContainerInterface::VersionContainerInterface() : d(NULL) {}
+VersionContainerInterface& VersionContainerInterface::operator=(VersionContainerInterface const &) {
+   return *this;
+}
+
+VersionContainerInterface::~VersionContainerInterface() {}

 }
 }