[apt.git] / apt-inst / filelist.h

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: filelist.h,v 1.2 2001/02/20 07:03:16 jgg Exp $
/* ######################################################################

   File Listing - Manages a Cache of File -> Package names.

   This is identical to the Package cache, except that the generator 
   (which is much simpler) is integrated directly into the main class, 
   and it has been designed to handle live updates.
   
   The storage content of the class is maintained in a memory map and is
   written directly to the file system. Performance is traded against 
   space to give something that performs well and remains small.
   The average per file usage is 32 bytes which yeilds about a meg every
   36k files. Directory paths are collected into a binary tree and stored
   only once, this offsets the cost of the hash nodes enough to keep 
   memory usage slightly less than the sum of the filenames.
 
   The file names are stored into a fixed size chained hash table that is
   linked to the package name and to the directory component. 

   Each file node has a set of associated flags that indicate the current
   state of the file.
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_FILELIST_H
#define PKGLIB_FILELIST_H

#include <apt-pkg/mmap.h>

#include <cstring>
#include <string>

class pkgFLCache
{
   public:
   struct Header;
   struct Node;
   struct Directory;
   struct Package;
   struct Diversion;
   struct ConfFile;
   
   class NodeIterator;
   class DirIterator;
   class PkgIterator;
   class DiverIterator;
   
   protected:
   std::string CacheFile;
   DynamicMMap &Map;
   map_ptrloc LastTreeLookup;
   unsigned long LastLookupSize;
   
   // Helpers for the addition algorithms
   map_ptrloc TreeLookup(map_ptrloc *Base,const char *Text,const char *TextEnd,
			 unsigned long Size,unsigned int *Count = 0,
			 bool Insert = false);
   
   public:
   
   // Pointers to the arrays of items
   Header *HeaderP;
   Node *NodeP;
   Directory *DirP;
   Package *PkgP;
   Diversion *DiverP;
   ConfFile *ConfP;
   char *StrP;
   unsigned char *AnyP;
   
   // Quick accessors
   Node *FileHash;
   
   // Accessors
   Header &Head() {return *HeaderP;};
   void PrintTree(map_ptrloc Base,unsigned long Size);

   // Add/Find things
   PkgIterator GetPkg(const char *Name,const char *End,bool Insert);
   inline PkgIterator GetPkg(const char *Name,bool Insert);
   NodeIterator GetNode(const char *Name,
			const char *NameEnd,
			map_ptrloc Loc,
			bool Insert,bool Divert);
   Node *HashNode(NodeIterator const &N);
   void DropNode(map_ptrloc Node);

   inline DiverIterator DiverBegin();
   
   // Diversion control
   void BeginDiverLoad();
   void FinishDiverLoad();
   bool AddDiversion(PkgIterator const &Owner,const char *From,
		     const char *To);
   bool AddConfFile(const char *Name,const char *NameEnd,
		    PkgIterator const &Owner,const unsigned char *Sum);
			     
   pkgFLCache(DynamicMMap &Map);
//   ~pkgFLCache();
};

struct pkgFLCache::Header
{
   // Signature information
   unsigned long Signature;
   short MajorVersion;
   short MinorVersion;
   bool Dirty;
   
   // Size of structure values
   unsigned HeaderSz;
   unsigned NodeSz;
   unsigned DirSz;
   unsigned PackageSz;
   unsigned DiversionSz;
   unsigned ConfFileSz;
   
   // Structure Counts;
   unsigned int NodeCount;
   unsigned int DirCount;
   unsigned int PackageCount;
   unsigned int DiversionCount;
   unsigned int ConfFileCount;
   unsigned int HashSize;
   unsigned long UniqNodes;
      
   // Offsets
   map_ptrloc FileHash;
   map_ptrloc DirTree;
   map_ptrloc Packages;
   map_ptrloc Diversions;
      
   /* Allocation pools, there should be one of these for each structure
      excluding the header */
   DynamicMMap::Pool Pools[5];

   bool CheckSizes(Header &Against) const;
   Header();
};

