edsp: ask policy engine for the pin of the version directly

[apt.git] / apt-private / private-install.h

diff --git a/apt-private/private-install.h b/apt-private/private-install.h
index fcf4cbcedc1d44c949ebbe99465ec8df1384a667..6bb863f61d1486b4c12ae37619d602848a1552af 100644 (file)
--- a/apt-private/private-install.h
+++ b/apt-private/private-install.h
@@ -1,23 +1,33 @@
 #ifndef APT_PRIVATE_INSTALL_H
 #define APT_PRIVATE_INSTALL_H
 
 #ifndef APT_PRIVATE_INSTALL_H
 #define APT_PRIVATE_INSTALL_H
 

+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>

 #include <apt-pkg/cacheset.h>
 #include <apt-pkg/cacheset.h>

-#include <apt-pkg/cmndline.h>
-#include <apt-pkg/strutl.h>
+#include <apt-pkg/macros.h>

 
 

-#include "private-cachefile.h"
-#include "private-output.h"
+#include <list>
+#include <string>
+#include <utility>

 
 

-#include <apti18n.h>
+class CacheFile;
+class CommandLine;
+class pkgProblemResolver;

 
 

-#define RAMFS_MAGIC     0x858458f6
+APT_PUBLIC bool DoInstall(CommandLine &Cmd);

 
 

-bool DoInstall(CommandLine &Cmd);
+bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, std::vector<const char*> &VolatileCmdL, CacheFile &Cache,
+                                        std::map<unsigned short, APT::VersionSet> &verset, int UpgradeMode);
+bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, std::vector<const char*> &VolatileCmdL, CacheFile &Cache, int UpgradeMode);
+bool DoCacheManipulationFromCommandLine(CommandLine &CmdL, CacheFile &Cache, int UpgradeMode);

 
 

-
-bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
+APT_PUBLIC bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,

                         bool Safety = true);
 
                         bool Safety = true);
 

