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