/* The bit field is used to advoid incurring an extra 4 bytes x 40000,
   Pointer is the most infrequently used member of the structure */
struct pkgFLCache::Node
{
   map_ptrloc Dir;            // Dir
   map_ptrloc File;           // String
   unsigned Pointer:24;       // Package/Diversion/ConfFile
   unsigned Flags:8;          // Package
   map_ptrloc Next;           // Node
   map_ptrloc NextPkg;        // Node

   enum Flags {Diversion = (1<<0),ConfFile = (1<<1),
               NewConfFile = (1<<2),NewFile = (1<<3),
               Unpacked = (1<<4),Replaced = (1<<5)};
};

struct pkgFLCache::Directory
{
   map_ptrloc Left;           // Directory
   map_ptrloc Right;          // Directory
   map_ptrloc Name;           // String
};

struct pkgFLCache::Package
{
   map_ptrloc Left;           // Package
   map_ptrloc Right;          // Package
   map_ptrloc Name;           // String
   map_ptrloc Files;          // Node
};

struct pkgFLCache::Diversion
{
   map_ptrloc OwnerPkg;       // Package
   map_ptrloc DivertFrom;     // Node
   map_ptrloc DivertTo;       // String
   
   map_ptrloc Next;           // Diversion
   unsigned long Flags;

   enum Flags {Touched = (1<<0)};
};

struct pkgFLCache::ConfFile
{
   map_ptrloc OwnerPkg;       // Package
   unsigned char MD5[16];
};

class pkgFLCache::PkgIterator
{
   Package *Pkg;
   pkgFLCache *Owner;
   
   public:
   
   inline bool end() const {return Owner == 0 || Pkg == Owner->PkgP?true:false;}
   
   // Accessors
   inline Package *operator ->() {return Pkg;};
   inline Package const *operator ->() const {return Pkg;};
   inline Package const &operator *() const {return *Pkg;};
   inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
   inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};

   inline unsigned long Offset() const {return Pkg - Owner->PkgP;};
   inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
   inline pkgFLCache::NodeIterator Files() const;

   PkgIterator() : Pkg(0), Owner(0) {};
   PkgIterator(pkgFLCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner) {};
};

class pkgFLCache::DirIterator
{
   Directory *Dir;
   pkgFLCache *Owner;
   
   public:
   
   // Accessors
   inline Directory *operator ->() {return Dir;};
   inline Directory const *operator ->() const {return Dir;};
   inline Directory const &operator *() const {return *Dir;};
   inline operator Directory *() {return Dir == Owner->DirP?0:Dir;};
   inline operator Directory const *() const {return Dir == Owner->DirP?0:Dir;};

   inline const char *Name() const {return Dir->Name == 0?0:Owner->StrP + Dir->Name;};

   DirIterator() : Dir(0), Owner(0) {};
   DirIterator(pkgFLCache &Owner,Directory *Trg) : Dir(Trg), Owner(&Owner) {};
};

class pkgFLCache::DiverIterator
{
   Diversion *Diver;
   pkgFLCache *Owner;
   
   public:

   // Iteration
   void operator ++(int) {if (Diver != Owner->DiverP) Diver = Owner->DiverP + Diver->Next;};
   inline void operator ++() {operator ++(0);};
   inline bool end() const {return Owner == 0 || Diver == Owner->DiverP;};

   // Accessors
   inline Diversion *operator ->() {return Diver;};
   inline Diversion const *operator ->() const {return Diver;};
   inline Diversion const &operator *() const {return *Diver;};
   inline operator Diversion *() {return Diver == Owner->DiverP?0:Diver;};
   inline operator Diversion const *() const {return Diver == Owner->DiverP?0:Diver;};

   inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Diver->OwnerPkg);};
   inline NodeIterator DivertFrom() const;
   inline NodeIterator DivertTo() const;

   DiverIterator() : Diver(0), Owner(0) {};
   DiverIterator(pkgFLCache &Owner,Diversion *Trg) : Diver(Trg), Owner(&Owner) {};
};

class pkgFLCache::NodeIterator
{
   Node *Nde;
   enum {NdePkg, NdeHash} Type;   
   pkgFLCache *Owner;
   
   public:
   
   // Iteration
   void operator ++(int) {if (Nde != Owner->NodeP) Nde = Owner->NodeP + 
	 (Type == NdePkg?Nde->NextPkg:Nde->Next);};
   inline void operator ++() {operator ++(0);};
   inline bool end() const {return Owner == 0 || Nde == Owner->NodeP;};

   // Accessors
   inline Node *operator ->() {return Nde;};
   inline Node const *operator ->() const {return Nde;};
   inline Node const &operator *() const {return *Nde;};
   inline operator Node *() {return Nde == Owner->NodeP?0:Nde;};
   inline operator Node const *() const {return Nde == Owner->NodeP?0:Nde;};
   inline unsigned long Offset() const {return Nde - Owner->NodeP;};
   inline DirIterator Dir() const {return DirIterator(*Owner,Owner->DirP + Nde->Dir);};
   inline DiverIterator Diversion() const {return DiverIterator(*Owner,Owner->DiverP + Nde->Pointer);};
   inline const char *File() const {return Nde->File == 0?0:Owner->StrP + Nde->File;};
   inline const char *DirN() const {return Owner->StrP + Owner->DirP[Nde->Dir].Name;};
   Package *RealPackage() const;
   
   NodeIterator() : Nde(0), Type(NdeHash), Owner(0) {};
   NodeIterator(pkgFLCache &Owner) : Nde(Owner.NodeP), Type(NdeHash), Owner(&Owner) {};
   NodeIterator(pkgFLCache &Owner,Node *Trg) : Nde(Trg), Type(NdeHash), Owner(&Owner) {};
   NodeIterator(pkgFLCache &Owner,Node *Trg,Package *) : Nde(Trg), Type(NdePkg), Owner(&Owner) {};
};

/* Inlines with forward references that cannot be included directly in their
   respsective classes */
inline pkgFLCache::NodeIterator pkgFLCache::DiverIterator::DivertFrom() const 
   {return NodeIterator(*Owner,Owner->NodeP + Diver->DivertFrom);};
inline pkgFLCache::NodeIterator pkgFLCache::DiverIterator::DivertTo() const
   {return NodeIterator(*Owner,Owner->NodeP + Diver->DivertTo);};

inline pkgFLCache::NodeIterator pkgFLCache::PkgIterator::Files() const
   {return NodeIterator(*Owner,Owner->NodeP + Pkg->Files,Pkg);};

inline pkgFLCache::DiverIterator pkgFLCache::DiverBegin()
   {return DiverIterator(*this,DiverP + HeaderP->Diversions);};

inline pkgFLCache::PkgIterator pkgFLCache::GetPkg(const char *Name,bool Insert) 
   {return GetPkg(Name,Name+strlen(Name),Insert);};

#endif
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	// $Id: filelist.h,v 1.2 2001/02/20 07:03:16 jgg Exp $
	4	/* ######################################################################
	5
	6	File Listing - Manages a Cache of File -> Package names.
	7
	8	This is identical to the Package cache, except that the generator
	9	(which is much simpler) is integrated directly into the main class,
	10	and it has been designed to handle live updates.
	11
	12	The storage content of the class is maintained in a memory map and is
	13	written directly to the file system. Performance is traded against
	14	space to give something that performs well and remains small.
	15	The average per file usage is 32 bytes which yeilds about a meg every
	16	36k files. Directory paths are collected into a binary tree and stored
	17	only once, this offsets the cost of the hash nodes enough to keep
	18	memory usage slightly less than the sum of the filenames.
	19
	20	The file names are stored into a fixed size chained hash table that is
	21	linked to the package name and to the directory component.
	22
	23	Each file node has a set of associated flags that indicate the current
	24	state of the file.
	25
	26	##################################################################### */
	27	/}}}/
	28	#ifndef PKGLIB_FILELIST_H
	29	#define PKGLIB_FILELIST_H
	30
