]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/pkgcache.h
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
convert some tabs to spaces to respect the style guide
[apt.git] / apt-pkg / pkgcache.h
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: pkgcache.h,v 1.25 2001/07/01 22:28:24 jgg 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
23#include <string>
24#include <time.h>
25#include <apt-pkg/mmap.h>
26
27using std::string;
28
29class pkgVersioningSystem;
30class pkgCache /*{{{*/
31{
32 public:
33 // Cache element predeclarations
34 struct Header;
35 struct Group;
36 struct Package;
37 struct PackageFile;
38 struct Version;
39 struct Description;
40 struct Provides;
41 struct Dependency;
42 struct StringItem;
43 struct VerFile;
44 struct DescFile;
45
46 // Iterators
47 template<typename Str, typename Itr> class Iterator;
48 class GrpIterator;
49 class PkgIterator;
50 class VerIterator;
51 class DescIterator;
52 class DepIterator;
53 class PrvIterator;
54 class PkgFileIterator;
55 class VerFileIterator;
56 class DescFileIterator;
57
58 class Namespace;
59
60 // These are all the constants used in the cache structures
61
62 // WARNING - if you change these lists you must also edit
63 // the stringification in pkgcache.cc and also consider whether
64 // the cache file will become incompatible.
65 struct Dep
66 {
67 enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
68 Conflicts=5,Replaces=6,Obsoletes=7,DpkgBreaks=8,Enhances=9};
69 enum DepCompareOp {Or=0x10,NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
70 Greater=0x4,Equals=0x5,NotEquals=0x6};
71 };
72
73 struct State
74 {
75 enum VerPriority {Important=1,Required=2,Standard=3,Optional=4,Extra=5};
76 enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
77 enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
78 enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
79 HalfInstalled=4,ConfigFiles=5,Installed=6,
80 TriggersAwaited=7,TriggersPending=8};
81 };
82
83 struct Flag
84 {
85 enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
86 enum PkgFFlags {NotSource=(1<<0),NotAutomatic=(1<<1)};
87 };
88
89 protected:
90
91 // Memory mapped cache file
92 string CacheFile;
93 MMap &Map;
94
95 unsigned long sHash(const string &S) const;
96 unsigned long sHash(const char *S) const;
97
98 public:
99
100 // Pointers to the arrays of items
101 Header *HeaderP;
102 Group *GrpP;
103 Package *PkgP;
104 VerFile *VerFileP;
105 DescFile *DescFileP;
106 PackageFile *PkgFileP;
107 Version *VerP;
108 Description *DescP;
109 Provides *ProvideP;
110 Dependency *DepP;
111 StringItem *StringItemP;
112 char *StrP;
113
114 virtual bool ReMap();
115 inline bool Sync() {return Map.Sync();};
116 inline MMap &GetMap() {return Map;};
117 inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();};
118
119 // String hashing function (512 range)
120 inline unsigned long Hash(const string &S) const {return sHash(S);};
121 inline unsigned long Hash(const char *S) const {return sHash(S);};
122
123 // Usefull transformation things
124 const char *Priority(unsigned char Priority);
125
126 // Accessors
127 GrpIterator FindGrp(const string &Name);
128 PkgIterator FindPkg(const string &Name);
129 PkgIterator FindPkg(const string &Name, const string &Arch);
130
131 Header &Head() {return *HeaderP;};
132 inline GrpIterator GrpBegin();
133 inline GrpIterator GrpEnd();
134 inline PkgIterator PkgBegin();
135 inline PkgIterator PkgEnd();
136 inline PkgFileIterator FileBegin();
137 inline PkgFileIterator FileEnd();
138
139 inline bool MultiArchCache() const { return MultiArchEnabled; };
140
141 // Make me a function
142 pkgVersioningSystem *VS;
143
144 // Converters
145 static const char *CompTypeDeb(unsigned char Comp);
146 static const char *CompType(unsigned char Comp);
147 static const char *DepType(unsigned char Dep);
148
149 pkgCache(MMap *Map,bool DoMap = true);
150 virtual ~pkgCache() {};
151
152private:
153 bool MultiArchEnabled;
154 PkgIterator SingleArchFindPkg(const string &Name);
155};
156 /*}}}*/
157// Header structure /*{{{*/
158struct pkgCache::Header
159{
160 // Signature information
161 unsigned long Signature;
162 short MajorVersion;
163 short MinorVersion;
164 bool Dirty;
165
166 // Size of structure values
167 unsigned short HeaderSz;
168 unsigned short PackageSz;
169 unsigned short PackageFileSz;
170 unsigned short VersionSz;
171 unsigned short DescriptionSz;
172 unsigned short DependencySz;
173 unsigned short ProvidesSz;
174 unsigned short VerFileSz;
175 unsigned short DescFileSz;
176
177 // Structure counts
178 unsigned long GroupCount;
179 unsigned long PackageCount;
180 unsigned long VersionCount;
181 unsigned long DescriptionCount;
182 unsigned long DependsCount;
183 unsigned long PackageFileCount;
184 unsigned long VerFileCount;
185 unsigned long DescFileCount;
186 unsigned long ProvidesCount;
187
188 // Offsets
189 map_ptrloc FileList; // struct PackageFile
190 map_ptrloc StringList; // struct StringItem
191 map_ptrloc VerSysName; // StringTable
192 map_ptrloc Architecture; // StringTable
193 unsigned long MaxVerFileSize;
194 unsigned long MaxDescFileSize;
195
196 /* Allocation pools, there should be one of these for each structure
197 excluding the header */
198 DynamicMMap::Pool Pools[9];
199
200 // Rapid package and group name lookup
201 // Notice: Increase only both table sizes as the
202 // hashmethod assume the size of the Pkg one
203 map_ptrloc PkgHashTable[2*1048];
204 map_ptrloc GrpHashTable[2*1048];
205
206 bool CheckSizes(Header &Against) const;
207 Header();
208};
209 /*}}}*/
210struct pkgCache::Group { /*{{{*/
211 map_ptrloc Name; // Stringtable
212
213 // Linked List
214 map_ptrloc FirstPackage;// Package
215 map_ptrloc LastPackage; // Package
216 map_ptrloc Next; // Group
217};
218 /*}}}*/
219struct pkgCache::Package /*{{{*/
220{
221 // Pointers
222 map_ptrloc Name; // Stringtable
223 map_ptrloc Arch; // StringTable (StringItem)
224 map_ptrloc VersionList; // Version
225 map_ptrloc CurrentVer; // Version
226 map_ptrloc Section; // StringTable (StringItem)
227 map_ptrloc Group; // Group the Package belongs to
228
229 // Linked list
230 map_ptrloc NextPackage; // Package
231 map_ptrloc RevDepends; // Dependency
232 map_ptrloc ProvidesList; // Provides
233
234 // Install/Remove/Purge etc
235 unsigned char SelectedState; // What
236 unsigned char InstState; // Flags
237 unsigned char CurrentState; // State
238
239 unsigned int ID;
240 unsigned long Flags;
241};
242 /*}}}*/
243struct pkgCache::PackageFile /*{{{*/
244{
245 // Names
246 map_ptrloc FileName; // Stringtable
247 map_ptrloc Archive; // Stringtable
248 map_ptrloc Codename; // Stringtable
249 map_ptrloc Component; // Stringtable
250 map_ptrloc Version; // Stringtable
251 map_ptrloc Origin; // Stringtable
252 map_ptrloc Label; // Stringtable
253 map_ptrloc Architecture; // Stringtable
254 map_ptrloc Site; // Stringtable
255 map_ptrloc IndexType; // Stringtable
256 unsigned long Size;
257 unsigned long Flags;
258
259 // Linked list
260 map_ptrloc NextFile; // PackageFile
261 unsigned int ID;
262 time_t mtime; // Modification time for the file
263};
264 /*}}}*/
265struct pkgCache::VerFile /*{{{*/
266{
267 map_ptrloc File; // PackageFile
268 map_ptrloc NextFile; // PkgVerFile
269 map_ptrloc Offset; // File offset
270 unsigned long Size;
271};
272 /*}}}*/
273struct pkgCache::DescFile /*{{{*/
274{
275 map_ptrloc File; // PackageFile
276 map_ptrloc NextFile; // PkgVerFile
277 map_ptrloc Offset; // File offset
278 unsigned long Size;
279};
280 /*}}}*/
281struct pkgCache::Version /*{{{*/
282{
283 map_ptrloc VerStr; // Stringtable
284 map_ptrloc Section; // StringTable (StringItem)
285 enum {None, All, Foreign, Same, Allowed} MultiArch;
286
287 // Lists
288 map_ptrloc FileList; // VerFile
289 map_ptrloc NextVer; // Version
290 map_ptrloc DescriptionList; // Description
291 map_ptrloc DependsList; // Dependency
292 map_ptrloc ParentPkg; // Package
293 map_ptrloc ProvidesList; // Provides
294
295 map_ptrloc Size; // These are the .deb size
296 map_ptrloc InstalledSize;
297 unsigned short Hash;
298 unsigned int ID;
299 unsigned char Priority;
300};
301 /*}}}*/
302struct pkgCache::Description /*{{{*/
303{
304 // Language Code store the description translation language code. If
305 // the value has a 0 lenght then this is readed using the Package
306 // file else the Translation-CODE are used.
307 map_ptrloc language_code; // StringTable
308 map_ptrloc md5sum; // StringTable
309
310 // Linked list
311 map_ptrloc FileList; // DescFile
312 map_ptrloc NextDesc; // Description
313 map_ptrloc ParentPkg; // Package
314
315 unsigned int ID;
316};
317 /*}}}*/
318struct pkgCache::Dependency /*{{{*/
319{
320 map_ptrloc Version; // Stringtable
321 map_ptrloc Package; // Package
322 map_ptrloc NextDepends; // Dependency
323 map_ptrloc NextRevDepends; // Dependency
324 map_ptrloc ParentVer; // Version
325
326 // Specific types of depends
327 map_ptrloc ID;
328 unsigned char Type;
329 unsigned char CompareOp;
330};
331 /*}}}*/
332struct pkgCache::Provides /*{{{*/
333{
334 map_ptrloc ParentPkg; // Pacakge
335 map_ptrloc Version; // Version
336 map_ptrloc ProvideVersion; // Stringtable
337 map_ptrloc NextProvides; // Provides
338 map_ptrloc NextPkgProv; // Provides
339};
340 /*}}}*/
341struct pkgCache::StringItem /*{{{*/
342{
343 map_ptrloc String; // Stringtable
344 map_ptrloc NextItem; // StringItem
345};
346 /*}}}*/
347#include <apt-pkg/cacheiterators.h>
348
349inline pkgCache::GrpIterator pkgCache::GrpBegin()
350 {return GrpIterator(*this);};
351inline pkgCache::GrpIterator pkgCache::GrpEnd()
352 {return GrpIterator(*this,GrpP);};
353inline pkgCache::PkgIterator pkgCache::PkgBegin()
354 {return PkgIterator(*this);};
355inline pkgCache::PkgIterator pkgCache::PkgEnd()
356 {return PkgIterator(*this,PkgP);};
357inline pkgCache::PkgFileIterator pkgCache::FileBegin()
358 {return PkgFileIterator(*this,PkgFileP + HeaderP->FileList);};
359inline pkgCache::PkgFileIterator pkgCache::FileEnd()
360 {return PkgFileIterator(*this,PkgFileP);};
361
362// Oh I wish for Real Name Space Support
363class pkgCache::Namespace /*{{{*/
364{
365 public:
366 typedef pkgCache::GrpIterator GrpIterator;
367 typedef pkgCache::PkgIterator PkgIterator;
368 typedef pkgCache::VerIterator VerIterator;
369 typedef pkgCache::DescIterator DescIterator;
370 typedef pkgCache::DepIterator DepIterator;
371 typedef pkgCache::PrvIterator PrvIterator;
372 typedef pkgCache::PkgFileIterator PkgFileIterator;
373 typedef pkgCache::VerFileIterator VerFileIterator;
374 typedef pkgCache::Version Version;
375 typedef pkgCache::Description Description;
376 typedef pkgCache::Package Package;
377 typedef pkgCache::Header Header;
378 typedef pkgCache::Dep Dep;
379 typedef pkgCache::Flag Flag;
380};
381 /*}}}*/
382#endif
APT (for Cydia)