[apt.git] / apt-pkg / pkgcachegen.h

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################
   
   Package Cache Generator - Generator for the cache structure.
   
   This builds the cache structure from the abstract package list parser. 
   Each archive source has it's own list parser that is instantiated by
   the caller to provide data for the generator. 
   
   Parts of the cache are created by this generator class while other
   parts are created by the list parser. The list parser is responsible
   for creating version, depends and provides structures, and some of
   their contents
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_PKGCACHEGEN_H
#define PKGLIB_PKGCACHEGEN_H

#include <apt-pkg/md5.h>
#include <apt-pkg/mmap.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/macros.h>

#include <vector>
#include <string>
#if __cplusplus >= 201103L
#include <unordered_set>
#endif
#ifdef APT_PKG_EXPOSE_STRING_VIEW
#include <apt-pkg/string_view.h>
#endif

class FileFd;
class pkgSourceList;
class OpProgress;
class pkgIndexFile;
class pkgCacheListParser;

class APT_HIDDEN pkgCacheGenerator					/*{{{*/
{
   APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
   APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
   APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
   APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);

   // Dirty hack for public users that do not use C++11 yet
#if __cplusplus >= 201103L
   struct string_pointer {
      const char *data_;
      size_t size;
      pkgCacheGenerator *generator;
      map_stringitem_t item;

      const char *data() const {
	 return data_ != nullptr ? data_ : static_cast<char*>(generator->Map.Data()) + item;
      }

      bool operator ==(string_pointer const &other) const {
	 return size == other.size && memcmp(data(), other.data(), size) == 0;
      }
   };
   struct hash {
      uint32_t operator()(string_pointer const &that) const {
	 uint32_t Hash = 5381;
	 const char * const end = that.data() + that.size;
	 for (const char *I = that.data(); I != end; ++I)
	    Hash = 33 * Hash + *I;
	 return Hash;
      }
   };

   std::unordered_set<string_pointer, hash> strMixed;
   std::unordered_set<string_pointer, hash> strPkgNames;
   std::unordered_set<string_pointer, hash> strVersions;
   std::unordered_set<string_pointer, hash> strSections;
#endif

   friend class pkgCacheListParser;
   typedef pkgCacheListParser ListParser;

   public:

   template<typename Iter> class Dynamic {
      public:
      static std::vector<Iter*> toReMap;
      explicit Dynamic(Iter &I) {
	 toReMap.push_back(&I);
      }

      ~Dynamic() {
	 toReMap.pop_back();
      }
   };

   protected:

   DynamicMMap &Map;
   pkgCache Cache;
   OpProgress *Progress;

   std::string RlsFileName;
   pkgCache::ReleaseFile *CurrentRlsFile;
   std::string PkgFileName;
   pkgCache::PackageFile *CurrentFile;

#ifdef APT_PKG_EXPOSE_STRING_VIEW
   bool NewGroup(pkgCache::GrpIterator &Grp, APT::StringView Name);
   bool NewPackage(pkgCache::PkgIterator &Pkg, APT::StringView Name, APT::StringView Arch);
#endif
   bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
   bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
   bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
		   map_pointer_t const Version, uint8_t const Op,
		   uint8_t const Type, map_pointer_t* &OldDepLast);
   map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED
   { return NewVersion(Ver, VerStr, 0, 0, Next); }
   map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
			    map_pointer_t const ParentPkg, unsigned short const Hash,
			    map_pointer_t const Next);
   map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str);
   bool NewProvides(pkgCache::VerIterator &Ver, pkgCache::PkgIterator &Pkg,
		    map_stringitem_t const ProvidesVersion, uint8_t const Flags);

   public:

   enum StringType { MIXED, PKGNAME, VERSIONNUMBER, SECTION };
   map_stringitem_t StoreString(StringType const type, const char * S, unsigned int const Size);

#ifdef APT_PKG_EXPOSE_STRING_VIEW
   inline map_stringitem_t StoreString(enum StringType const type, APT::StringView S) {return StoreString(type, S.data(),S.length());};
