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    map_stringitem_t Name;
 381    /** \brief Architecture of the package */
 382    map_stringitem_t Arch;
 383    /** \brief Base of a singly linked list of versions
 384
 385        Each structure represents a unique version of the package.
 386        The version structures contain links into PackageFile and the
 387        original text file as well as detailed information about the size
 388        and dependencies of the specific package. In this way multiple
 389        versions of a package can be cleanly handled by the system.
 390        Furthermore, this linked list is guaranteed to be sorted
 391        from Highest version to lowest version with no duplicate entries. */
 392    map_pointer_t VersionList;       // Version
 393    /** \brief index to the installed version */
 394    map_pointer_t CurrentVer;        // Version
 395    /** \brief index of the group this package belongs to */
 396    map_pointer_t Group;             // Group the Package belongs to
 397
 398    // Linked list
 399    /** \brief Link to the next package in the same bucket */
 400    map_pointer_t Next;       // Package
 401    /** \brief List of all dependencies on this package */
 402    map_pointer_t RevDepends;        // Dependency
 403    /** \brief List of all "packages" this package provide */
 404    map_pointer_t ProvidesList;      // Provides
 405
 406    // Install/Remove/Purge etc
 407    /** \brief state that the user wishes the package to be in */
 408    unsigned char SelectedState;     // What
 409    /** \brief installation state of the package
 410
 411        This should be "ok" but in case the installation failed
 412        it will be different.
 413    */
 414    unsigned char InstState;         // Flags
 415    /** \brief indicates if the package is installed */
 416    unsigned char CurrentState;      // State
 417
 418    /** \brief unique sequel ID
 419
 420        ID is a unique value from 0 to Header->PackageCount assigned by the generator.
 421        This allows clients to create an array of size PackageCount and use it to store
 422        state information for the package map. For instance the status file emitter uses
 423        this to track which packages have been emitted already. */
 424    map_id_t ID;
 425    /** \brief some useful indicators of the package's state */
 426    unsigned long Flags;
 427 };
 428                                                                         /*}}}*/
 429 // Package File structure                                               /*{{{*/
 430 /** \brief stores information about the files used to generate the cache
 431
 432     Package files are referenced by Version structures to be able to know
 433     after the generation still from which Packages file includes this Version
 434     as we need this information later on e.g. for pinning. */
 435 struct pkgCache::PackageFile
 436 {
 437    /** \brief physical disk file that this PackageFile represents */
 438    map_pointer_t FileName;        // StringItem
 439    /** \brief the release information
 440
 441        Please see the files document for a description of what the
 442        release information means. */
 443    map_stringitem_t Archive;
 444    map_stringitem_t Codename;
 445    map_stringitem_t Component;
 446    map_stringitem_t Version;
 447    map_stringitem_t Origin;
 448    map_stringitem_t Label;
 449    map_stringitem_t Architecture;
 450    /** \brief The site the index file was fetched from */
 451    map_stringitem_t Site;
 452    /** \brief indicates what sort of index file this is
 453
 454        @TODO enumerate at least the possible indexes */
 455    map_stringitem_t IndexType;
 456    /** \brief Size of the file
 457
 458        Used together with the modification time as a
 459        simple check to ensure that the Packages
 460        file has not been altered since Cache generation. */
 461    map_filesize_t Size;
 462    /** \brief Modification time for the file */
 463    time_t mtime;
 464
 465    /** @TODO document PackageFile::Flags */
 466    unsigned long Flags;
 467
 468    // Linked list
 469    /** \brief Link to the next PackageFile in the Cache */
 470    map_pointer_t NextFile;        // PackageFile
 471    /** \brief unique sequel ID */
 472    map_fileid_t ID;
 473 };
 474                                                                         /*}}}*/
 475 // VerFile structure                                                    /*{{{*/
 476 /** \brief associates a version with a PackageFile
 477
 478     This allows a full description of all Versions in all files
 479     (and hence all sources) under consideration. */
 480 struct pkgCache::VerFile
 481 {
 482    /** \brief index of the package file that this version was found in */
 483    map_pointer_t File;           // PackageFile
 484    /** \brief next step in the linked list */
 485    map_pointer_t NextFile;       // PkgVerFile
 486    /** \brief position in the package file */
 487    map_filesize_t Offset;         // File offset
 488    /** @TODO document pkgCache::VerFile::Size */
 489    map_filesize_t Size;
 490 };
 491                                                                         /*}}}*/
 492 // DescFile structure                                                   /*{{{*/
 493 /** \brief associates a description with a Translation file */
 494 struct pkgCache::DescFile
 495 {
 496    /** \brief index of the file that this description was found in */
 497    map_pointer_t File;           // PackageFile
 498    /** \brief next step in the linked list */
 499    map_pointer_t NextFile;       // PkgVerFile
 500    /** \brief position in the file */
 501    map_filesize_t Offset;         // File offset
 502    /** @TODO document pkgCache::DescFile::Size */
 503    map_filesize_t Size;
 504 };
 505                                                                         /*}}}*/
 506 // Version structure                                                    /*{{{*/
 507 /** \brief information for a single version of a package
 508
 509     The version list is always sorted from highest version to lowest
 510     version by the generator. Equal version numbers are either merged
 511     or handled as separate versions based on the Hash value. */
 512 struct pkgCache::Version
 513 {
 514    /** \brief complete version string */
 515    map_stringitem_t VerStr;
 516    /** \brief section this version is filled in */
 517    map_stringitem_t Section;
 518
 519    /** \brief Multi-Arch capabilities of a package version */
 520    enum VerMultiArch { None = 0, /*!< is the default and doesn't trigger special behaviour */
 521                        All = (1<<0), /*!< will cause that Ver.Arch() will report "all" */
 522                        Foreign = (1<<1), /*!< can satisfy dependencies in another architecture */
 523                        Same = (1<<2), /*!< can be co-installed with itself from other architectures */
 524                        Allowed = (1<<3), /*!< other packages are allowed to depend on thispkg:any */
 525                        AllForeign = All | Foreign,
 526                        AllAllowed = All | Allowed };
 527    /** \brief stores the MultiArch capabilities of this version
 528
 529        Flags used are defined in pkgCache::Version::VerMultiArch
 530    */
 531    unsigned char MultiArch;
 532
 533    /** \brief references all the PackageFile's that this version came from
 534
 535        FileList can be used to determine what distribution(s) the Version
 536        applies to. If FileList is 0 then this is a blank version.
 537        The structure should also have a 0 in all other fields excluding
 538        pkgCache::Version::VerStr and Possibly pkgCache::Version::NextVer. */
 539    map_pointer_t FileList;          // VerFile
 540    /** \brief next (lower or equal) version in the linked list */
 541    map_pointer_t NextVer;           // Version
 542    /** \brief next description in the linked list */
 543    map_pointer_t DescriptionList;   // Description
 544    /** \brief base of the dependency list */
 545    map_pointer_t DependsList;       // Dependency
 546    /** \brief links to the owning package
 547
 548        This allows reverse dependencies to determine the package */
 549    map_pointer_t ParentPkg;         // Package
 550    /** \brief list of pkgCache::Provides */
 551    map_pointer_t ProvidesList;      // Provides
 552
 553    /** \brief archive size for this version
 554
 555        For Debian this is the size of the .deb file. */
 556    uint64_t Size; // These are the .deb size
 557    /** \brief uncompressed size for this version */
 558    uint64_t InstalledSize;
 559    /** \brief characteristic value representing this version
 560
 561        No two packages in existence should have the same VerStr
 562        and Hash with different contents. */
 563    unsigned short Hash;
 564    /** \brief unique sequel ID */
 565    map_id_t ID;
 566    /** \brief parsed priority value */
 567    unsigned char Priority;
 568 };
 569                                                                         /*}}}*/
 570 // Description structure                                                /*{{{*/
 571 /** \brief datamember of a linked list of available description for a version */
 572 struct pkgCache::Description
 573 {
 574    /** \brief Language code of this description (translation)
 575
 576        If the value has a 0 length then this is read using the Package
 577        file else the Translation-CODE file is used. */
 578    map_stringitem_t language_code;
 579    /** \brief MD5sum of the original description
 580
 581        Used to map Translations of a description to a version
 582        and to check that the Translation is up-to-date. */
 583    map_stringitem_t md5sum;
 584
 585    /** @TODO document pkgCache::Description::FileList */
 586    map_pointer_t FileList;          // DescFile
 587    /** \brief next translation for this description */
 588    map_pointer_t NextDesc;          // Description
 589    /** \brief the text is a description of this package */
 590    map_pointer_t ParentPkg;         // Package
 591
 592    /** \brief unique sequel ID */
 593    map_id_t ID;
 594 };
 595                                                                         /*}}}*/
 596 // Dependency structure                                                 /*{{{*/
 597 /** \brief information for a single dependency record
 598
 599     The records are split up like this to ease processing by the client.
 600     The base of the linked list is pkgCache::Version::DependsList.
 601     All forms of dependencies are recorded here including Depends,
 602     Recommends, Suggests, Enhances, Conflicts, Replaces and Breaks. */
 603 struct pkgCache::Dependency
 604 {
 605    /** \brief string of the version the dependency is applied against */
 606    map_stringitem_t Version;         // StringItem
 607    /** \brief index of the package this depends applies to
 608
 609        The generator will - if the package does not already exist -
 610        create a blank (no version records) package. */
 611    map_pointer_t Package;         // Package
 612    /** \brief next dependency of this version */
 613    map_pointer_t NextDepends;     // Dependency
 614    /** \brief next reverse dependency of this package */
 615    map_pointer_t NextRevDepends;  // Dependency
 616    /** \brief version of the package which has the reverse depends */
 617    map_pointer_t ParentVer;       // Version
 618
 619    /** \brief unique sequel ID */
 620    map_id_t ID;
 621    /** \brief Dependency type - Depends, Recommends, Conflicts, etc */
 622    unsigned char Type;
 623    /** \brief comparison operator specified on the depends line
 624
 625        If the high bit is set then it is a logical OR with the previous record. */
 626    unsigned char CompareOp;
 627 };
 628                                                                         /*}}}*/
 629 // Provides structure                                                   /*{{{*/
 630 /** \brief handles virtual packages
 631
 632     When a Provides: line is encountered a new provides record is added
 633     associating the package with a virtual package name.
 634     The provides structures are linked off the package structures.
 635     This simplifies the analysis of dependencies and other aspects A provides
 636     refers to a specific version of a specific package, not all versions need to
 637     provide that provides.*/
 638 struct pkgCache::Provides
 639 {
 640    /** \brief index of the package providing this */
 641    map_pointer_t ParentPkg;        // Package
 642    /** \brief index of the version this provide line applies to */
 643    map_pointer_t Version;          // Version
 644    /** \brief version in the provides line (if any)
 645
 646        This version allows dependencies to depend on specific versions of a
 647        Provides, as well as allowing Provides to override existing packages.
 648        This is experimental. Note that Debian doesn't allow versioned provides */
 649    map_stringitem_t ProvideVersion;
 650    /** \brief next provides (based of package) */
 651    map_pointer_t NextProvides;     // Provides
 652    /** \brief next provides (based of version) */
 653    map_pointer_t NextPkgProv;      // Provides
 654 };
 655                                                                         /*}}}*/
 656 // StringItem structure                                                 /*{{{*/
 657 /** \brief used for generating single instances of strings
 658
 659     Some things like Section Name are are useful to have as unique tags.
 660     It is part of a linked list based at pkgCache::Header::StringList
 661
 662     All strings are simply inlined any place in the file that is natural
 663     for the writer. The client should make no assumptions about the positioning
 664     of strings. All StringItems should be null-terminated. */
 665 struct pkgCache::StringItem
 666 {
 667    /** \brief string this refers to */
 668    map_stringitem_t String;
 669    /** \brief Next link in the chain */
 670    map_stringitem_t NextItem;
 671 };
 672                                                                         /*}}}*/
 673
 674
 675 inline char const * pkgCache::NativeArch()
 676         { return StrP + HeaderP->Architecture; }
 677
 678 #include <apt-pkg/cacheiterators.h>
 679
 680 inline pkgCache::GrpIterator pkgCache::GrpBegin()
 681        {return GrpIterator(*this);}
 682 inline pkgCache::GrpIterator pkgCache::GrpEnd()
 683        {return GrpIterator(*this,GrpP);}
 684 inline pkgCache::PkgIterator pkgCache::PkgBegin()
 685        {return PkgIterator(*this);}
 686 inline pkgCache::PkgIterator pkgCache::PkgEnd()
 687        {return PkgIterator(*this,PkgP);}
 688 inline pkgCache::PkgFileIterator pkgCache::FileBegin()
 689        {return PkgFileIterator(*this,PkgFileP + HeaderP->FileList);}
 690 inline pkgCache::PkgFileIterator pkgCache::FileEnd()
 691        {return PkgFileIterator(*this,PkgFileP);}
 692
 693 // Oh I wish for Real Name Space Support
 694 class pkgCache::Namespace                                               /*{{{*/
 695 {
 696    public:
 697    typedef pkgCache::GrpIterator GrpIterator;
 698    typedef pkgCache::PkgIterator PkgIterator;
 699    typedef pkgCache::VerIterator VerIterator;
 700    typedef pkgCache::DescIterator DescIterator;
 701    typedef pkgCache::DepIterator DepIterator;
 702    typedef pkgCache::PrvIterator PrvIterator;
 703    typedef pkgCache::PkgFileIterator PkgFileIterator;
 704    typedef pkgCache::VerFileIterator VerFileIterator;
 705    typedef pkgCache::Version Version;
 706    typedef pkgCache::Description Description;
 707    typedef pkgCache::Package Package;
 708    typedef pkgCache::Header Header;
 709    typedef pkgCache::Dep Dep;
 710    typedef pkgCache::Flag Flag;
 711 };
 712                                                                         /*}}}*/
 713 #endif