472ff00e	31	#include <apt-pkg/mmap.h>
13500573	32
4f333a8b	33	#include <cstring>
472ff00e	34	#include <string>
b2e465d6 AL	35
	36	class pkgFLCache
	37	{
	38	public:
	39	struct Header;
	40	struct Node;
	41	struct Directory;
	42	struct Package;
	43	struct Diversion;
	44	struct ConfFile;
	45
	46	class NodeIterator;
	47	class DirIterator;
	48	class PkgIterator;
	49	class DiverIterator;
	50
	51	protected:
8f3ba4e8	52	std::string CacheFile;
b2e465d6 AL	53	DynamicMMap &Map;
	54	map_ptrloc LastTreeLookup;
	55	unsigned long LastLookupSize;
	56
	57	// Helpers for the addition algorithms
	58	map_ptrloc TreeLookup(map_ptrloc Base,const char Text,const char *TextEnd,
	59	unsigned long Size,unsigned int *Count = 0,
	60	bool Insert = false);
	61
	62	public:
	63
	64	// Pointers to the arrays of items
	65	Header *HeaderP;
	66	Node *NodeP;
	67	Directory *DirP;
	68	Package *PkgP;
	69	Diversion *DiverP;
	70	ConfFile *ConfP;
	71	char *StrP;
	72	unsigned char *AnyP;
	73
	74	// Quick accessors
	75	Node *FileHash;
	76
	77	// Accessors
	78	Header &Head() {return *HeaderP;};
	79	void PrintTree(map_ptrloc Base,unsigned long Size);
	80
	81	// Add/Find things
	82	PkgIterator GetPkg(const char Name,const char End,bool Insert);
	83	inline PkgIterator GetPkg(const char *Name,bool Insert);
	84	NodeIterator GetNode(const char *Name,
	85	const char *NameEnd,
	86	map_ptrloc Loc,
	87	bool Insert,bool Divert);
	88	Node *HashNode(NodeIterator const &N);
	89	void DropNode(map_ptrloc Node);
	90
	91	inline DiverIterator DiverBegin();
	92
	93	// Diversion control
	94	void BeginDiverLoad();
	95	void FinishDiverLoad();
	96	bool AddDiversion(PkgIterator const &Owner,const char *From,
	97	const char *To);
	98	bool AddConfFile(const char Name,const char NameEnd,
	99	PkgIterator const &Owner,const unsigned char *Sum);
	100
	101	pkgFLCache(DynamicMMap &Map);
	102	// ~pkgFLCache();
	103	};
	104
	105	struct pkgFLCache::Header
	106	{
	107	// Signature information
	108	unsigned long Signature;
	109	short MajorVersion;
	110	short MinorVersion;
	111	bool Dirty;
	112
	113	// Size of structure values
	114	unsigned HeaderSz;
	115	unsigned NodeSz;
	116	unsigned DirSz;
117	unsigned PackageSz;
118	unsigned DiversionSz;
119	unsigned ConfFileSz;
120
121	// Structure Counts;
122	unsigned int NodeCount;
123	unsigned int DirCount;
124	unsigned int PackageCount;
125	unsigned int DiversionCount;
126	unsigned int ConfFileCount;
127	unsigned int HashSize;
128	unsigned long UniqNodes;
129
130	// Offsets
131	map_ptrloc FileHash;
132	map_ptrloc DirTree;
133	map_ptrloc Packages;
134	map_ptrloc Diversions;
135
136	/* Allocation pools, there should be one of these for each structure
137	excluding the header */
138	DynamicMMap::Pool Pools[5];
139
140	bool CheckSizes(Header &Against) const;
141	Header();
142	};
143
144	/* The bit field is used to advoid incurring an extra 4 bytes x 40000,
145	Pointer is the most infrequently used member of the structure */
146	struct pkgFLCache::Node
147	{
148	map_ptrloc Dir; // Dir
149	map_ptrloc File; // String
150	unsigned Pointer:24; // Package/Diversion/ConfFile
151	unsigned Flags:8; // Package
152	map_ptrloc Next; // Node
153	map_ptrloc NextPkg; // Node
154
155	enum Flags {Diversion = (1<<0),ConfFile = (1<<1),
156	NewConfFile = (1<<2),NewFile = (1<<3),
157	Unpacked = (1<<4),Replaced = (1<<5)};
158	};
159
160	struct pkgFLCache::Directory
161	{
162	map_ptrloc Left; // Directory
163	map_ptrloc Right; // Directory
164	map_ptrloc Name; // String
165	};
166
167	struct pkgFLCache::Package
168	{
169	map_ptrloc Left; // Package
170	map_ptrloc Right; // Package
171	map_ptrloc Name; // String
172	map_ptrloc Files; // Node
173	};
174
175	struct pkgFLCache::Diversion
176	{
177	map_ptrloc OwnerPkg; // Package
178	map_ptrloc DivertFrom; // Node
179	map_ptrloc DivertTo; // String
180
181	map_ptrloc Next; // Diversion
182	unsigned long Flags;
183
184	enum Flags {Touched = (1<<0)};
185	};
186
187	struct pkgFLCache::ConfFile
188	{
189	map_ptrloc OwnerPkg; // Package
190	unsigned char MD5[16];
191	};
192
193	class pkgFLCache::PkgIterator
194	{
195	Package *Pkg;
196	pkgFLCache *Owner;
197
198	public:
199
200	inline bool end() const {return Owner == 0 \|\| Pkg == Owner->PkgP?true:false;}
201
202	// Accessors
203	inline Package *operator ->() {return Pkg;};
204	inline Package const *operator ->() const {return Pkg;};
205	inline Package const &operator () const {return Pkg;};
206	inline operator Package *() {return Pkg == Owner->PkgP?0:Pkg;};
207	inline operator Package const *() const {return Pkg == Owner->PkgP?0:Pkg;};
208
209	inline unsigned long Offset() const {return Pkg - Owner->PkgP;};
210	inline const char *Name() const {return Pkg->Name == 0?0:Owner->StrP + Pkg->Name;};
211	inline pkgFLCache::NodeIterator Files() const;
212
213	PkgIterator() : Pkg(0), Owner(0) {};
214	PkgIterator(pkgFLCache &Owner,Package *Trg) : Pkg(Trg), Owner(&Owner) {};
215	};
216
217	class pkgFLCache::DirIterator
218	{
219	Directory *Dir;
220	pkgFLCache *Owner;
221
222	public:
223
224	// Accessors
225	inline Directory *operator ->() {return Dir;};
226	inline Directory const *operator ->() const {return Dir;};
227	inline Directory const &operator () const {return Dir;};
228	inline operator Directory *() {return Dir == Owner->DirP?0:Dir;};
229	inline operator Directory const *() const {return Dir == Owner->DirP?0:Dir;};
230
231	inline const char *Name() const {return Dir->Name == 0?0:Owner->StrP + Dir->Name;};
232
233	DirIterator() : Dir(0), Owner(0) {};
234	DirIterator(pkgFLCache &Owner,Directory *Trg) : Dir(Trg), Owner(&Owner) {};
235	};
236
237	class pkgFLCache::DiverIterator
238	{
239	Diversion *Diver;
240	pkgFLCache *Owner;
241
242	public:
243
244	// Iteration
245	void operator ++(int) {if (Diver != Owner->DiverP) Diver = Owner->DiverP + Diver->Next;};
246	inline void operator ++() {operator ++(0);};
247	inline bool end() const {return Owner == 0 \|\| Diver == Owner->DiverP;};
248
249	// Accessors
250	inline Diversion *operator ->() {return Diver;};
251	inline Diversion const *operator ->() const {return Diver;};
252	inline Diversion const &operator () const {return Diver;};
253	inline operator Diversion *() {return Diver == Owner->DiverP?0:Diver;};
254	inline operator Diversion const *() const {return Diver == Owner->DiverP?0:Diver;};
255
256	inline PkgIterator OwnerPkg() const {return PkgIterator(*Owner,Owner->PkgP + Diver->OwnerPkg);};
257	inline NodeIterator DivertFrom() const;
258	inline NodeIterator DivertTo() const;
259
260	DiverIterator() : Diver(0), Owner(0) {};
261	DiverIterator(pkgFLCache &Owner,Diversion *Trg) : Diver(Trg), Owner(&Owner) {};
262	};
263
264	class pkgFLCache::NodeIterator
265	{
266	Node *Nde;
267	enum {NdePkg, NdeHash} Type;
268	pkgFLCache *Owner;
269
270	public:
271
272	// Iteration
273	void operator ++(int) {if (Nde != Owner->NodeP) Nde = Owner->NodeP +
274	(Type == NdePkg?Nde->NextPkg:Nde->Next);};
275	inline void operator ++() {operator ++(0);};
276	inline bool end() const {return Owner == 0 \|\| Nde == Owner->NodeP;};
277
278	// Accessors
279	inline Node *operator ->() {return Nde;};
280	inline Node const *operator ->() const {return Nde;};
281	inline Node const &operator () const {return Nde;};
282	inline operator Node *() {return Nde == Owner->NodeP?0:Nde;};
283	inline operator Node const *() const {return Nde == Owner->NodeP?0:Nde;};
284	inline unsigned long Offset() const {return Nde - Owner->NodeP;};
285	inline DirIterator Dir() const {return DirIterator(*Owner,Owner->DirP + Nde->Dir);};
286	inline DiverIterator Diversion() const {return DiverIterator(*Owner,Owner->DiverP + Nde->Pointer);};
287	inline const char *File() const {return Nde->File == 0?0:Owner->StrP + Nde->File;};
288	inline const char *DirN() const {return Owner->StrP + Owner->DirP[Nde->Dir].Name;};
289	Package *RealPackage() const;
290
291	NodeIterator() : Nde(0), Type(NdeHash), Owner(0) {};
292	NodeIterator(pkgFLCache &Owner) : Nde(Owner.NodeP), Type(NdeHash), Owner(&Owner) {};
293	NodeIterator(pkgFLCache &Owner,Node *Trg) : Nde(Trg), Type(NdeHash), Owner(&Owner) {};
294	NodeIterator(pkgFLCache &Owner,Node Trg,Package ) : Nde(Trg), Type(NdePkg), Owner(&Owner) {};
295	};
296
297	/* Inlines with forward references that cannot be included directly in their
298	respsective classes */
299	inline pkgFLCache::NodeIterator pkgFLCache::DiverIterator::DivertFrom() const
300	{return NodeIterator(*Owner,Owner->NodeP + Diver->DivertFrom);};
301	inline pkgFLCache::NodeIterator pkgFLCache::DiverIterator::DivertTo() const
302	{return NodeIterator(*Owner,Owner->NodeP + Diver->DivertTo);};
303
304	inline pkgFLCache::NodeIterator pkgFLCache::PkgIterator::Files() const
305	{return NodeIterator(*Owner,Owner->NodeP + Pkg->Files,Pkg);};
306
307	inline pkgFLCache::DiverIterator pkgFLCache::DiverBegin()
308	{return DiverIterator(*this,DiverP + HeaderP->Diversions);};
309
310	inline pkgFLCache::PkgIterator pkgFLCache::GetPkg(const char *Name,bool Insert)
311	{return GetPkg(Name,Name+strlen(Name),Insert);};
312
313	#endif