git.saurik.com Git - apt.git/blame_incremental

... / ...

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