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