]> git.saurik.com Git - apt.git/blame - apt-pkg/pkgcache.h
just-in-time removal of broken essential packages
[apt.git] / apt-pkg / pkgcache.h
CommitLineData
578bfd0a
AL
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
94449d7c
DK
3/**\file pkgcache.h
4 \brief pkgCache - Structure definitions for the cache file
5
6 The goal of the cache file is two fold:
7 Firstly to speed loading and processing of the package file array and
8 secondly to reduce memory consumption of the package file array.
9
10 The implementation is aimed at an environment with many primary package
11 files, for instance someone that has a Package file for their CD-ROM, a
12 Package file for the latest version of the distribution on the CD-ROM and a
13 package file for the development version. Always present is the information
14 contained in the status file which might be considered a separate package
15 file.
16
17 Please understand, this is designed as a <b>Cache file</b> it is not meant to be
18 used on any system other than the one it was created for. It is not meant to
19 be authoritative either, i.e. if a system crash or software failure occurs it
20 must be perfectly acceptable for the cache file to be in an inconsistent
21 state. Furthermore at any time the cache file may be erased without losing
22 any information.
23
24 Also the structures and storage layout is optimized for use by the APT
25 and may not be suitable for all purposes. However it should be possible
26 to extend it with associate cache files that contain other information.
27
28 To keep memory use down the cache file only contains often used fields and
29 fields that are inexpensive to store, the Package file has a full list of
30 fields. Also the client may assume that all items are perfectly valid and
31 need not perform checks against their correctness. Removal of information
32 from the cache is possible, but blanks will be left in the file, and
33 unused strings will also be present. The recommended implementation is to
34 simply rebuild the cache each time any of the data files change. It is
35 possible to add a new package file to the cache without any negative side
36 effects.
37
38 <b>Note on Pointer access</b>
578bfd0a 39 Clients should always use the CacheIterators classes for access to the
94449d7c
DK
40 cache and the data in it. They also provide a simple STL-like method for
41 traversing the links of the datastructure.
42
43 Every item in every structure is stored as the index to that structure.
44 What this means is that once the files is mmaped every data access has to
45 go through a fix up stage to get a real memory pointer. This is done
46 by taking the index, multiplying it by the type size and then adding
47 it to the start address of the memory block. This sounds complex, but
48 in C it is a single array dereference. Because all items are aligned to
49 their size and indexes are stored as multiples of the size of the structure
50 the format is immediately portable to all possible architectures - BUT the
51 generated files are -NOT-.
52
53 This scheme allows code like this to be written:
54 <example>
55 void *Map = mmap(...);
56 Package *PkgList = (Package *)Map;
57 Header *Head = (Header *)Map;
58 char *Strings = (char *)Map;
59 cout << (Strings + PkgList[Head->HashTable[0]]->Name) << endl;
60 </example>
61 Notice the lack of casting or multiplication. The net result is to return
62 the name of the first package in the first hash bucket, without error
63 checks.
64
65 The generator uses allocation pools to group similarly sized structures in
66 large blocks to eliminate any alignment overhead. The generator also
67 assures that no structures overlap and all indexes are unique. Although
68 at first glance it may seem like there is the potential for two structures
69 to exist at the same point the generator never allows this to happen.
70 (See the discussion of free space pools)
71
72 See \ref pkgcachegen.h for more information about generating cache structures. */
578bfd0a 73 /*}}}*/
578bfd0a
AL
74#ifndef PKGLIB_PKGCACHE_H
75#define PKGLIB_PKGCACHE_H
76
a02db58f
DK
77#include <apt-pkg/mmap.h>
78#include <apt-pkg/macros.h>
79
578bfd0a
AL
80#include <string>
81#include <time.h>
4ad8619b 82#include <stdint.h>
0a843901 83
a4f6bdc8
DK
84#ifndef APT_8_CLEANER_HEADERS
85using std::string;
86#endif
87
4dc77823
DK
88// size of (potentially big) files like debs or the install size of them
89typedef uint64_t map_filesize_t;
4ad8619b 90// storing file sizes of indexes, which are way below 4 GB for now
4dc77823 91typedef uint32_t map_filesize_small_t;
4ad8619b
DK
92// each package/group/dependency gets an id
93typedef uint32_t map_id_t;
94// some files get an id, too, but in far less absolute numbers
95typedef uint16_t map_fileid_t;
96// relative pointer from cache start
97typedef uint32_t map_pointer_t;
98// same as the previous, but documented to be to a string item
99typedef map_pointer_t map_stringitem_t;
dfe66c72
DK
100// we have only a small amount of flags for each item
101typedef uint8_t map_flags_t;
102typedef uint8_t map_number_t;
4ad8619b 103
b2e465d6 104class pkgVersioningSystem;
92fcbfc1 105class pkgCache /*{{{*/
578bfd0a
AL
106{
107 public:
108 // Cache element predeclarations
109 struct Header;
5bf15716 110 struct Group;
578bfd0a 111 struct Package;
b07aeb1a 112 struct ReleaseFile;
578bfd0a
AL
113 struct PackageFile;
114 struct Version;
a52f938b 115 struct Description;
578bfd0a
AL
116 struct Provides;
117 struct Dependency;
71c9e95b 118 struct DependencyData;
32ab4bd0 119 struct StringItem;
dcb79bae 120 struct VerFile;
a52f938b 121 struct DescFile;
578bfd0a
AL
122
123 // Iterators
773e2c1f 124 template<typename Str, typename Itr> class Iterator;
5bf15716 125 class GrpIterator;
578bfd0a
AL
126 class PkgIterator;
127 class VerIterator;
a52f938b 128 class DescIterator;
578bfd0a
AL
129 class DepIterator;
130 class PrvIterator;
b07aeb1a 131 class RlsFileIterator;
578bfd0a 132 class PkgFileIterator;
dcb79bae 133 class VerFileIterator;
a52f938b 134 class DescFileIterator;
b2e465d6
AL
135
136 class Namespace;
dcb79bae 137
f55a958f 138 // These are all the constants used in the cache structures
308c7d30
IJ
139
140 // WARNING - if you change these lists you must also edit
141 // the stringification in pkgcache.cc and also consider whether
142 // the cache file will become incompatible.
6c139d6e
AL
143 struct Dep
144 {
145 enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
f8ae7e8b 146 Conflicts=5,Replaces=6,Obsoletes=7,DpkgBreaks=8,Enhances=9};
94449d7c
DK
147 /** \brief available compare operators
148
149 The lower 4 bits are used to indicate what operator is being specified and
150 the upper 4 bits are flags. OR indicates that the next package is
151 or'd with the current package. */
8c7af4d4
DK
152 enum DepCompareOp {NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
153 Greater=0x4,Equals=0x5,NotEquals=0x6,
154 Or=0x10, /*!< or'ed with the next dependency */
155 MultiArchImplicit=0x20, /*!< generated internally, not spelled out in the index */
156 ArchSpecific=0x40 /*!< was decorated with an explicit architecture in index */
157 };
6c139d6e
AL
158 };
159
160 struct State
161 {
94449d7c
DK
162 /** \brief priority of a package version
163
164 Zero is used for unparsable or absent Priority fields. */
9005f08e 165 enum VerPriority {Required=1,Important=2,Standard=3,Optional=4,Extra=5};
6c139d6e
AL
166 enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
167 enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
168 enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
9d06bc80
MV
169 HalfInstalled=4,ConfigFiles=5,Installed=6,
170 TriggersAwaited=7,TriggersPending=8};
6c139d6e
AL
171 };
172
173 struct Flag
174 {
138d4b3d 175 enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
448c38bd
DK
176 enum PkgFFlags {
177 NotSource=(1<<0), /*!< packages can't be fetched from here, e.g. dpkg/status file */
b07aeb1a 178 LocalSource=(1<<1), /*!< local sources can't and will not be verified by hashes */
d2cb5b15 179 NoPackages=(1<<2), /*!< the file includes no package records itself, but additions like Translations */
b07aeb1a
DK
180 };
181 enum ReleaseFileFlags {
182 NotAutomatic=(1<<0), /*!< archive has a default pin of 1 */
183 ButAutomaticUpgrades=(1<<1), /*!< (together with the previous) archive has a default pin of 100 */
448c38bd 184 };
8c7af4d4
DK
185 enum ProvidesFlags {
186 MultiArchImplicit=pkgCache::Dep::MultiArchImplicit, /*!< generated internally, not spelled out in the index */
187 ArchSpecific=pkgCache::Dep::ArchSpecific /*!< was decorated with an explicit architecture in index */
188 };
6c139d6e 189 };
578bfd0a
AL
190
191 protected:
192
193 // Memory mapped cache file
8f3ba4e8 194 std::string CacheFile;
578bfd0a
AL
195 MMap &Map;
196
4ad8619b
DK
197 map_id_t sHash(const std::string &S) const APT_PURE;
198 map_id_t sHash(const char *S) const APT_PURE;
578bfd0a
AL
199
200 public:
201
202 // Pointers to the arrays of items
203 Header *HeaderP;
5bf15716 204 Group *GrpP;
578bfd0a 205 Package *PkgP;
dcb79bae 206 VerFile *VerFileP;
a52f938b 207 DescFile *DescFileP;
b07aeb1a 208 ReleaseFile *RlsFileP;
578bfd0a
AL
209 PackageFile *PkgFileP;
210 Version *VerP;
a52f938b 211 Description *DescP;
578bfd0a
AL
212 Provides *ProvideP;
213 Dependency *DepP;
71c9e95b 214 DependencyData *DepDataP;
32ab4bd0 215 APT_DEPRECATED StringItem *StringItemP;
578bfd0a 216 char *StrP;
dcb79bae 217
a9fe5928 218 virtual bool ReMap(bool const &Errorchecks = true);
d3e8fbb3
DK
219 inline bool Sync() {return Map.Sync();}
220 inline MMap &GetMap() {return Map;}
221 inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();}
b2e465d6 222
578bfd0a 223 // String hashing function (512 range)
4ad8619b
DK
224 inline map_id_t Hash(const std::string &S) const {return sHash(S);}
225 inline map_id_t Hash(const char *S) const {return sHash(S);}
578bfd0a 226
94449d7c 227 // Useful transformation things
ebc5b43c 228 static const char *Priority(unsigned char Priority);
0149949b 229
578bfd0a 230 // Accessors
8f3ba4e8
DK
231 GrpIterator FindGrp(const std::string &Name);
232 PkgIterator FindPkg(const std::string &Name);
233 PkgIterator FindPkg(const std::string &Name, const std::string &Arch);
5bf15716 234
d3e8fbb3 235 Header &Head() {return *HeaderP;}
25396fb0
DK
236 inline GrpIterator GrpBegin();
237 inline GrpIterator GrpEnd();
578bfd0a
AL
238 inline PkgIterator PkgBegin();
239 inline PkgIterator PkgEnd();
ad00ae81
AL
240 inline PkgFileIterator FileBegin();
241 inline PkgFileIterator FileEnd();
b07aeb1a
DK
242 inline RlsFileIterator RlsFileBegin();
243 inline RlsFileIterator RlsFileEnd();
b2e465d6 244
d3e8fbb3 245 inline bool MultiArchCache() const { return MultiArchEnabled; }
d64e130a 246 inline char const * NativeArch();
8d4c859d 247
b2e465d6
AL
248 // Make me a function
249 pkgVersioningSystem *VS;
250
251 // Converters
a02db58f
DK
252 static const char *CompTypeDeb(unsigned char Comp) APT_CONST;
253 static const char *CompType(unsigned char Comp) APT_CONST;
b2e465d6 254 static const char *DepType(unsigned char Dep);
c8a4ce6c 255
b2e465d6 256 pkgCache(MMap *Map,bool DoMap = true);
c8a4ce6c 257 virtual ~pkgCache();
8d4c859d
DK
258
259private:
6c55f07a 260 void * const d;
8d4c859d 261 bool MultiArchEnabled;
3809194b 262 APT_HIDDEN PkgIterator SingleArchFindPkg(const std::string &Name);
578bfd0a 263};
92fcbfc1
DK
264 /*}}}*/
265// Header structure /*{{{*/
578bfd0a
AL
266struct pkgCache::Header
267{
94449d7c
DK
268 /** \brief Signature information
269
270 This must contain the hex value 0x98FE76DC which is designed to
271 verify that the system loading the image has the same byte order
272 and byte size as the system saving the image */
dfe66c72 273 uint32_t Signature;
94449d7c 274 /** These contain the version of the cache file */
dfe66c72
DK
275 map_number_t MajorVersion;
276 map_number_t MinorVersion;
94449d7c
DK
277 /** \brief indicates if the cache should be erased
278
279 Dirty is true if the cache file was opened for reading, the client
280 expects to have written things to it and have not fully synced it.
281 The file should be erased and rebuilt if it is true. */
578bfd0a 282 bool Dirty;
94449d7c
DK
283
284 /** \brief Size of structure values
285
286 All *Sz variables contains the sizeof() that particular structure.
287 It is used as an extra consistency check on the structure of the file.
288
289 If any of the size values do not exactly match what the client expects
290 then the client should refuse the load the file. */
dfe66c72
DK
291 uint16_t HeaderSz;
292 map_number_t GroupSz;
293 map_number_t PackageSz;
294 map_number_t ReleaseFileSz;
295 map_number_t PackageFileSz;
296 map_number_t VersionSz;
297 map_number_t DescriptionSz;
298 map_number_t DependencySz;
299 map_number_t DependencyDataSz;
300 map_number_t ProvidesSz;
301 map_number_t VerFileSz;
302 map_number_t DescFileSz;
94449d7c
DK
303
304 /** \brief Structure counts
305
306 These indicate the number of each structure contained in the cache.
307 PackageCount is especially useful for generating user state structures.
308 See Package::Id for more info. */
4ad8619b
DK
309 map_id_t GroupCount;
310 map_id_t PackageCount;
311 map_id_t VersionCount;
312 map_id_t DescriptionCount;
313 map_id_t DependsCount;
71c9e95b 314 map_id_t DependsDataCount;
b07aeb1a 315 map_fileid_t ReleaseFileCount;
4ad8619b
DK
316 map_fileid_t PackageFileCount;
317 map_fileid_t VerFileCount;
318 map_fileid_t DescFileCount;
319 map_id_t ProvidesCount;
94449d7c
DK
320
321 /** \brief index of the first PackageFile structure
322
323 The PackageFile structures are singly linked lists that represent
324 all package files that have been merged into the cache. */
4ad8619b 325 map_pointer_t FileList;
b07aeb1a
DK
326 /** \brief index of the first ReleaseFile structure */
327 map_pointer_t RlsFileList;
328
94449d7c 329 /** \brief String representing the version system used */
4ad8619b 330 map_pointer_t VerSysName;
7a223b93 331 /** \brief native architecture the cache was built against */
4ad8619b 332 map_pointer_t Architecture;
7a223b93 333 /** \brief all architectures the cache was built against */
4ad8619b 334 map_pointer_t Architectures;
94449d7c 335 /** \brief The maximum size of a raw entry from the original Package file */
4ad8619b 336 map_filesize_t MaxVerFileSize;
94449d7c 337 /** \brief The maximum size of a raw entry from the original Translation file */
4ad8619b 338 map_filesize_t MaxDescFileSize;
578bfd0a 339
94449d7c
DK
340 /** \brief The Pool structures manage the allocation pools that the generator uses
341
342 Start indicates the first byte of the pool, Count is the number of objects
343 remaining in the pool and ItemSize is the structure size (alignment factor)
344 of the pool. An ItemSize of 0 indicates the pool is empty. There should be
345 the same number of pools as there are structure types. The generator
346 stores this information so future additions can make use of any unused pool
347 blocks. */
b291aa59 348 DynamicMMap::Pool Pools[12];
e8a7b0b2 349
94449d7c
DK
350 /** \brief hash tables providing rapid group/package name lookup
351
e8a7b0b2 352 Each group/package name is inserted into a hash table using pkgCache::Hash(const &string)
94449d7c
DK
353 By iterating over each entry in the hash table it is possible to iterate over
354 the entire list of packages. Hash Collisions are handled with a singly linked
355 list of packages based at the hash item. The linked list contains only
356 packages that match the hashing function.
357 In the PkgHashTable is it possible that multiple packages have the same name -
358 these packages are stored as a sequence in the list.
e8a7b0b2 359 The size of both tables is the same. */
dfe66c72
DK
360 uint32_t HashTableSize;
361 uint32_t GetHashTableSize() const { return HashTableSize; }
32ab4bd0
DK
362 void SetHashTableSize(unsigned int const sz) { HashTableSize = sz; }
363 map_pointer_t GetArchitectures() const { return Architectures; }
364 void SetArchitectures(map_pointer_t const idx) { Architectures = idx; }
32ab4bd0
DK
365 map_pointer_t * PkgHashTableP() const { return (map_pointer_t*) (this + 1); }
366 map_pointer_t * GrpHashTableP() const { return PkgHashTableP() + GetHashTableSize(); }
578bfd0a 367
0688ccd8 368 /** \brief Size of the complete cache file */
4dc77823 369 map_filesize_small_t CacheFileSize;
0688ccd8 370
a02db58f 371 bool CheckSizes(Header &Against) const APT_PURE;
578bfd0a
AL
372 Header();
373};
92fcbfc1 374 /*}}}*/
94449d7c
DK
375// Group structure /*{{{*/
376/** \brief groups architecture depending packages together
5bf15716 377
94449d7c
DK
378 On or more packages with the same name form a group, so we have
379 a simple way to access a package built for different architectures
380 Group exists in a singly linked list of group records starting at
381 the hash index of the name in the pkgCache::Header::GrpHashTable */
382struct pkgCache::Group
383{
384 /** \brief Name of the group */
4ad8619b 385 map_stringitem_t Name;
94449d7c
DK
386
387 // Linked List
52c41485 388 /** \brief Link to the first package which belongs to the group */
4ad8619b 389 map_pointer_t FirstPackage; // Package
52c41485 390 /** \brief Link to the last package which belongs to the group */
4ad8619b 391 map_pointer_t LastPackage; // Package
52c41485 392 /** \brief Link to the next Group */
4ad8619b 393 map_pointer_t Next; // Group
52c41485 394 /** \brief unique sequel ID */
4dc77823 395 map_id_t ID;
52c41485 396
5bf15716
DK
397};
398 /*}}}*/
94449d7c
DK
399// Package structure /*{{{*/
400/** \brief contains information for a single unique package
401
402 There can be any number of versions of a given package.
403 Package exists in a singly linked list of package records starting at
404 the hash index of the name in the pkgCache::Header::PkgHashTable
405
406 A package can be created for every architecture so package names are
1e3f4083 407 not unique, but it is guaranteed that packages with the same name
94449d7c
DK
408 are sequencel ordered in the list. Packages with the same name can be
409 accessed with the Group.
410*/
411struct pkgCache::Package
578bfd0a 412{
fe86debb
DK
413 /** \brief Name of the package
414 * Note that the access method Name() will remain. It is just this data member
415 * deprecated as this information is already stored and available via the
416 * associated Group – so it is wasting precious binary cache space */
417 APT_DEPRECATED map_stringitem_t Name;
94449d7c 418 /** \brief Architecture of the package */
4ad8619b 419 map_stringitem_t Arch;
94449d7c
DK
420 /** \brief Base of a singly linked list of versions
421
422 Each structure represents a unique version of the package.
423 The version structures contain links into PackageFile and the
424 original text file as well as detailed information about the size
425 and dependencies of the specific package. In this way multiple
426 versions of a package can be cleanly handled by the system.
427 Furthermore, this linked list is guaranteed to be sorted
428 from Highest version to lowest version with no duplicate entries. */
4ad8619b 429 map_pointer_t VersionList; // Version
94449d7c 430 /** \brief index to the installed version */
4ad8619b 431 map_pointer_t CurrentVer; // Version
94449d7c 432 /** \brief index of the group this package belongs to */
4ad8619b 433 map_pointer_t Group; // Group the Package belongs to
94449d7c
DK
434
435 // Linked list
436 /** \brief Link to the next package in the same bucket */
32ab4bd0 437 map_pointer_t NextPackage; // Package
94449d7c 438 /** \brief List of all dependencies on this package */
4ad8619b 439 map_pointer_t RevDepends; // Dependency
94449d7c 440 /** \brief List of all "packages" this package provide */
4ad8619b 441 map_pointer_t ProvidesList; // Provides
a52f938b 442
578bfd0a 443 // Install/Remove/Purge etc
94449d7c 444 /** \brief state that the user wishes the package to be in */
dfe66c72 445 map_number_t SelectedState; // What
94449d7c
DK
446 /** \brief installation state of the package
447
448 This should be "ok" but in case the installation failed
449 it will be different.
450 */
dfe66c72 451 map_number_t InstState; // Flags
94449d7c 452 /** \brief indicates if the package is installed */
dfe66c72 453 map_number_t CurrentState; // State
94449d7c
DK
454
455 /** \brief unique sequel ID
456
457 ID is a unique value from 0 to Header->PackageCount assigned by the generator.
458 This allows clients to create an array of size PackageCount and use it to store
459 state information for the package map. For instance the status file emitter uses
460 this to track which packages have been emitted already. */
4dc77823 461 map_id_t ID;
94449d7c 462 /** \brief some useful indicators of the package's state */
dfe66c72 463 map_flags_t Flags;
578bfd0a 464};
92fcbfc1 465 /*}}}*/
b07aeb1a
DK
466// Release File structure /*{{{*/
467/** \brief stores information about the release files used to generate the cache
94449d7c 468
b07aeb1a
DK
469 PackageFiles reference ReleaseFiles as we need to keep record of which
470 version belongs to which release e.g. for pinning. */
471struct pkgCache::ReleaseFile
578bfd0a 472{
b07aeb1a 473 /** \brief physical disk file that this ReleaseFile represents */
78a5476f 474 map_stringitem_t FileName;
94449d7c
DK
475 /** \brief the release information
476
477 Please see the files document for a description of what the
478 release information means. */
4ad8619b
DK
479 map_stringitem_t Archive;
480 map_stringitem_t Codename;
4ad8619b
DK
481 map_stringitem_t Version;
482 map_stringitem_t Origin;
483 map_stringitem_t Label;
94449d7c 484 /** \brief The site the index file was fetched from */
4ad8619b 485 map_stringitem_t Site;
b07aeb1a
DK
486
487 /** \brief Size of the file
488
489 Used together with the modification time as a
490 simple check to ensure that the Packages
491 file has not been altered since Cache generation. */
492 map_filesize_t Size;
493 /** \brief Modification time for the file */
494 time_t mtime;
495
496 /** @TODO document PackageFile::Flags */
dfe66c72 497 map_flags_t Flags;
b07aeb1a
DK
498
499 // Linked list
500 /** \brief Link to the next ReleaseFile in the Cache */
501 map_pointer_t NextFile;
502 /** \brief unique sequel ID */
4dc77823 503 map_fileid_t ID;
b07aeb1a
DK
504};
505 /*}}}*/
506// Package File structure /*{{{*/
507/** \brief stores information about the files used to generate the cache
508
509 Package files are referenced by Version structures to be able to know
510 after the generation still from which Packages file includes this Version
511 as we need this information later on e.g. for pinning. */
512struct pkgCache::PackageFile
513{
514 /** \brief physical disk file that this PackageFile represents */
515 map_stringitem_t FileName;
516 /** \brief the release information */
517 map_pointer_t Release;
518
519 map_stringitem_t Component;
520 map_stringitem_t Architecture;
521
94449d7c
DK
522 /** \brief indicates what sort of index file this is
523
524 @TODO enumerate at least the possible indexes */
4ad8619b 525 map_stringitem_t IndexType;
94449d7c
DK
526 /** \brief Size of the file
527
528 Used together with the modification time as a
529 simple check to ensure that the Packages
530 file has not been altered since Cache generation. */
4ad8619b 531 map_filesize_t Size;
94449d7c
DK
532 /** \brief Modification time for the file */
533 time_t mtime;
534
255c9e4b 535 /** @TODO document PackageFile::Flags */
dfe66c72 536 map_flags_t Flags;
94449d7c 537
578bfd0a 538 // Linked list
94449d7c 539 /** \brief Link to the next PackageFile in the Cache */
4ad8619b 540 map_pointer_t NextFile; // PackageFile
94449d7c 541 /** \brief unique sequel ID */
4dc77823 542 map_fileid_t ID;
578bfd0a 543};
92fcbfc1 544 /*}}}*/
94449d7c
DK
545// VerFile structure /*{{{*/
546/** \brief associates a version with a PackageFile
547
548 This allows a full description of all Versions in all files
549 (and hence all sources) under consideration. */
550struct pkgCache::VerFile
dcb79bae 551{
94449d7c 552 /** \brief index of the package file that this version was found in */
4ad8619b 553 map_pointer_t File; // PackageFile
94449d7c 554 /** \brief next step in the linked list */
4ad8619b 555 map_pointer_t NextFile; // PkgVerFile
94449d7c 556 /** \brief position in the package file */
4dc77823 557 map_filesize_t Offset; // File offset
255c9e4b 558 /** @TODO document pkgCache::VerFile::Size */
4ad8619b 559 map_filesize_t Size;
dcb79bae 560};
92fcbfc1 561 /*}}}*/
94449d7c
DK
562// DescFile structure /*{{{*/
563/** \brief associates a description with a Translation file */
564struct pkgCache::DescFile
a52f938b 565{
94449d7c 566 /** \brief index of the file that this description was found in */
4ad8619b 567 map_pointer_t File; // PackageFile
94449d7c 568 /** \brief next step in the linked list */
4ad8619b 569 map_pointer_t NextFile; // PkgVerFile
94449d7c 570 /** \brief position in the file */
4dc77823 571 map_filesize_t Offset; // File offset
255c9e4b 572 /** @TODO document pkgCache::DescFile::Size */
4ad8619b 573 map_filesize_t Size;
a52f938b 574};
92fcbfc1 575 /*}}}*/
94449d7c
DK
576// Version structure /*{{{*/
577/** \brief information for a single version of a package
578
579 The version list is always sorted from highest version to lowest
580 version by the generator. Equal version numbers are either merged
581 or handled as separate versions based on the Hash value. */
582struct pkgCache::Version
578bfd0a 583{
94449d7c 584 /** \brief complete version string */
4ad8619b 585 map_stringitem_t VerStr;
94449d7c 586 /** \brief section this version is filled in */
4ad8619b 587 map_stringitem_t Section;
a221efc3
DK
588 /** \brief source package name this version comes from
589 Always contains the name, even if it is the same as the binary name */
590 map_stringitem_t SourcePkgName;
591 /** \brief source version this version comes from
592 Always contains the version string, even if it is the same as the binary version */
593 map_stringitem_t SourceVerStr;
894d672e
DK
594
595 /** \brief Multi-Arch capabilities of a package version */
22df31be 596 enum VerMultiArch { No = 0, /*!< is the default and doesn't trigger special behaviour */
894d672e
DK
597 All = (1<<0), /*!< will cause that Ver.Arch() will report "all" */
598 Foreign = (1<<1), /*!< can satisfy dependencies in another architecture */
599 Same = (1<<2), /*!< can be co-installed with itself from other architectures */
00b6a181
DK
600 Allowed = (1<<3), /*!< other packages are allowed to depend on thispkg:any */
601 AllForeign = All | Foreign,
602 AllAllowed = All | Allowed };
f0109006
JAK
603
604 /** \brief deprecated variant of No */
605 static const APT_DEPRECATED VerMultiArch None = No;
606
94449d7c
DK
607 /** \brief stores the MultiArch capabilities of this version
608
894d672e
DK
609 Flags used are defined in pkgCache::Version::VerMultiArch
610 */
dfe66c72 611 map_number_t MultiArch;
25396fb0 612
94449d7c
DK
613 /** \brief references all the PackageFile's that this version came from
614
615 FileList can be used to determine what distribution(s) the Version
616 applies to. If FileList is 0 then this is a blank version.
617 The structure should also have a 0 in all other fields excluding
618 pkgCache::Version::VerStr and Possibly pkgCache::Version::NextVer. */
4ad8619b 619 map_pointer_t FileList; // VerFile
94449d7c 620 /** \brief next (lower or equal) version in the linked list */
4ad8619b 621 map_pointer_t NextVer; // Version
94449d7c 622 /** \brief next description in the linked list */
4ad8619b 623 map_pointer_t DescriptionList; // Description
94449d7c 624 /** \brief base of the dependency list */
4ad8619b 625 map_pointer_t DependsList; // Dependency
94449d7c
DK
626 /** \brief links to the owning package
627
628 This allows reverse dependencies to determine the package */
4ad8619b 629 map_pointer_t ParentPkg; // Package
94449d7c 630 /** \brief list of pkgCache::Provides */
4ad8619b 631 map_pointer_t ProvidesList; // Provides
94449d7c
DK
632
633 /** \brief archive size for this version
634
635 For Debian this is the size of the .deb file. */
4dc77823 636 map_filesize_t Size; // These are the .deb size
94449d7c 637 /** \brief uncompressed size for this version */
4dc77823 638 map_filesize_t InstalledSize;
94449d7c
DK
639 /** \brief characteristic value representing this version
640
641 No two packages in existence should have the same VerStr
642 and Hash with different contents. */
204fbdcc 643 unsigned short Hash;
94449d7c 644 /** \brief unique sequel ID */
4dc77823 645 map_id_t ID;
94449d7c 646 /** \brief parsed priority value */
dfe66c72 647 map_number_t Priority;
578bfd0a 648};
92fcbfc1 649 /*}}}*/
94449d7c
DK
650// Description structure /*{{{*/
651/** \brief datamember of a linked list of available description for a version */
652struct pkgCache::Description
a52f938b 653{
94449d7c
DK
654 /** \brief Language code of this description (translation)
655
656 If the value has a 0 length then this is read using the Package
657 file else the Translation-CODE file is used. */
4ad8619b 658 map_stringitem_t language_code;
94449d7c
DK
659 /** \brief MD5sum of the original description
660
661 Used to map Translations of a description to a version
662 and to check that the Translation is up-to-date. */
4ad8619b 663 map_stringitem_t md5sum;
a52f938b 664
255c9e4b 665 /** @TODO document pkgCache::Description::FileList */
4ad8619b 666 map_pointer_t FileList; // DescFile
94449d7c 667 /** \brief next translation for this description */
4ad8619b 668 map_pointer_t NextDesc; // Description
94449d7c 669 /** \brief the text is a description of this package */
4ad8619b 670 map_pointer_t ParentPkg; // Package
a52f938b 671
94449d7c 672 /** \brief unique sequel ID */
4dc77823 673 map_id_t ID;
a52f938b 674};
92fcbfc1 675 /*}}}*/
94449d7c
DK
676// Dependency structure /*{{{*/
677/** \brief information for a single dependency record
678
679 The records are split up like this to ease processing by the client.
680 The base of the linked list is pkgCache::Version::DependsList.
681 All forms of dependencies are recorded here including Depends,
682 Recommends, Suggests, Enhances, Conflicts, Replaces and Breaks. */
71c9e95b 683struct pkgCache::DependencyData
578bfd0a 684{
94449d7c 685 /** \brief string of the version the dependency is applied against */
78a5476f 686 map_stringitem_t Version;
94449d7c
DK
687 /** \brief index of the package this depends applies to
688
689 The generator will - if the package does not already exist -
690 create a blank (no version records) package. */
4ad8619b 691 map_pointer_t Package; // Package
94449d7c 692
94449d7c 693 /** \brief Dependency type - Depends, Recommends, Conflicts, etc */
dfe66c72 694 map_number_t Type;
94449d7c
DK
695 /** \brief comparison operator specified on the depends line
696
697 If the high bit is set then it is a logical OR with the previous record. */
dfe66c72 698 map_flags_t CompareOp;
b291aa59
DK
699
700 map_pointer_t NextData;
71c9e95b
DK
701};
702struct pkgCache::Dependency
703{
704 map_pointer_t DependencyData; // DependencyData
705 /** \brief version of the package which has the depends */
706 map_pointer_t ParentVer; // Version
707 /** \brief next reverse dependency of this package */
708 map_pointer_t NextRevDepends; // Dependency
709 /** \brief next dependency of this version */
710 map_pointer_t NextDepends; // Dependency
711
712 /** \brief unique sequel ID */
4dc77823 713 map_id_t ID;
578bfd0a 714};
92fcbfc1 715 /*}}}*/
94449d7c
DK
716// Provides structure /*{{{*/
717/** \brief handles virtual packages
718
719 When a Provides: line is encountered a new provides record is added
720 associating the package with a virtual package name.
721 The provides structures are linked off the package structures.
722 This simplifies the analysis of dependencies and other aspects A provides
723 refers to a specific version of a specific package, not all versions need to
724 provide that provides.*/
725struct pkgCache::Provides
578bfd0a 726{
94449d7c 727 /** \brief index of the package providing this */
4ad8619b 728 map_pointer_t ParentPkg; // Package
94449d7c 729 /** \brief index of the version this provide line applies to */
4ad8619b 730 map_pointer_t Version; // Version
94449d7c
DK
731 /** \brief version in the provides line (if any)
732
733 This version allows dependencies to depend on specific versions of a
8c7af4d4 734 Provides, as well as allowing Provides to override existing packages. */
4ad8619b 735 map_stringitem_t ProvideVersion;
8c7af4d4 736 map_flags_t Flags;
94449d7c 737 /** \brief next provides (based of package) */
4ad8619b 738 map_pointer_t NextProvides; // Provides
94449d7c 739 /** \brief next provides (based of version) */
4ad8619b 740 map_pointer_t NextPkgProv; // Provides
578bfd0a 741};
92fcbfc1 742 /*}}}*/
32ab4bd0
DK
743// UNUSED StringItem structure /*{{{*/
744struct APT_DEPRECATED pkgCache::StringItem
745{
746 /** \brief string this refers to */
747 map_ptrloc String; // StringItem
748 /** \brief Next link in the chain */
749 map_ptrloc NextItem; // StringItem
750};
751 /*}}}*/
959470da 752
d64e130a 753inline char const * pkgCache::NativeArch()
d3e8fbb3 754 { return StrP + HeaderP->Architecture; }
959470da 755
094a497d 756#include <apt-pkg/cacheiterators.h>
578bfd0a 757
d3e8fbb3
DK
758inline pkgCache::GrpIterator pkgCache::GrpBegin()
759 {return GrpIterator(*this);}
760inline pkgCache::GrpIterator pkgCache::GrpEnd()
761 {return GrpIterator(*this,GrpP);}
762inline pkgCache::PkgIterator pkgCache::PkgBegin()
763 {return PkgIterator(*this);}
764inline pkgCache::PkgIterator pkgCache::PkgEnd()
765 {return PkgIterator(*this,PkgP);}
ad00ae81 766inline pkgCache::PkgFileIterator pkgCache::FileBegin()
d3e8fbb3 767 {return PkgFileIterator(*this,PkgFileP + HeaderP->FileList);}
ad00ae81 768inline pkgCache::PkgFileIterator pkgCache::FileEnd()
d3e8fbb3 769 {return PkgFileIterator(*this,PkgFileP);}
b07aeb1a
DK
770inline pkgCache::RlsFileIterator pkgCache::RlsFileBegin()
771 {return RlsFileIterator(*this,RlsFileP + HeaderP->RlsFileList);}
772inline pkgCache::RlsFileIterator pkgCache::RlsFileEnd()
773 {return RlsFileIterator(*this,RlsFileP);}
774
578bfd0a 775
b2e465d6 776// Oh I wish for Real Name Space Support
92fcbfc1 777class pkgCache::Namespace /*{{{*/
d3e8fbb3 778{
b2e465d6 779 public:
803ea2a8 780 typedef pkgCache::GrpIterator GrpIterator;
b2e465d6
AL
781 typedef pkgCache::PkgIterator PkgIterator;
782 typedef pkgCache::VerIterator VerIterator;
a52f938b 783 typedef pkgCache::DescIterator DescIterator;
b2e465d6
AL
784 typedef pkgCache::DepIterator DepIterator;
785 typedef pkgCache::PrvIterator PrvIterator;
b07aeb1a 786 typedef pkgCache::RlsFileIterator RlsFileIterator;
b2e465d6 787 typedef pkgCache::PkgFileIterator PkgFileIterator;
d3e8fbb3 788 typedef pkgCache::VerFileIterator VerFileIterator;
b2e465d6 789 typedef pkgCache::Version Version;
a52f938b 790 typedef pkgCache::Description Description;
b2e465d6
AL
791 typedef pkgCache::Package Package;
792 typedef pkgCache::Header Header;
793 typedef pkgCache::Dep Dep;
794 typedef pkgCache::Flag Flag;
795};
92fcbfc1 796 /*}}}*/
578bfd0a 797#endif