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