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)
  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);
  81    virtual bool Configure(PkgIterator Pkg);
  82    virtual bool Remove(PkgIterator Pkg,bool Purge);
  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    static pkgProblemResolver *This;
 117    APT_HIDDEN static int ScoreSort(const void *a,const void *b) APT_PURE;
 118
 119    struct PackageKill
 120    {
 121       PkgIterator Pkg;
 122       DepIterator Dep;
 123    };
 124
 125    APT_HIDDEN void MakeScores();
 126    APT_HIDDEN bool DoUpgrade(pkgCache::PkgIterator Pkg);
 127
 128    APT_HIDDEN bool ResolveInternal(bool const BrokenFix = false);
 129    APT_HIDDEN bool ResolveByKeepInternal();
 130
 131    protected:
 132    bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg);
 133
 134    public:
 135
 136    inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);};
 137    inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
 138    inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
 139
 140    // Try to intelligently resolve problems by installing and removing packages
 141 #if APT_PKG_ABI >= 413
 142    bool Resolve(bool BrokenFix = false, OpProgress * const Progress = NULL);
 143 #else
 144    bool Resolve(bool BrokenFix = false);
 145    bool Resolve(bool BrokenFix, OpProgress * const Progress);
 146 #endif
 147
 148    // Try to resolve problems only by using keep
 149 #if APT_PKG_ABI >= 413
 150    bool ResolveByKeep(OpProgress * const Progress = NULL);
 151 #else
 152    bool ResolveByKeep();
 153    bool ResolveByKeep(OpProgress * const Progress);
 154 #endif
 155
 156    APT_DEPRECATED void InstallProtect();
 157
 158    explicit pkgProblemResolver(pkgDepCache *Cache);
 159    virtual ~pkgProblemResolver();
 160 };
 161                                                                         /*}}}*/
 162 bool pkgApplyStatus(pkgDepCache &Cache);
 163 bool pkgFixBroken(pkgDepCache &Cache);
 164
 165 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
 166
 167
 168 #endif