apt-pkg/algorithms.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: algorithms.h,v 1.10 2001/05/22 04:17:41 jgg Exp $
   4 /* ######################################################################
   5
   6    Algorithms - A set of misc algorithms
   7
   8    This simulate class displays what the ordering code has done and
   9    analyses it with a fresh new dependency cache. In this way we can
  10    see all of the effects of an upgrade run.
  11
  12    pkgDistUpgrade computes an upgrade that causes as many packages as
  13    possible to move to the newest version.
  14
  15    pkgApplyStatus sets the target state based on the content of the status
  16    field in the status file. It is important to get proper crash recovery.
  17
  18    pkgFixBroken corrects a broken system so that it is in a sane state.
  19
  20    pkgAllUpgrade attempts to upgade as many packages as possible but
  21    without installing new packages.
  22
  23    The problem resolver class contains a number of complex algorithms
  24    to try to best-guess an upgrade state. It solves the problem of
  25    maximizing the number of install state packages while having no broken
  26    packages.
  27
  28    ##################################################################### */
  29                                                                         /*}}}*/
  30 #ifndef PKGLIB_ALGORITHMS_H
  31 #define PKGLIB_ALGORITHMS_H
  32
  33
  34 #include <apt-pkg/packagemanager.h>
  35 #include <apt-pkg/depcache.h>
  36 #include <apt-pkg/pkgcache.h>
  37 #include <apt-pkg/cacheiterators.h>
  38
  39 #include <iostream>
  40 #include <string>
  41
  42 #include <apt-pkg/macros.h>
  43
  44 #ifndef APT_8_CLEANER_HEADERS
  45 #include <apt-pkg/acquire.h>
  46 using std::ostream;
  47 #endif
  48
  49 #ifndef APT_9_CLEANER_HEADERS
  50 // include pkg{DistUpgrade,AllUpgrade,MiniizeUpgrade} here for compatibility
  51 #include <apt-pkg/upgrade.h>
  52 #include <apt-pkg/update.h>
  53 #endif
  54
  55
  56 class pkgSimulate : public pkgPackageManager                            /*{{{*/
  57 {
  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       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    void ShortBreaks();
  86    void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
  87
  88    public:
  89
  90    pkgSimulate(pkgDepCache *Cache);
  91    ~pkgSimulate();
  92 };
  93                                                                         /*}}}*/
  94 class pkgProblemResolver                                                /*{{{*/
  95 {
  96  private:
  97    /** \brief dpointer placeholder (for later in case we need it) */
  98    void *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    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    void MakeScores();
 126    bool DoUpgrade(pkgCache::PkgIterator Pkg);
 127
 128    bool ResolveInternal(bool const BrokenFix = false);
 129    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    bool Resolve(bool BrokenFix = false, OpProgress * const Progress = NULL);
 142
 143    // Try to resolve problems only by using keep
 144    bool ResolveByKeep(OpProgress * const Progress = NULL);
 145
 146    APT_DEPRECATED void InstallProtect();
 147
 148    pkgProblemResolver(pkgDepCache *Cache);
 149    ~pkgProblemResolver();
 150 };
 151                                                                         /*}}}*/
 152 bool pkgApplyStatus(pkgDepCache &Cache);
 153 bool pkgFixBroken(pkgDepCache &Cache);
 154
 155 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
 156
 157
 158 #endif