]>
Commit | Line | Data |
---|---|---|
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 | #include <map> | |
31 | ||
32 | class FileFd; | |
33 | class pkgSourceList; | |
34 | class OpProgress; | |
35 | class pkgIndexFile; | |
36 | ||
37 | class APT_HIDDEN pkgCacheGenerator /*{{{*/ | |
38 | { | |
39 | private: | |
40 | APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); }; | |
41 | APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String); | |
42 | APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len); | |
43 | APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size); | |
44 | ||
45 | std::map<std::string,map_stringitem_t> strMixed; | |
46 | std::map<std::string,map_stringitem_t> strSections; | |
47 | std::map<std::string,map_stringitem_t> strPkgNames; | |
48 | std::map<std::string,map_stringitem_t> strVersions; | |
49 | ||
50 | public: | |
51 | ||
52 | class ListParser; | |
53 | friend class ListParser; | |
54 | ||
55 | template<typename Iter> class Dynamic { | |
56 | public: | |
57 | static std::vector<Iter*> toReMap; | |
58 | Dynamic(Iter &I) { | |
59 | toReMap.push_back(&I); | |
60 | } | |
61 | ||
62 | ~Dynamic() { | |
63 | toReMap.pop_back(); | |
64 | } | |
65 | }; | |
66 | ||
67 | protected: | |
68 | ||
69 | DynamicMMap ⤅ | |
70 | pkgCache Cache; | |
71 | OpProgress *Progress; | |
72 | ||
73 | std::string PkgFileName; | |
74 | pkgCache::PackageFile *CurrentFile; | |
75 | ||
76 | // Flag file dependencies | |
77 | bool FoundFileDeps; | |
78 | ||
79 | bool NewGroup(pkgCache::GrpIterator &Grp,const std::string &Name); | |
80 | bool NewPackage(pkgCache::PkgIterator &Pkg,const std::string &Name, const std::string &Arch); | |
81 | bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List); | |
82 | bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List); | |
83 | bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver, | |
84 | std::string const &Version, unsigned int const &Op, | |
85 | unsigned int const &Type, map_pointer_t* &OldDepLast); | |
86 | bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver, | |
87 | map_pointer_t const Version, unsigned int const &Op, | |
88 | unsigned int const &Type, map_pointer_t* &OldDepLast); | |
89 | map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED | |
90 | { return NewVersion(Ver, VerStr, 0, 0, Next); } | |
91 | map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr, | |
92 | map_pointer_t const ParentPkg, unsigned short const Hash, | |
93 | map_pointer_t const Next); | |
94 | map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str); | |
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,const std::string &Site,pkgIndexFile const &Index, | |
104 | 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 | ||
110 | bool HasFileDeps() {return FoundFileDeps;}; | |
111 | bool MergeFileProvides(ListParser &List); | |
112 | bool FinishCache(OpProgress *Progress) APT_DEPRECATED APT_CONST; | |
113 | ||
114 | APT_PUBLIC static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress, | |
115 | MMap **OutMap = 0,bool AllowMem = false); | |
116 | APT_PUBLIC static bool MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap); | |
117 | APT_PUBLIC static DynamicMMap* CreateDynamicMMap(FileFd *CacheF, unsigned long Flags = 0); | |
118 | ||
119 | void ReMap(void const * const oldMap, void const * const newMap); | |
120 | ||
121 | pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress); | |
122 | ~pkgCacheGenerator(); | |
123 | ||
124 | private: | |
125 | APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName); | |
126 | APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg); | |
127 | APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg, | |
128 | std::string const &Version, pkgCache::VerIterator* &OutVer); | |
129 | ||
130 | APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P, | |
131 | pkgCache::VerIterator &V); | |
132 | APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D); | |
133 | ||
134 | APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver, | |
135 | std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx); | |
136 | }; | |
137 | /*}}}*/ | |
138 | // This is the abstract package list parser class. /*{{{*/ | |
139 | class APT_HIDDEN pkgCacheGenerator::ListParser | |
140 | { | |
141 | pkgCacheGenerator *Owner; | |
142 | friend class pkgCacheGenerator; | |
143 | ||
144 | // Some cache items | |
145 | pkgCache::VerIterator OldDepVer; | |
146 | map_pointer_t *OldDepLast; | |
147 | ||
148 | // Flag file dependencies | |
149 | bool FoundFileDeps; | |
150 | ||
151 | protected: | |
152 | ||
153 | inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, std::string const &S) {return Owner->StoreString(type, S);}; | |
154 | inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);}; | |
155 | ||
156 | inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);}; | |
157 | inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);}; | |
158 | bool NewDepends(pkgCache::VerIterator &Ver,const std::string &Package, const std::string &Arch, | |
159 | const std::string &Version,unsigned int Op, | |
160 | unsigned int Type); | |
161 | bool NewProvides(pkgCache::VerIterator &Ver,const std::string &PkgName, | |
162 | const std::string &PkgArch, const std::string &Version); | |
163 | ||
164 | public: | |
165 | ||
166 | // These all operate against the current section | |
167 | virtual std::string Package() = 0; | |
168 | virtual std::string Architecture() = 0; | |
169 | virtual bool ArchitectureAll() = 0; | |
170 | virtual std::string Version() = 0; | |
171 | virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0; | |
172 | virtual std::string Description(std::string const &lang) = 0; | |
173 | virtual std::vector<std::string> AvailableDescriptionLanguages() = 0; | |
174 | virtual MD5SumValue Description_md5() = 0; | |
175 | virtual unsigned short VersionHash() = 0; | |
176 | /** compare currently parsed version with given version | |
177 | * | |
178 | * \param Hash of the currently parsed version | |
179 | * \param Ver to compare with | |
180 | */ | |
181 | #if APT_PKG_ABI >= 413 | |
182 | virtual | |
183 | #endif | |
184 | APT_PURE bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver); | |
185 | virtual bool UsePackage(pkgCache::PkgIterator &Pkg, | |
186 | pkgCache::VerIterator &Ver) = 0; | |
187 | virtual map_filesize_t Offset() = 0; | |
188 | virtual map_filesize_t Size() = 0; | |
189 | ||
190 | virtual bool Step() = 0; | |
191 | ||
192 | inline bool HasFileDeps() {return FoundFileDeps;}; | |
193 | virtual bool CollectFileProvides(pkgCache &/*Cache*/, | |
194 | pkgCache::VerIterator &/*Ver*/) {return true;}; | |
195 | ||
196 | ListParser() : Owner(NULL), OldDepLast(NULL), FoundFileDeps(false) {}; | |
197 | virtual ~ListParser() {}; | |
198 | }; | |
199 | /*}}}*/ | |
200 | ||
201 | bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress, | |
202 | MMap **OutMap = 0,bool AllowMem = false); | |
203 | bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap); | |
204 | ||
205 | #endif |