#endif

   void DropProgress() {Progress = 0;};
   bool SelectFile(const std::string &File,pkgIndexFile const &Index, std::string const &Architecture, std::string const &Component, unsigned long Flags = 0);
   bool SelectReleaseFile(const std::string &File, const std::string &Site, unsigned long Flags = 0);
   bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
   inline pkgCache &GetCache() {return Cache;};
   inline pkgCache::PkgFileIterator GetCurFile()
         {return pkgCache::PkgFileIterator(Cache,CurrentFile);};
   inline pkgCache::RlsFileIterator GetCurRlsFile()
         {return pkgCache::RlsFileIterator(Cache,CurrentRlsFile);};

   APT_PUBLIC static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
			MMap **OutMap = 0,bool AllowMem = false);
   APT_HIDDEN static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
			MMap **OutMap,pkgCache **OutCache, bool AllowMem = false);
   APT_PUBLIC static bool MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap);

   void ReMap(void const * const oldMap, void const * const newMap, size_t oldSize);

   pkgCacheGenerator(DynamicMMap *Map,OpProgress *Progress);
   virtual ~pkgCacheGenerator();

   private:
   void * const d;
   APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName);
   APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
   APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
			 std::string const &Version, pkgCache::VerIterator* &OutVer);

   APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
			   pkgCache::VerIterator &V);
   APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);

   APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
	 std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx);
};
									/*}}}*/
// This is the abstract package list parser class.			/*{{{*/
class APT_HIDDEN pkgCacheListParser
{
   pkgCacheGenerator *Owner;
   friend class pkgCacheGenerator;

   // Some cache items
   pkgCache::VerIterator OldDepVer;
   map_pointer_t *OldDepLast;

   void * const d;

   protected:

   inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);};
#ifdef APT_PKG_EXPOSE_STRING_VIEW
   inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, APT::StringView S) {return Owner->StoreString(type, S);};
#endif

   inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
   inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
#ifdef APT_PKG_EXPOSE_STRING_VIEW
   bool NewDepends(pkgCache::VerIterator &Ver,APT::StringView Package, APT::StringView Arch,
		   APT::StringView Version,uint8_t const Op,
		   uint8_t const Type);
   bool NewProvides(pkgCache::VerIterator &Ver,APT::StringView PkgName,
		    APT::StringView PkgArch, APT::StringView Version,
		    uint8_t const Flags);
   bool NewProvidesAllArch(pkgCache::VerIterator &Ver, APT::StringView Package,
			   APT::StringView Version, uint8_t const Flags);
#endif
   public:
   
   // These all operate against the current section
   virtual std::string Package() = 0;
   virtual std::string Architecture() = 0;
   virtual bool ArchitectureAll() = 0;
   virtual std::string Version() = 0;
   virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
   virtual std::string Description(std::string const &lang) = 0;
   virtual std::vector<std::string> AvailableDescriptionLanguages() = 0;
   virtual MD5SumValue Description_md5() = 0;
   virtual unsigned short VersionHash() = 0;
   /** compare currently parsed version with given version
    *
    * \param Hash of the currently parsed version
    * \param Ver to compare with
    */
   virtual bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
   virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
			   pkgCache::VerIterator &Ver) = 0;
   virtual map_filesize_t Offset() = 0;
   virtual map_filesize_t Size() = 0;
   
   virtual bool Step() = 0;
   
   virtual bool CollectFileProvides(pkgCache &/*Cache*/,
				    pkgCache::VerIterator &/*Ver*/) {return true;};

   pkgCacheListParser();
   virtual ~pkgCacheListParser();
};
									/*}}}*/

APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeStatusCache instead") bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
			MMap **OutMap = 0,bool AllowMem = false);
APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeOnlyStatusCache instead") bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);

#endif
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
578bfd0a AL	3	/* ######################################################################
	4
	5	Package Cache Generator - Generator for the cache structure.
	6
	7	This builds the cache structure from the abstract package list parser.
6fc33863 AL	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
578bfd0a AL	15
	16	##################################################################### */
	17	/}}}/
578bfd0a AL	18	#ifndef PKGLIB_PKGCACHEGEN_H
	19	#define PKGLIB_PKGCACHEGEN_H
	20
a52f938b	21	#include <apt-pkg/md5.h>
453b82a3 DK	22	#include <apt-pkg/mmap.h>
	23	#include <apt-pkg/pkgcache.h>
	24	#include <apt-pkg/cacheiterators.h>
