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 InstBroken() const {return (DepState & DepInstMin) != DepInstMin;};
 101       inline bool InstPolicyBroken() const {return (DepState & DepInstPolicy) != DepInstPolicy;};
 102       inline bool Install() const {return Mode == ModeInstall;};
 103       inline VerIterator InstVerIter(pkgCache &Cache)
 104                 {return VerIterator(Cache,InstallVer);};
 105       inline VerIterator CandidateVerIter(pkgCache &Cache)
 106                 {return VerIterator(Cache,CandidateVer);};
 107    };
 108
 109    // Helper functions
 110    void BuildGroupOrs(VerIterator const &V);
 111    void UpdateVerState(PkgIterator Pkg);
 112
 113    // User Policy control
 114    class Policy
 115    {
 116       public:
 117
 118       virtual VerIterator GetCandidateVer(PkgIterator Pkg);
 119       virtual bool IsImportantDep(DepIterator Dep);
 120
 121       virtual ~Policy() {};
 122    };
 123
 124    protected:
 125
 126    // State information
 127    pkgCache *Cache;
 128    StateCache *PkgState;
 129    unsigned char *DepState;
 130
 131    double iUsrSize;
 132    double iDownloadSize;
 133    unsigned long iInstCount;
 134    unsigned long iDelCount;
 135    unsigned long iKeepCount;
 136    unsigned long iBrokenCount;
 137    unsigned long iBadCount;
 138
 139    Policy *delLocalPolicy;           // For memory clean up..
 140    Policy *LocalPolicy;
 141
 142    // Check for a matching provides
 143    bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
 144    inline bool CheckDep(DepIterator Dep,int Type)
 145    {
 146       PkgIterator Res(*this,0);
 147       return CheckDep(Dep,Type,Res);
 148    }
 149
 150    // Computes state information for deps and versions (w/o storing)
 151    unsigned char DependencyState(DepIterator &D);
 152    unsigned char VersionState(DepIterator D,unsigned char Check,
 153                               unsigned char SetMin,
 154                               unsigned char SetPolicy);
 155
 156    // Recalculates various portions of the cache, call after changing something
 157    void Update(DepIterator Dep);           // Mostly internal
 158    void Update(PkgIterator const &P);
 159
 160    // Count manipulators
 161    void AddSizes(const PkgIterator &Pkg,signed long Mult = 1);
 162    inline void RemoveSizes(const PkgIterator &Pkg) {AddSizes(Pkg,-1);};
 163    void AddStates(const PkgIterator &Pkg,int Add = 1);
 164    inline void RemoveStates(const PkgIterator &Pkg) {AddStates(Pkg,-1);};
 165
 166    public:
 167
 168    // Legacy.. We look like a pkgCache
 169    inline operator pkgCache &() {return *Cache;};
 170    inline Header &Head() {return *Cache->HeaderP;};
 171    inline PkgIterator PkgBegin() {return Cache->PkgBegin();};
 172    inline PkgIterator FindPkg(string const &Name) {return Cache->FindPkg(Name);};
 173
 174    inline pkgCache &GetCache() {return *Cache;};
 175    inline pkgVersioningSystem &VS() {return *Cache->VS;};
 176
 177    // Policy implementation
 178    inline VerIterator GetCandidateVer(PkgIterator Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
 179    inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
 180    inline Policy &GetPolicy() {return *LocalPolicy;};
 181
 182    // Accessors
 183    inline StateCache &operator [](PkgIterator const &I) {return PkgState[I->ID];};
 184    inline unsigned char &operator [](DepIterator const &I) {return DepState[I->ID];};
 185
 186    // Manipulators
 187    void MarkKeep(PkgIterator const &Pkg,bool Soft = false);
 188    void MarkDelete(PkgIterator const &Pkg,bool Purge = false);
 189    void MarkInstall(PkgIterator const &Pkg,bool AutoInst = true,
 190                     unsigned long Depth = 0);
 191    void SetReInstall(PkgIterator const &Pkg,bool To);
 192    void SetCandidateVersion(VerIterator TargetVer);
 193
 194    // This is for debuging
 195    void Update(OpProgress *Prog = 0);
 196
 197    // Size queries
 198    inline double UsrSize() {return iUsrSize;};
 199    inline double DebSize() {return iDownloadSize;};
 200    inline unsigned long DelCount() {return iDelCount;};
 201    inline unsigned long KeepCount() {return iKeepCount;};
 202    inline unsigned long InstCount() {return iInstCount;};
 203    inline unsigned long BrokenCount() {return iBrokenCount;};
 204    inline unsigned long BadCount() {return iBadCount;};
 205
 206    bool Init(OpProgress *Prog);
 207
 208    pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
 209    virtual ~pkgDepCache();
 210 };
 211
 212 #endif