apt-pkg/pkgcachegen.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Package Cache Generator - Generator for the cache structure.
   6
   7    This builds the cache structure from the abstract package list parser.
   8    Each archive source has it's own list parser that is instantiated by
   9    the caller to provide data for the generator.
  10
  11    Parts of the cache are created by this generator class while other
  12    parts are created by the list parser. The list parser is responsible
  13    for creating version, depends and provides structures, and some of
  14    their contents
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 #ifndef PKGLIB_PKGCACHEGEN_H
  19 #define PKGLIB_PKGCACHEGEN_H
  20
  21 #include <apt-pkg/md5.h>
  22 #include <apt-pkg/mmap.h>
  23 #include <apt-pkg/pkgcache.h>
  24 #include <apt-pkg/cacheiterators.h>
  25 #include <apt-pkg/macros.h>
  26
  27 #include <vector>
  28 #include <string>
  29 #include <map>
  30
  31 class FileFd;
  32 class pkgSourceList;
  33 class OpProgress;
  34 class pkgIndexFile;
  35 class pkgCacheListParser;
  36
  37 class APT_HIDDEN pkgCacheGenerator                                      /*{{{*/
  38 {
  39    APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
  40    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
  41    APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
  42    APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);
  43
  44    std::map<std::string,map_stringitem_t> strMixed;
  45    std::map<std::string,map_stringitem_t> strSections;
  46    std::map<std::string,map_stringitem_t> strPkgNames;
  47    std::map<std::string,map_stringitem_t> strVersions;
  48
  49    friend class pkgCacheListParser;
  50    typedef pkgCacheListParser ListParser;
  51
  52    public:
  53
  54    template<typename Iter> class Dynamic {
  55       public:
  56       static std::vector<Iter*> toReMap;
  57       explicit Dynamic(Iter &I) {
  58          toReMap.push_back(&I);
  59       }
  60
  61       ~Dynamic() {
  62          toReMap.pop_back();
  63       }
  64    };
  65
  66    protected:
  67
  68    DynamicMMap &Map;
  69    pkgCache Cache;
  70    OpProgress *Progress;
  71
  72    std::string RlsFileName;
  73    pkgCache::ReleaseFile *CurrentRlsFile;
  74    std::string PkgFileName;
  75    pkgCache::PackageFile *CurrentFile;
  76
  77    // Flag file dependencies
  78    bool FoundFileDeps;
  79
  80    bool NewGroup(pkgCache::GrpIterator &Grp,const std::string &Name);
  81    bool NewPackage(pkgCache::PkgIterator &Pkg,const std::string &Name, const std::string &Arch);
  82    bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
  83    bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
  84    bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
  85                    map_pointer_t const Version, uint8_t const Op,
  86                    uint8_t const Type, map_pointer_t* &OldDepLast);
  87    map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED
  88    { return NewVersion(Ver, VerStr, 0, 0, Next); }
  89    map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
  90                             map_pointer_t const ParentPkg, unsigned short const Hash,
  91                             map_pointer_t const Next);
  92    map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str);
  93    bool NewProvides(pkgCache::VerIterator &Ver, pkgCache::PkgIterator &Pkg,
  94                     map_stringitem_t const ProvidesVersion, uint8_t const Flags);
  95
  96    public:
  97
  98    enum StringType { MIXED, PKGNAME, VERSIONNUMBER, SECTION };
  99    map_stringitem_t StoreString(StringType const type, const char * S, unsigned int const Size);
 100    inline map_stringitem_t StoreString(enum StringType const type, const std::string &S) {return StoreString(type, S.c_str(),S.length());};
 101
 102    void DropProgress() {Progress = 0;};
 103    bool SelectFile(const std::string &File,pkgIndexFile const &Index, std::string const &Architecture, std::string const &Component, unsigned long Flags = 0);
 104    bool SelectReleaseFile(const std::string &File, const std::string &Site, unsigned long Flags = 0);
 105    bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
 106    inline pkgCache &GetCache() {return Cache;};
 107    inline pkgCache::PkgFileIterator GetCurFile()
 108          {return pkgCache::PkgFileIterator(Cache,CurrentFile);};
 109    inline pkgCache::RlsFileIterator GetCurRlsFile()
 110          {return pkgCache::RlsFileIterator(Cache,CurrentRlsFile);};
 111
 112    bool HasFileDeps() {return FoundFileDeps;};
 113    bool MergeFileProvides(ListParser &List);
 114    bool FinishCache(OpProgress *Progress) APT_DEPRECATED APT_CONST;
 115
 116    APT_PUBLIC static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
 117                         MMap **OutMap = 0,bool AllowMem = false);
 118    APT_PUBLIC static bool MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap);
 119
 120    void ReMap(void const * const oldMap, void const * const newMap);
 121
 122    pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress);
 123    virtual ~pkgCacheGenerator();
 124
 125    private:
 126    void * const d;
 127    APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName);
 128    APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
 129    APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
 130                          std::string const &Version, pkgCache::VerIterator* &OutVer);
 131
 132    APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
 133                            pkgCache::VerIterator &V);
 134    APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
 135
 136    APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
 137          std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx);
 138 };
 139                                                                         /*}}}*/
 140 // This is the abstract package list parser class.                      /*{{{*/
 141 class APT_HIDDEN pkgCacheListParser
 142 {
 143    pkgCacheGenerator *Owner;
 144    friend class pkgCacheGenerator;
 145    template<class T> using Dynamic = pkgCacheGenerator::Dynamic<T>;
 146
 147    // Some cache items
 148    pkgCache::VerIterator OldDepVer;
 149    map_pointer_t *OldDepLast;
 150
 151    // Flag file dependencies
 152    bool FoundFileDeps;
 153
 154    void * const d;
 155
 156    protected:
 157
 158    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, std::string const &S) {return Owner->StoreString(type, S);};
 159    inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);};
 160
 161    inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
 162    inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
 163    bool NewDepends(pkgCache::VerIterator &Ver,const std::string &Package, const std::string &Arch,
 164                    const std::string &Version,uint8_t const Op,
 165                    uint8_t const Type);
 166    bool NewProvides(pkgCache::VerIterator &Ver,const std::string &PkgName,
 167                     const std::string &PkgArch, const std::string &Version,
 168                     uint8_t const Flags);
 169    bool NewProvidesAllArch(pkgCache::VerIterator &Ver, std::string const &Package,
 170                            std::string const &Version, uint8_t const Flags);
 171
 172    public:
 173
 174    // These all operate against the current section
 175    virtual std::string Package() = 0;
 176    virtual std::string Architecture() = 0;
 177    virtual bool ArchitectureAll() = 0;
 178    virtual std::string Version() = 0;
 179    virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
 180    virtual std::string Description(std::string const &lang) = 0;
 181    virtual std::vector<std::string> AvailableDescriptionLanguages() = 0;
 182    virtual MD5SumValue Description_md5() = 0;
 183    virtual unsigned short VersionHash() = 0;
 184    /** compare currently parsed version with given version
 185     *
 186     * \param Hash of the currently parsed version
 187     * \param Ver to compare with
 188     */
 189    virtual bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
 190    virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
 191                            pkgCache::VerIterator &Ver) = 0;
 192    virtual map_filesize_t Offset() = 0;
 193    virtual map_filesize_t Size() = 0;
 194
 195    virtual bool Step() = 0;
 196
 197    inline bool HasFileDeps() {return FoundFileDeps;};
 198    virtual bool CollectFileProvides(pkgCache &/*Cache*/,
 199                                     pkgCache::VerIterator &/*Ver*/) {return true;};
 200
 201    pkgCacheListParser();
 202    virtual ~pkgCacheListParser();
 203 };
 204                                                                         /*}}}*/
 205
 206 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
 207                         MMap **OutMap = 0,bool AllowMem = false);
 208 bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);
 209
 210 #endif