apt-pkg/depcache.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: depcache.h,v 1.14 2001/02/20 07:03:17 jgg Exp $
   4 /* ######################################################################
   5
   6    DepCache - Dependency Extension data for the cache
   7
   8    This class stores the cache data and a set of extension structures for
   9    monitoring the current state of all the packages. It also generates and
  10    caches the 'install' state of many things. This refers to the state of the
  11    package after an install has been run.
  12
  13    The StateCache::State field can be -1,0,1,2 which is <,=,>,no current.
  14    StateCache::Mode is which of the 3 fields is active.
  15
  16    This structure is important to support the readonly status of the cache
  17    file. When the data is saved the cache will be refereshed from our
  18    internal rep and written to disk. Then the actual persistant data
  19    files will be put on the disk.
  20
  21    Each dependency is compared against 3 target versions to produce to
  22    3 dependency results.
  23      Now - Compared using the Currently install version
  24      Install - Compared using the install version (final state)
  25      CVer - (Candidate Verion) Compared using the Candidate Version
  26    The candidate and now results are used to decide wheather a package
  27    should be automatically installed or if it should be left alone.
  28
  29    Remember, the Candidate Version is selected based on the distribution
  30    settings for the Package. The Install Version is selected based on the
  31    state (Delete, Keep, Install) field and can be either the Current Version
  32    or the Candidate version.
  33
  34    The Candidate version is what is shown the 'Install Version' field.
  35
  36    ##################################################################### */
  37                                                                         /*}}}*/
  38 #ifndef PKGLIB_DEPCACHE_H
  39 #define PKGLIB_DEPCACHE_H
  40
  41 #ifdef __GNUG__
  42 #pragma interface "apt-pkg/depcache.h"
  43 #endif
  44
  45 #include <apt-pkg/pkgcache.h>
  46 #include <apt-pkg/progress.h>
  47
  48 class pkgDepCache : protected pkgCache::Namespace
  49 {
  50    public:
  51
  52    // These flags are used in DepState
  53    enum DepFlags {DepNow = (1 << 0),DepInstall = (1 << 1),DepCVer = (1 << 2),
  54                   DepGNow = (1 << 3),DepGInstall = (1 << 4),DepGCVer = (1 << 5)};
  55
  56    // These flags are used in StateCache::DepState
  57    enum DepStateFlags {DepNowPolicy = (1 << 0), DepNowMin = (1 << 1),
  58                        DepInstPolicy = (1 << 2), DepInstMin = (1 << 3),
  59                        DepCandPolicy = (1 << 4), DepCandMin = (1 << 5)};
  60
  61    // These flags are used in StateCache::iFlags
  62    enum InternalFlags {AutoKept = (1 << 0), Purge = (1 << 1), ReInstall = (1 << 2)};
  63
  64    enum VersionTypes {NowVersion, InstallVersion, CandidateVersion};
  65    enum ModeList {ModeDelete = 0, ModeKeep = 1, ModeInstall = 2};
  66    struct StateCache
  67    {
  68       // Epoch stripped text versions of the two version fields
  69       const char *CandVersion;
  70       const char *CurVersion;
  71
  72       // Pointer to the candidate install version.
  73       Version *CandidateVer;
  74
  75       // Pointer to the install version.
  76       Version *InstallVer;
  77
  78       // Copy of Package::Flags
  79       unsigned short Flags;
  80       unsigned short iFlags;           // Internal flags
  81
  82       // Various tree indicators
  83       signed char Status;              // -1,0,1,2
  84       unsigned char Mode;              // ModeList
  85       unsigned char DepState;          // DepState Flags
  86
  87       // Update of candidate version
  88       const char *StripEpoch(const char *Ver);
  89       void Update(PkgIterator Pkg,pkgCache &Cache);
  90
  91       // Various test members for the current status of the package
  92       inline bool NewInstall() const {return Status == 2 && Mode == ModeInstall;};
  93       inline bool Delete() const {return Mode == ModeDelete;};
  94       inline bool Keep() const {return Mode == ModeKeep;};
  95       inline bool Upgrade() const {return Status > 0 && Mode == ModeInstall;};
  96       inline bool Upgradable() const {return Status >= 1;};
  97       inline bool Downgrade() const {return Status < 0 && Mode == ModeInstall;};
  98       inline bool Held() const {return Status != 0 && Keep();};
  99       inline bool NowBroken() const {return (DepState & DepNowMin) != DepNowMin;};
 100       inline bool NowPolicyBroken() const {return (DepState & DepNowPolicy) != DepNowPolicy;};
 101       inline bool InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
 102       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
 103       inline bool Install() const {return Mode == ModeInstall;};
 104       inline VerIterator InstVerIter(pkgCache &Cache)
 105                 {return VerIterator(Cache,InstallVer);};
 106       inline VerIterator CandidateVerIter(pkgCache &Cache)
 107                 {return VerIterator(Cache,CandidateVer);};
 108    };
 109
 110    // Helper functions
 111    void BuildGroupOrs(VerIterator const &V);
 112    void UpdateVerState(PkgIterator Pkg);
 113
 114    // User Policy control
 115    class Policy
 116    {
 117       public:
 118
 119       virtual VerIterator GetCandidateVer(PkgIterator Pkg);
 120       virtual bool IsImportantDep(DepIterator Dep);
 121
 122       virtual ~Policy() {};
 123    };
 124
 125    protected:
 126
 127    // State information
 128    pkgCache *Cache;
 129    StateCache *PkgState;
 130    unsigned char *DepState;
 131
 132    double iUsrSize;
 133    double iDownloadSize;
 134    unsigned long iInstCount;
 135    unsigned long iDelCount;
 136    unsigned long iKeepCount;
 137    unsigned long iBrokenCount;
 138    unsigned long iPolicyBrokenCount;
 139    unsigned long iBadCount;
 140
 141    Policy *delLocalPolicy;           // For memory clean up..
 142    Policy *LocalPolicy;
 143
 144    // Check for a matching provides
 145    bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
 146    inline bool CheckDep(DepIterator Dep,int Type)
 147    {
 148       PkgIterator Res(*this,0);
 149       return CheckDep(Dep,Type,Res);
 150    }
 151
 152    // Computes state information for deps and versions (w/o storing)
 153    unsigned char DependencyState(DepIterator &D);
 154    unsigned char VersionState(DepIterator D,unsigned char Check,
 155                               unsigned char SetMin,
 156                               unsigned char SetPolicy);
 157
 158    // Recalculates various portions of the cache, call after changing something
 159    void Update(DepIterator Dep);           // Mostly internal
 160    void Update(PkgIterator const &P);
 161
 162    // Count manipulators
 163    void AddSizes(const PkgIterator &Pkg,signed long Mult = 1);
 164    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);};
 165    void AddStates(const PkgIterator &Pkg,int Add = 1);
 166    inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);};
 167
 168    public:
 169
 170    // Legacy.. We look like a pkgCache
 171    inline operator pkgCache &() {return *Cache;};
 172    inline Header &Head() {return *Cache->HeaderP;};
 173    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
 174    inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
 175
 176    inline pkgCache &GetCache() {return *Cache;};
 177    inline pkgVersioningSystem &VS() {return *Cache->VS;};
 178
 179    // Policy implementation
 180    inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
 181    inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
 182    inline Policy &GetPolicy() {return *LocalPolicy;};
 183
 184    // Accessors
 185    inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
 186    inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
 187
 188    // Manipulators
 189    void MarkKeep(PkgIterator const &Pkg,bool Soft = false);
 190    void MarkDelete(PkgIterator const &Pkg,bool Purge = false);
 191    void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
 192                     unsigned long Depth = 0, bool ForceImportantDeps = false);
 193    void SetReInstall(PkgIterator const &Pkg,bool To);
 194    void SetCandidateVersion(VerIterator TargetVer);
 195
 196    // This is for debuging
 197    void Update(OpProgress *Prog = 0);
 198
 199    // Size queries
 200    inline double UsrSize() {return iUsrSize;};
 201    inline double DebSize() {return iDownloadSize;};
 202    inline unsigned long DelCount() {return iDelCount;};
 203    inline unsigned long KeepCount() {return iKeepCount;};
 204    inline unsigned long InstCount() {return iInstCount;};
 205    inline unsigned long BrokenCount() {return iBrokenCount;};
 206    inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
 207    inline unsigned long BadCount() {return iBadCount;};
 208
 209    bool Init(OpProgress *Prog);
 210
 211    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
 212    virtual ~pkgDepCache();
 213 };
 214
 215 #endif