5a8e963b	25	#include <apt-pkg/macros.h>
b35d2f5f	26
7635093c	27	#include <vector>
453b82a3	28	#include <string>
2837a718	29	#if __cplusplus >= 201103L
869700d8	30	#include <unordered_set>
2837a718	31	#endif
eff0c22e JAK	32	#ifdef APT_PKG_EXPOSE_STRING_VIEW
	33	#include <apt-pkg/string_view.h>
	34	#endif
a9fe5928	35
453b82a3	36	class FileFd;
b35d2f5f AL	37	class pkgSourceList;
b35d2f5f AL	38	class OpProgress;
b2e465d6	39	class pkgIndexFile;
c9443c01	40	class pkgCacheListParser;
578bfd0a	41
dce45dbe	42	class APT_HIDDEN pkgCacheGenerator /{{{/
578bfd0a	43	{
4ad8619b DK	44	APT_HIDDEN map_stringitem_t WriteStringInMap(std::string const &String) { return WriteStringInMap(String.c_str()); };
	45	APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String);
	46	APT_HIDDEN map_stringitem_t WriteStringInMap(const char *String, const unsigned long &Len);
	47	APT_HIDDEN map_pointer_t AllocateInMap(const unsigned long &size);
7e58ab0c	48
2837a718 JAK	49	// Dirty hack for public users that do not use C++11 yet
2837a718 JAK	50	#if __cplusplus >= 201103L
869700d8 JAK	51	struct string_pointer {
	52	const char *data_;
	53	size_t size;
	54	pkgCacheGenerator *generator;
	55	map_stringitem_t item;
	56
	57	const char *data() const {
	58	return data_ != nullptr ? data_ : static_cast<char*>(generator->Map.Data()) + item;
	59	}
	60
	61	bool operator ==(string_pointer const &other) const {
	62	return size == other.size && memcmp(data(), other.data(), size) == 0;
	63	}
	64	};
	65	struct hash {
	66	uint32_t operator()(string_pointer const &that) const {
	67	uint32_t Hash = 5381;
	68	const char * const end = that.data() + that.size;
	69	for (const char *I = that.data(); I != end; ++I)
a0e3c0f5	70	Hash = 33 * Hash + *I;
869700d8 JAK	71	return Hash;
	72	}
	73	};
	74
	75	std::unordered_set<string_pointer, hash> strMixed;
	76	std::unordered_set<string_pointer, hash> strPkgNames;
	77	std::unordered_set<string_pointer, hash> strVersions;
	78	std::unordered_set<string_pointer, hash> strSections;
2837a718	79	#endif
78a5476f	80
c9443c01 DK	81	friend class pkgCacheListParser;
	82	typedef pkgCacheListParser ListParser;
	83
578bfd0a	84	public:
a9fe5928 DK	85
a9fe5928 DK	86	template<typename Iter> class Dynamic {
a9fe5928	87	public:
7635093c	88	static std::vector<Iter*> toReMap;
e8afd168	89	explicit Dynamic(Iter &I) {
7635093c	90	toReMap.push_back(&I);
a9fe5928 DK	91	}
	92
	93	~Dynamic() {
7635093c	94	toReMap.pop_back();
a9fe5928 DK	95	}
	96	};
	97
578bfd0a	98	protected:
a9fe5928	99
578bfd0a AL	100	DynamicMMap &Map;
578bfd0a AL	101	pkgCache Cache;
ddc1d8d0	102	OpProgress *Progress;
b07aeb1a DK	103
	104	std::string RlsFileName;
	105	pkgCache::ReleaseFile *CurrentRlsFile;
8f3ba4e8	106	std::string PkgFileName;
578bfd0a	107	pkgCache::PackageFile *CurrentFile;
45415543	108
eff0c22e JAK	109	#ifdef APT_PKG_EXPOSE_STRING_VIEW
	110	bool NewGroup(pkgCache::GrpIterator &Grp, APT::StringView Name);
	111	bool NewPackage(pkgCache::PkgIterator &Pkg, APT::StringView Name, APT::StringView Arch);
	112	#endif
f55a958f	113	bool NewFileVer(pkgCache::VerIterator &Ver,ListParser &List);
a52f938b	114	bool NewFileDesc(pkgCache::DescIterator &Desc,ListParser &List);
9c44383f	115	bool NewDepends(pkgCache::PkgIterator &Pkg, pkgCache::VerIterator &Ver,
8c7af4d4 DK	116	map_pointer_t const Version, uint8_t const Op,
8c7af4d4 DK	117	uint8_t const Type, map_pointer_t* &OldDepLast);
4ad8619b	118	map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,map_pointer_t const Next) APT_DEPRECATED
885594fc	119	{ return NewVersion(Ver, VerStr, 0, 0, Next); }
4ad8619b DK	120	map_pointer_t NewVersion(pkgCache::VerIterator &Ver,const std::string &VerStr,
	121	map_pointer_t const ParentPkg, unsigned short const Hash,
	122	map_pointer_t const Next);
	123	map_pointer_t NewDescription(pkgCache::DescIterator &Desc,const std::string &Lang,const MD5SumValue &md5sum,map_stringitem_t const idxmd5str);
ecc138f8 DK	124	bool NewProvides(pkgCache::VerIterator &Ver, pkgCache::PkgIterator &Pkg,
ecc138f8 DK	125	map_stringitem_t const ProvidesVersion, uint8_t const Flags);
578bfd0a	126
b2e465d6 AL	127	public:
b2e465d6 AL	128
30b45652 DK	129	enum StringType { MIXED, PKGNAME, VERSIONNUMBER, SECTION };
30b45652 DK	130	map_stringitem_t StoreString(StringType const type, const char * S, unsigned int const Size);
dd592790 JAK	131
	132	#ifdef APT_PKG_EXPOSE_STRING_VIEW
	133	inline map_stringitem_t StoreString(enum StringType const type, APT::StringView S) {return StoreString(type, S.data(),S.length());};
	134	#endif
813c8eea	135
ddc1d8d0	136	void DropProgress() {Progress = 0;};
e185d8b3	137	bool SelectFile(const std::string &File,pkgIndexFile const &Index, std::string const &Architecture, std::string const &Component, unsigned long Flags = 0);
b07aeb1a	138	bool SelectReleaseFile(const std::string &File, const std::string &Site, unsigned long Flags = 0);
ddc1d8d0	139	bool MergeList(ListParser &List,pkgCache::VerIterator *Ver = 0);
ad00ae81	140	inline pkgCache &GetCache() {return Cache;};
1d3eea5c	141	inline pkgCache::PkgFileIterator GetCurFile()
b0b4efb9	142	{return pkgCache::PkgFileIterator(Cache,CurrentFile);};
1d3eea5c	143	inline pkgCache::RlsFileIterator GetCurRlsFile()
b07aeb1a	144	{return pkgCache::RlsFileIterator(Cache,CurrentRlsFile);};
45415543	145
dce45dbe	146	APT_PUBLIC static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
2e5f4e45	147	MMap **OutMap = 0,bool AllowMem = false);
f1616039 JAK	148	APT_HIDDEN static bool MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
f1616039 JAK	149	MMap OutMap,pkgCache OutCache, bool AllowMem = false);
dce45dbe	150	APT_PUBLIC static bool MakeOnlyStatusCache(OpProgress Progress,DynamicMMap *OutMap);
25396fb0	151
19819ac5	152	void ReMap(void const * const oldMap, void const * const newMap, size_t oldSize);
a9fe5928	153
b2e465d6	154	pkgCacheGenerator(DynamicMMap Map,OpProgress Progress);
c8a4ce6c	155	virtual ~pkgCacheGenerator();
99a2ea5a DK	156
99a2ea5a DK	157	private:
6c55f07a	158	void * const d;
ce62f1de DK	159	APT_HIDDEN bool MergeListGroup(ListParser &List, std::string const &GrpName);
	160	APT_HIDDEN bool MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg);
	161	APT_HIDDEN bool MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
