- more off_t typing fixes (Ralf)
[apt.git] / apt-pkg / pkgcache.h
1 // -*- mode: c++; mode: fold -*-
2 // Description                                                          /*{{{*/
3 // $Id: pkgcache.h,v 1.2 2003/01/29 13:04:48 niemeyer Exp $
4 /* ######################################################################
5    
6    Cache - Structure definitions for the cache file
7    
8    Please see doc/apt-pkg/cache.sgml for a more detailed description of 
9    this format. Also be sure to keep that file up-to-date!!
10    
11    Clients should always use the CacheIterators classes for access to the
12    cache. They provide a simple STL-like method for traversing the links
13    of the datastructure.
14    
15    See pkgcachegen.h for information about generating cache structures.
16    
17    ##################################################################### */
18                                                                         /*}}}*/
19 #ifndef PKGLIB_PKGCACHE_H
20 #define PKGLIB_PKGCACHE_H
21
22 #ifdef __GNUG__
23 #pragma interface "apt-pkg/pkgcache.h"
24 #endif 
25
26 #include <string>
27 #include <time.h>
28 #include <apt-pkg/mmap.h>
29
30 using std::string;
31     
32 class pkgVersioningSystem;
33 class pkgCache
34 {
35    public:
36    // Cache element predeclarations
37    struct Header;
38    struct Package;
39    struct PackageFile;
40    struct Version;
41    struct Provides;
42    struct Dependency;
43    struct StringItem;
44    struct VerFile;
45    
46    // Iterators
47    class PkgIterator;
48    class VerIterator;
49    class DepIterator;
50    class PrvIterator;
51    class PkgFileIterator;
52    class VerFileIterator;
53    friend class PkgIterator;
54    friend class VerIterator;
55    friend class DepIterator;
56    friend class PrvIterator;
57    friend class PkgFileIterator;
58    friend class VerFileIterator;
59    
60    class Namespace;
61    
62    // These are all the constants used in the cache structures
63    struct Dep
64    {
65       enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
66          Conflicts=5,Replaces=6,Obsoletes=7};
67       enum DepCompareOp {Or=0x10,NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
68          Greater=0x4,Equals=0x5,NotEquals=0x6};
69    };
70    
71    struct State
72    {
73       enum VerPriority {Important=1,Required=2,Standard=3,Optional=4,Extra=5};
74       enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
75       enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
76       enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
77            HalfInstalled=4,ConfigFiles=5,Installed=6};
78    };
79    
80    struct Flag
81    {
82       enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
83       enum PkgFFlags {NotSource=(1<<0),NotAutomatic=(1<<1)};
84    };
85
86    /* Unnested structures for SWIG. Don't use them for APT internal
87     * purposes as this will be dropped as soon as SWIG starts
88     * supporting nested structures. Use definitions above instead. */
89    enum _DepType {DepDepends=1,DepPreDepends=2,DepSuggests=3,DepRecommends=4,
90       DepConflicts=5,DepReplaces=6,DepObsoletes=7};
91    enum _DepCompareOp {DepOr=0x10,DepNoOp=0,DepLessEq=0x1,DepGreaterEq=0x2,
92       DepLess=0x3,DepGreater=0x4,DepEquals=0x5,DepNotEquals=0x6};
93    enum _VerPriority {StateImportant=1,StateRequired=2,StateStandard=3,
94       StateOptional=4,StateExtra=5};
95    enum _PkgSelectedState {StateUnknown=0,StateInstall=1,StateHold=2,
96       StateDeInstall=3,StatePurge=4};
97    enum _PkgInstState {StateOk=0,StateReInstReq=1,StateHoldInst=2,
98       StateHoldReInstReq=3};
99    enum _PkgCurrentState {StateNotInstalled=0,StateUnPacked=1,
100       StateHalfConfigured=2,StateHalfInstalled=4,StateConfigFiles=5,
101       StateInstalled=6};
102    enum _PkgFlags {FlagAuto=(1<<0),FlagEssential=(1<<3),FlagImportant=(1<<4)};
103    enum _PkgFFlags {FlagNotSource=(1<<0),FlagNotAutomatic=(1<<1)};
104    
105    protected:
106    
107    // Memory mapped cache file
108    string CacheFile;
109    MMap &Map;
110
111    // CNC:2003-02-16 - Inlined here.
112    inline unsigned long sHash(const char *S) const;
113    inline unsigned long sHash(string S) const {return sHash(S.c_str());};
114    
115    public:
116    
117    // Pointers to the arrays of items
118    Header *HeaderP;
119    Package *PkgP;
120    VerFile *VerFileP;
121    PackageFile *PkgFileP;
122    Version *VerP;
123    Provides *ProvideP;
124    Dependency *DepP;
125    StringItem *StringItemP;
126    char *StrP;
127
128    virtual bool ReMap();
129    inline bool Sync() {return Map.Sync();};
130    inline MMap &GetMap() {return Map;};
131    inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();};
132       
133    // String hashing function (512 range)
134    inline unsigned long Hash(string S) const {return sHash(S);};
135    inline unsigned long Hash(const char *S) const {return sHash(S);};
136
137    // Usefull transformation things
138    const char *Priority(unsigned char Priority);
139    
140    // Accessors
141    PkgIterator FindPkg(string Name);
142    // CNC:2003-02-17 - A slightly changed FindPkg(), hacked for performance.
143    Package *FindPackage(const char *Name);
144    Header &Head() {return *HeaderP;};
145    inline PkgIterator PkgBegin();
146    inline PkgIterator PkgEnd();
147    inline PkgFileIterator FileBegin();
148    inline PkgFileIterator FileEnd();
149
150    // Make me a function
151    pkgVersioningSystem *VS;
152    
153    // Converters
154    static const char *CompTypeDeb(unsigned char Comp);
155    static const char *CompType(unsigned char Comp);
156    static const char *DepType(unsigned char Dep);
157    
158    pkgCache(MMap *Map,bool DoMap = true);
159    virtual ~pkgCache() {};
160 };
161
162 // Header structure
163 struct pkgCache::Header
164 {
165    // Signature information
166    unsigned long Signature;
167    short MajorVersion;
168    short MinorVersion;
169    bool Dirty;
170
171    // CNC:2003-03-18
172    bool HasFileDeps;
173
174    // CNC:2003-11-24
175    unsigned long OptionsHash;
176    
177    // Size of structure values
178    unsigned short HeaderSz;
179    unsigned short PackageSz;
180    unsigned short PackageFileSz;
181    unsigned short VersionSz;
182    unsigned short DependencySz;
183    unsigned short ProvidesSz;
184    unsigned short VerFileSz;
185    
186    // Structure counts
187    unsigned long PackageCount;
188    unsigned long VersionCount;
189    unsigned long DependsCount;
190    unsigned long PackageFileCount;
191    unsigned long VerFileCount;
192    unsigned long ProvidesCount;
193    
194    // Offsets
195    map_ptrloc FileList;              // struct PackageFile
196    map_ptrloc StringList;            // struct StringItem
197    map_ptrloc VerSysName;            // StringTable
198    map_ptrloc Architecture;          // StringTable
199    unsigned long MaxVerFileSize;
200
201    /* Allocation pools, there should be one of these for each structure
202       excluding the header */
203    DynamicMMap::Pool Pools[7];
204    
205    // Rapid package name lookup
206    map_ptrloc HashTable[8*1048];
207
208    bool CheckSizes(Header &Against) const;
209    Header();
210 };
211
212 struct pkgCache::Package
213 {
214    // Pointers
215    map_ptrloc Name;              // Stringtable
216    map_ptrloc VersionList;       // Version
217    map_ptrloc CurrentVer;        // Version
218    map_ptrloc Section;           // StringTable (StringItem)
219       
220    // Linked list 
221    map_ptrloc NextPackage;       // Package
222    map_ptrloc RevDepends;        // Dependency
223    map_ptrloc ProvidesList;      // Provides
224    
225    // Install/Remove/Purge etc
226    unsigned char SelectedState;     // What
227    unsigned char InstState;         // Flags
228    unsigned char CurrentState;      // State
229    
230    unsigned short ID;
231    unsigned long Flags;
232 };
233
234 struct pkgCache::PackageFile
235 {
236    // Names
237    map_ptrloc FileName;        // Stringtable
238    map_ptrloc Archive;         // Stringtable
239    map_ptrloc Component;       // Stringtable
240    map_ptrloc Version;         // Stringtable
241    map_ptrloc Origin;          // Stringtable
242    map_ptrloc Label;           // Stringtable
243    map_ptrloc Architecture;    // Stringtable
244    map_ptrloc Site;            // Stringtable
245    map_ptrloc IndexType;       // Stringtable
246    unsigned long Size;            
247    unsigned long Flags;
248    
249    // Linked list
250    map_ptrloc NextFile;        // PackageFile
251    unsigned short ID;
252    time_t mtime;                  // Modification time for the file
253 };
254
255 struct pkgCache::VerFile
256 {
257    map_ptrloc File;           // PackageFile
258    map_ptrloc NextFile;       // PkgVerFile
259    map_ptrloc Offset;         // File offset
260    unsigned short Size;
261 };
262
263 struct pkgCache::Version
264 {
265    map_ptrloc VerStr;            // Stringtable
266    map_ptrloc Section;           // StringTable (StringItem)
267    map_ptrloc Arch;              // StringTable
268       
269    // Lists
270    map_ptrloc FileList;          // VerFile
271    map_ptrloc NextVer;           // Version
272    map_ptrloc DependsList;       // Dependency
273    map_ptrloc ParentPkg;         // Package
274    map_ptrloc ProvidesList;      // Provides
275    
276    off_t Size;                   // These are the .deb size
277    map_ptrloc InstalledSize;
278    unsigned short Hash;
279    unsigned short ID;
280    unsigned char Priority;
281 };
282
283 struct pkgCache::Dependency
284 {
285    map_ptrloc Version;         // Stringtable
286    map_ptrloc Package;         // Package
287    map_ptrloc NextDepends;     // Dependency
288    map_ptrloc NextRevDepends;  // Dependency
289    map_ptrloc ParentVer;       // Version
290    
291    // Specific types of depends
292    map_ptrloc ID;   
293    unsigned char Type;
294    unsigned char CompareOp;
295 };
296
297 struct pkgCache::Provides
298 {
299    map_ptrloc ParentPkg;        // Pacakge
300    map_ptrloc Version;          // Version
301    map_ptrloc ProvideVersion;   // Stringtable
302    map_ptrloc NextProvides;     // Provides
303    map_ptrloc NextPkgProv;      // Provides
304 };
305
306 struct pkgCache::StringItem
307 {
308    map_ptrloc String;        // Stringtable
309    map_ptrloc NextItem;      // StringItem
310 };
311
312 #include <apt-pkg/cacheiterators.h>
313
314 // CNC:2003-02-16 - Inlined here.
315 #include <ctype.h>
316 #define hash_count(a) (sizeof(a)/sizeof(a[0]))
317 inline unsigned long pkgCache::sHash(const char *Str) const
318 {
319    unsigned long Hash = 0;
320    for (const char *I = Str; *I != 0; I++)
321       //Hash = 5*Hash + tolower(*I);
322       Hash = 5*Hash + *I;
323    return Hash % hash_count(HeaderP->HashTable);
324 }
325 #undef hash_count
326
327 inline pkgCache::PkgIterator pkgCache::PkgBegin() 
328        {return PkgIterator(*this);}
329 inline pkgCache::PkgIterator pkgCache::PkgEnd() 
330        {return PkgIterator(*this,PkgP);}
331 inline pkgCache::PkgFileIterator pkgCache::FileBegin()
332        {return PkgFileIterator(*this,PkgFileP + HeaderP->FileList);}
333 inline pkgCache::PkgFileIterator pkgCache::FileEnd()
334        {return PkgFileIterator(*this,PkgFileP);}
335
336 // Oh I wish for Real Name Space Support
337 class pkgCache::Namespace
338 {   
339    public:
340
341    typedef pkgCache::PkgIterator PkgIterator;
342    typedef pkgCache::VerIterator VerIterator;
343    typedef pkgCache::DepIterator DepIterator;
344    typedef pkgCache::PrvIterator PrvIterator;
345    typedef pkgCache::PkgFileIterator PkgFileIterator;
346    typedef pkgCache::VerFileIterator VerFileIterator;   
347    typedef pkgCache::Version Version;
348    typedef pkgCache::Package Package;
349    typedef pkgCache::Header Header;
350    typedef pkgCache::Dep Dep;
351    typedef pkgCache::Flag Flag;
352 };
353
354 #endif
355
356 // vim:sts=3:sw=3