apt  0.9.12.1
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 
23 #include <apt-pkg/pkgcache.h>
24 #include <apt-pkg/md5.h>
25 #include <apt-pkg/macros.h>
26 
27 #include <vector>
28 
29 class pkgSourceList;
30 class OpProgress;
31 class MMap;
32 class pkgIndexFile;
33 
34 class pkgCacheGenerator /*{{{*/
35 {
36  private:
37 
38  pkgCache::StringItem *UniqHash[26];
39  map_ptrloc WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
40  map_ptrloc WriteStringInMap(const char *String);
41  map_ptrloc WriteStringInMap(const char *String, const unsigned long &Len);
42  map_ptrloc AllocateInMap(const unsigned long &size);
43 
44  public:
45 
46  class ListParser;
47  friend class ListParser;
48 
49  template<typename Iter> class Dynamic {
50  public:
51  static std::vector<Iter*> toReMap;
52  Dynamic(Iter &I) {
53  toReMap.push_back(&I);
54  }
55 
56  ~Dynamic() {
57  toReMap.pop_back();
58  }
59  };
60 
61  protected:
62 
63  DynamicMMap &Map;
64  pkgCache Cache;
65  OpProgress *Progress;
66 
67  std::string PkgFileName;
68  pkgCache::PackageFile *CurrentFile;
69 
70  // Flag file dependencies
71  bool FoundFileDeps;
72 
73  bool NewGroup(pkgCache::GrpIterator &Grp,const std::string &Name);
74  bool NewPackage(pkgCache::PkgIterator &Pkg,const std::string &Name, const std::string &Arch);
75  bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
76  bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
77  bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
78  std::string const &Version, unsigned int const &Op,
79  unsigned int const &Type, map_ptrloc* &OldDepLast);
80  bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
81  map_ptrloc const Version, unsigned int const &Op,
82  unsigned int const &Type, map_ptrloc* &OldDepLast);
83  __deprecated unsigned long NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,unsigned long Next)
84  { return NewVersion(Ver, VerStr, 0, 0, Next); }
85  unsigned long NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
86  map_ptrloc const ParentPkg, unsigned long const Hash,
87  unsigned long Next);
88  map_ptrloc NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_ptrloc Next);
89 
90  public:
91 
92  unsigned long WriteUniqString(const char *S,unsigned int Size);
93  inline unsigned long WriteUniqString(const std::string &S) {return WriteUniqString(S.c_str(),S.length());};
94 
95  void DropProgress() {Progress = 0;};
96  bool SelectFile(const std::string &File,const std::string &Site,pkgIndexFile const &Index,
97  unsigned long Flags = 0);
98  bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
99  inline pkgCache &GetCache() {return Cache;};
100  inline pkgCache::PkgFileIterator GetCurFile()
101  {return pkgCache::PkgFileIterator(Cache,CurrentFile);};
102 
103  bool HasFileDeps() {return FoundFileDeps;};
104  bool MergeFileProvides(ListParser &List);
105  __deprecated bool FinishCache(OpProgress *Progress);
106 
107  static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
108  MMap **OutMap = 0,bool AllowMem = false);
109  static bool MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap);
110  static DynamicMMap* CreateDynamicMMap(FileFd *CacheF, unsigned long Flags = 0);
111 
112  void ReMap(void const * const oldMap, void const * const newMap);
113 
114  pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress);
116 
117  private:
118  bool MergeListGroup(ListParser &List, std::string const &GrpName);
119  bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
120  bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
121  std::string const &Version, pkgCache::VerIterator* &OutVer);
122 
123  bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
125  bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
126 };
127  /*}}}*/
128 // This is the abstract package list parser class. /*{{{*/
130 {
131  pkgCacheGenerator *Owner;
132  friend class pkgCacheGenerator;
133 
134  // Some cache items
135  pkgCache::VerIterator OldDepVer;
136  map_ptrloc *OldDepLast;
137 
138  // Flag file dependencies
139  bool FoundFileDeps;
140 
141  protected:
142 
143  inline unsigned long WriteUniqString(std::string S) {return Owner->WriteUniqString(S);};
144  inline unsigned long WriteUniqString(const char *S,unsigned int Size) {return Owner->WriteUniqString(S,Size);};
145  inline unsigned long WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
146  inline unsigned long WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
147  bool NewDepends(pkgCache::VerIterator &Ver,const std::string &Package, const std::string &Arch,
148  const std::string &Version,unsigned int Op,
149  unsigned int Type);
150  bool NewProvides(pkgCache::VerIterator &Ver,const std::string &PkgName,
151  const std::string &PkgArch, const std::string &Version);
152 
153  public:
154 
155  // These all operate against the current section
156  virtual std::string Package() = 0;
157  virtual std::string Architecture() = 0;
158  virtual bool ArchitectureAll() = 0;
159  virtual std::string Version() = 0;
160  virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
161  virtual std::string Description() = 0;
162  virtual std::string DescriptionLanguage() = 0;
163  virtual MD5SumValue Description_md5() = 0;
164  virtual unsigned short VersionHash() = 0;
165  virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
166  pkgCache::VerIterator &Ver) = 0;
167  virtual unsigned long Offset() = 0;
168  virtual unsigned long Size() = 0;
169 
170  virtual bool Step() = 0;
171 
172  inline bool HasFileDeps() {return FoundFileDeps;};
173  virtual bool CollectFileProvides(pkgCache &Cache,
174  pkgCache::VerIterator &Ver) {return true;};
175 
176  ListParser() : FoundFileDeps(false) {};
177  virtual ~ListParser() {};
178 };
179  /*}}}*/
180 
181 bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
182  MMap **OutMap = 0,bool AllowMem = false);
183 bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);
184 
185 #endif