99a2ea5a	162	std::string const &Version, pkgCache::VerIterator* &OutVer);
5a8e963b	163
ce62f1de	164	APT_HIDDEN bool AddImplicitDepends(pkgCache::GrpIterator &G, pkgCache::PkgIterator &P,
5a8e963b	165	pkgCache::VerIterator &V);
ce62f1de	166	APT_HIDDEN bool AddImplicitDepends(pkgCache::VerIterator &V, pkgCache::PkgIterator &D);
ffe3c68e DK	167
ffe3c68e DK	168	APT_HIDDEN bool AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver,
4ad8619b	169	std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx);
578bfd0a	170	};
92fcbfc1 DK	171	/}}}/
92fcbfc1 DK	172	// This is the abstract package list parser class. /{{{/
c9443c01	173	class APT_HIDDEN pkgCacheListParser
f55ece0e AL	174	{
f55ece0e AL	175	pkgCacheGenerator *Owner;
b2e465d6	176	friend class pkgCacheGenerator;
c9443c01	177
f9eec0e7 AL	178	// Some cache items
f9eec0e7 AL	179	pkgCache::VerIterator OldDepVer;
4ad8619b	180	map_pointer_t *OldDepLast;
45415543	181
6c55f07a	182	void * const d;
c8a4ce6c	183
f55ece0e	184	protected:
813c8eea	185
78a5476f	186	inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, const char *S,unsigned int Size) {return Owner->StoreString(type, S, Size);};
dd592790 JAK	187	#ifdef APT_PKG_EXPOSE_STRING_VIEW
	188	inline map_stringitem_t StoreString(pkgCacheGenerator::StringType const type, APT::StringView S) {return Owner->StoreString(type, S);};
	189	#endif