+bool CheckNothingBroken(CacheFile &Cache);
+bool DoAutomaticRemove(CacheFile &Cache);

 
 // TryToInstall - Mark a package for installation                      /*{{{*/
 struct TryToInstall {
 
 // TryToInstall - Mark a package for installation                      /*{{{*/
 struct TryToInstall {


@@ -30,102 +40,9 @@ struct TryToInstall {
    TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 
    TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),
                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 

-   void operator() (pkgCache::VerIterator const &Ver) {
-      pkgCache::PkgIterator Pkg = Ver.ParentPkg();
-
-      Cache->GetDepCache()->SetCandidateVersion(Ver);
-      pkgDepCache::StateCache &State = (*Cache)[Pkg];
-
-      // Handle the no-upgrade case
-      if (_config->FindB("APT::Get::upgrade",true) == false && Pkg->CurrentVer != 0)
-        ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
-                 Pkg.FullName(true).c_str());
-      // Ignore request for install if package would be new
-      else if (_config->FindB("APT::Get::Only-Upgrade", false) == true && Pkg->CurrentVer == 0)
-        ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
-                 Pkg.FullName(true).c_str());
-      else {
-        if (Fix != NULL) {
-           Fix->Clear(Pkg);
-           Fix->Protect(Pkg);
-        }
-        Cache->GetDepCache()->MarkInstall(Pkg,false);
-
-        if (State.Install() == false) {
-           if (_config->FindB("APT::Get::ReInstall",false) == true) {
-              if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
-                 ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
-                          Pkg.FullName(true).c_str());
-              else
-                 Cache->GetDepCache()->SetReInstall(Pkg, true);
-           } else
-              ioprintf(c1out,_("%s is already the newest version.\n"),
-                       Pkg.FullName(true).c_str());
-        }
-
-        // Install it with autoinstalling enabled (if we not respect the minial
-        // required deps or the policy)
-        if (FixBroken == false)
-           doAutoInstallLater.insert(Pkg);
-      }
-
-      // see if we need to fix the auto-mark flag
-      // e.g. apt-get install foo
-      // where foo is marked automatic
-      if (State.Install() == false &&
-         (State.Flags & pkgCache::Flag::Auto) &&
-         _config->FindB("APT::Get::ReInstall",false) == false &&
-         _config->FindB("APT::Get::Only-Upgrade",false) == false &&
-         _config->FindB("APT::Get::Download-Only",false) == false)
-      {
-        ioprintf(c1out,_("%s set to manually installed.\n"),
-                 Pkg.FullName(true).c_str());
-        Cache->GetDepCache()->MarkAuto(Pkg,false);
-        AutoMarkChanged++;
-      }
-   }
-
-   bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > start, std::ostream &out)
-   {
-      for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
-               s != start.end(); ++s)
-        Cache->GetDepCache()->SetCandidateVersion(s->first);
-
-      bool Success = true;
-      std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
-      for (std::list<std::pair<pkgCache::VerIterator, std::string> >::const_iterator s = start.begin();
-               s != start.end(); ++s)
-      {
-        Changed.push_back(std::make_pair(s->first, pkgCache::VerIterator(*Cache)));
-        // We continue here even if it failed to enhance the ShowBroken output
-        Success &= Cache->GetDepCache()->SetCandidateRelease(s->first, s->second, Changed);
-      }
-      for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
-          c != Changed.end(); ++c)
-      {
-        if (c->second.end() == true)
-           ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
-                    c->first.VerStr(), c->first.RelStr().c_str(), c->first.ParentPkg().FullName(true).c_str());
-        else if (c->first.ParentPkg()->Group != c->second.ParentPkg()->Group)
-        {
-           pkgCache::VerIterator V = (*Cache)[c->first.ParentPkg()].CandidateVerIter(*Cache);
-           ioprintf(out, _("Selected version '%s' (%s) for '%s' because of '%s'\n"), V.VerStr(),
-                    V.RelStr().c_str(), V.ParentPkg().FullName(true).c_str(), c->second.ParentPkg().FullName(true).c_str());
-        }
-      }
-      return Success;
-   }
-
-   void doAutoInstall() {
-      for (APT::PackageSet::const_iterator P = doAutoInstallLater.begin();
-          P != doAutoInstallLater.end(); ++P) {
-        pkgDepCache::StateCache &State = (*Cache)[P];
-        if (State.InstBroken() == false && State.InstPolicyBroken() == false)
-           continue;
-        Cache->GetDepCache()->MarkInstall(P, true);
-      }
-      doAutoInstallLater.clear();
-   }
+   void operator() (pkgCache::VerIterator const &Ver);
+   bool propergateReleaseCandiateSwitching(std::list<std::pair<pkgCache::VerIterator, std::string> > const &start, std::ostream &out);
+   void doAutoInstall();

 };
                                                                        /*}}}*/
 // TryToRemove - Mark a package for removal                            /*{{{*/
 };
                                                                        /*}}}*/
 // TryToRemove - Mark a package for removal                            /*{{{*/


@@ -137,43 +54,7 @@ struct TryToRemove {
    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
                                PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
 
    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
                                PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
 

-   void operator() (pkgCache::VerIterator const &Ver)
-   {
-      pkgCache::PkgIterator Pkg = Ver.ParentPkg();
-
-      if (Fix != NULL)
-      {
-        Fix->Clear(Pkg);
-        Fix->Protect(Pkg);
-        Fix->Remove(Pkg);
-      }
-
-      if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
-         (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
-      {
-        pkgCache::GrpIterator Grp = Pkg.Group();
-        pkgCache::PkgIterator P = Grp.PackageList();
-        for (; P.end() != true; P = Grp.NextPkg(P))
-        {
-           if (P == Pkg)
-              continue;
-           if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
-           {
-              // TRANSLATORS: Note, this is not an interactive question
-              ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
-                       Pkg.FullName(true).c_str(), P.FullName(true).c_str());
-              break;
-           }
-        }
-        if (P.end() == true)
-           ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
-
-        // MarkInstall refuses to install packages on hold
-        Pkg->SelectedState = pkgCache::State::Hold;
-      }
-      else
-        Cache->GetDepCache()->MarkDelete(Pkg, PurgePkgs);
-   }
+   void operator() (pkgCache::VerIterator const &Ver);

 };
                                                                        /*}}}*/
 
 };
                                                                        /*}}}*/