apt-pkg/pkgcachegen.h

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