apt-pkg/algorithms.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Algorithms - A set of misc algorithms
   6
   7    This simulate class displays what the ordering code has done and
   8    analyses it with a fresh new dependency cache. In this way we can
   9    see all of the effects of an upgrade run.
  10
  11    pkgDistUpgrade computes an upgrade that causes as many packages as
  12    possible to move to the newest version.
  13
  14    pkgApplyStatus sets the target state based on the content of the status
  15    field in the status file. It is important to get proper crash recovery.
  16
  17    pkgFixBroken corrects a broken system so that it is in a sane state.
  18
  19    pkgAllUpgrade attempts to upgade as many packages as possible but
  20    without installing new packages.
  21
  22    The problem resolver class contains a number of complex algorithms
  23    to try to best-guess an upgrade state. It solves the problem of
  24    maximizing the number of install state packages while having no broken
  25    packages.
  26
  27    ##################################################################### */
  28                                                                         /*}}}*/
  29 #ifndef PKGLIB_ALGORITHMS_H
  30 #define PKGLIB_ALGORITHMS_H
  31
  32
  33 #include <apt-pkg/packagemanager.h>
  34 #include <apt-pkg/depcache.h>
  35 #include <apt-pkg/pkgcache.h>
  36 #include <apt-pkg/cacheiterators.h>
  37
  38 #include <iostream>
  39 #include <string>
  40
  41 #include <apt-pkg/macros.h>
  42
  43 #ifndef APT_8_CLEANER_HEADERS
  44 #include <apt-pkg/acquire.h>
  45 using std::ostream;
  46 #endif
  47
  48 #ifndef APT_9_CLEANER_HEADERS
  49 // include pkg{DistUpgrade,AllUpgrade,MiniizeUpgrade} here for compatibility
  50 #include <apt-pkg/upgrade.h>
  51 #include <apt-pkg/update.h>
  52 #endif
  53
  54
  55 class pkgSimulate : public pkgPackageManager                            /*{{{*/
  56 {
  57    void * const d;
  58    protected:
  59
  60    class Policy : public pkgDepCache::Policy
  61    {
  62       pkgDepCache *Cache;
  63       public:
  64
  65       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg) APT_OVERRIDE
  66       {
  67          return (*Cache)[Pkg].CandidateVerIter(*Cache);
  68       }
  69
  70       explicit Policy(pkgDepCache *Cache) : Cache(Cache) {};
  71    };
  72
  73    unsigned char *Flags;
  74
  75    Policy iPolicy;
  76    pkgDepCache Sim;
  77    pkgDepCache::ActionGroup group;
  78
  79    // The Actuall installation implementation
  80    virtual bool Install(PkgIterator Pkg,std::string File) APT_OVERRIDE;
  81    virtual bool Configure(PkgIterator Pkg) APT_OVERRIDE;
  82    virtual bool Remove(PkgIterator Pkg,bool Purge) APT_OVERRIDE;
  83
  84 private:
  85    APT_HIDDEN void ShortBreaks();
  86    APT_HIDDEN void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
  87
  88    public:
  89
  90    explicit pkgSimulate(pkgDepCache *Cache);
  91    virtual ~pkgSimulate();
  92 };
  93                                                                         /*}}}*/
  94 class pkgProblemResolver                                                /*{{{*/
  95 {
  96  private:
  97    /** \brief dpointer placeholder (for later in case we need it) */
  98    void * const d;
  99
 100    pkgDepCache &Cache;
 101    typedef pkgCache::PkgIterator PkgIterator;
 102    typedef pkgCache::VerIterator VerIterator;
 103    typedef pkgCache::DepIterator DepIterator;
 104    typedef pkgCache::PrvIterator PrvIterator;
 105    typedef pkgCache::Version Version;
 106    typedef pkgCache::Package Package;
 107
 108    enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
 109                Upgradable = (1 << 2), ReInstateTried = (1 << 3),
 110                ToRemove = (1 << 4)};
 111    int *Scores;
 112    unsigned char *Flags;
 113    bool Debug;
 114
 115    // Sort stuff
 116    APT_HIDDEN int ScoreSort(Package const *A, Package const *B) APT_PURE;
 117
 118    struct PackageKill
 119    {
 120       PkgIterator Pkg;
 121       DepIterator Dep;
 122    };
 123
 124    APT_HIDDEN void MakeScores();
 125    APT_HIDDEN bool DoUpgrade(pkgCache::PkgIterator Pkg);
 126
 127    APT_HIDDEN bool ResolveInternal(bool const BrokenFix = false);
 128    APT_HIDDEN bool ResolveByKeepInternal();
 129
 130    protected:
 131    bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg);
 132
 133    public:
 134
 135    inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);};
 136    inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
 137    inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
 138
 139    // Try to intelligently resolve problems by installing and removing packages
 140    bool Resolve(bool BrokenFix = false, OpProgress * const Progress = NULL);
 141
 142    // Try to resolve problems only by using keep
 143    bool ResolveByKeep(OpProgress * const Progress = NULL);
 144
 145    APT_DEPRECATED void InstallProtect();
 146
 147    explicit pkgProblemResolver(pkgDepCache *Cache);
 148    virtual ~pkgProblemResolver();
 149 };
 150                                                                         /*}}}*/
 151 bool pkgApplyStatus(pkgDepCache &Cache);
 152 bool pkgFixBroken(pkgDepCache &Cache);
 153
 154 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
 155
 156
 157 #endif