78a5476f	190
4ad8619b DK	191	inline map_stringitem_t WriteString(const std::string &S) {return Owner->WriteStringInMap(S);};
4ad8619b DK	192	inline map_stringitem_t WriteString(const char *S,unsigned int Size) {return Owner->WriteStringInMap(S,Size);};
eff0c22e JAK	193	#ifdef APT_PKG_EXPOSE_STRING_VIEW
	194	bool NewDepends(pkgCache::VerIterator &Ver,APT::StringView Package, APT::StringView Arch,
	195	APT::StringView Version,uint8_t const Op,
8c7af4d4	196	uint8_t const Type);
eff0c22e JAK	197	bool NewProvides(pkgCache::VerIterator &Ver,APT::StringView PkgName,
eff0c22e JAK	198	APT::StringView PkgArch, APT::StringView Version,
8c7af4d4	199	uint8_t const Flags);
eff0c22e JAK	200	bool NewProvidesAllArch(pkgCache::VerIterator &Ver, APT::StringView Package,
	201	APT::StringView Version, uint8_t const Flags);
	202	#endif
f55ece0e AL	203	public:
	204
	205	// These all operate against the current section
8f3ba4e8 DK	206	virtual std::string Package() = 0;
8f3ba4e8 DK	207	virtual std::string Architecture() = 0;
857e9c13	208	virtual bool ArchitectureAll() = 0;
8f3ba4e8	209	virtual std::string Version() = 0;
32b9a14c	210	virtual bool NewVersion(pkgCache::VerIterator &Ver) = 0;
ffe3c68e DK	211	virtual std::string Description(std::string const &lang) = 0;
ffe3c68e DK	212	virtual std::vector<std::string> AvailableDescriptionLanguages() = 0;
a52f938b	213	virtual MD5SumValue Description_md5() = 0;
204fbdcc	214	virtual unsigned short VersionHash() = 0;
68134bda DK	215	/** compare currently parsed version with given version
	216	*
	217	* \param Hash of the currently parsed version
	218	* \param Ver to compare with
	219	*/
c8a4ce6c	220	virtual bool SameVersion(unsigned short const Hash, pkgCache::VerIterator const &Ver);
32b9a14c DK	221	virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
32b9a14c DK	222	pkgCache::VerIterator &Ver) = 0;
4ad8619b DK	223	virtual map_filesize_t Offset() = 0;
4ad8619b DK	224	virtual map_filesize_t Size() = 0;
f55ece0e AL	225
	226	virtual bool Step() = 0;
	227
65512241 DK	228	virtual bool CollectFileProvides(pkgCache &/Cache/,
65512241 DK	229	pkgCache::VerIterator &/Ver/) {return true;};
45415543	230
c9443c01 DK	231	pkgCacheListParser();
c9443c01 DK	232	virtual ~pkgCacheListParser();
f55ece0e	233	};
92fcbfc1	234	/}}}/
2e5f4e45	235
5dd00edb	236	APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeStatusCache instead") bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
b2e465d6	237	MMap **OutMap = 0,bool AllowMem = false);
5dd00edb	238	APT_DEPRECATED_MSG("Use pkgCacheGenerator::MakeOnlyStatusCache instead") bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap);
b2e465d6	239
578bfd0a	240	#endif