LCOV - lcov.info - /usr/include/apt-pkg/pkgcache.h

LTP GCOV extension - code coverage report
Current view: | directory - usr/include/apt-pkg - pkgcache.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 2
Code covered: | 100.0 % |  | Executed lines: | 2

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

Generated by: LTP GCOV extension version 1.6