[apt.git] / apt-pkg / pkgcache.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: pkgcache.cc,v 1.8 1998/07/19 04:22:00 jgg Exp $
/* ######################################################################
   
   Package Cache - Accessor code for the cache
   
   Please see doc/apt-pkg/cache.sgml for a more detailed description of 
   this format. Also be sure to keep that file up-to-date!!
   
   This is the general utility functions for cache managment. They provide
   a complete set of accessor functions for the cache. The cacheiterators
   header contains the STL-like iterators that can be used to easially
   navigate the cache as well as seemlessly dereference the mmap'd 
   indexes. Use these always.
   
   The main class provides for ways to get package indexes and some
   general lookup functions to start the iterators.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/pkgcache.h"
#pragma implementation "apt-pkg/cacheiterators.h"
#endif 
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/version.h>
#include <apt-pkg/error.h>
#include <system.h>

#include <string>
#include <sys/stat.h>
#include <unistd.h>
									/*}}}*/

// Cache::Header::Header - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* Simply initialize the header */
pkgCache::Header::Header()
{
   Signature = 0x98FE76DC;
   
   /* Whenever the structures change the major version should be bumped,
      whenever the generator changes the minor version should be bumped. */
   MajorVersion = 2;
   MinorVersion = 0;
   Dirty = true;
   
   HeaderSz = sizeof(pkgCache::Header);
   PackageSz = sizeof(pkgCache::Package);
   PackageFileSz = sizeof(pkgCache::PackageFile);
   VersionSz = sizeof(pkgCache::Version);
   DependencySz = sizeof(pkgCache::Dependency);
   ProvidesSz = sizeof(pkgCache::Provides);
   VerFileSz = sizeof(pkgCache::VerFile);
   
   PackageCount = 0;
   VersionCount = 0;
   DependsCount = 0;
   PackageFileCount = 0;
   MaxVerFileSize = 0;
   
   FileList = 0;
   StringList = 0;
   memset(HashTable,0,sizeof(HashTable));
   memset(Pools,0,sizeof(Pools));
}
									/*}}}*/
// Cache::Header::CheckSizes - Check if the two headers have same *sz	/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgCache::Header::CheckSizes(Header &Against) const
{
   if (HeaderSz == Against.HeaderSz &&
       PackageSz == Against.PackageSz &&
       PackageFileSz == Against.PackageFileSz &&
       VersionSz == Against.VersionSz &&
       DependencySz == Against.DependencySz &&
       VerFileSz == Against.VerFileSz &&
       ProvidesSz == Against.ProvidesSz)
      return true;
   return false;
}
									/*}}}*/

// Cache::pkgCache - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
pkgCache::pkgCache(MMap &Map) : Map(Map)
{
   ReMap();
}
									/*}}}*/
// Cache::ReMap - Reopen the cache file					/*{{{*/
// ---------------------------------------------------------------------
/* If the file is already closed then this will open it open it. */
bool pkgCache::ReMap()
{
   // Apply the typecasts.
   HeaderP = (Header *)Map.Data();
   PkgP = (Package *)Map.Data();
   VerFileP = (VerFile *)Map.Data();
   PkgFileP = (PackageFile *)Map.Data();
   VerP = (Version *)Map.Data();
   ProvideP = (Provides *)Map.Data();
   DepP = (Dependency *)Map.Data();
   StringItemP = (StringItem *)Map.Data();
   StrP = (char *)Map.Data();

   if (Map.Size() == 0)
      return false;
   
   // Check the header
   Header DefHeader;
   if (HeaderP->Signature != DefHeader.Signature ||
       HeaderP->Dirty == true)
      return _error->Error("The package cache file is corrupted");
   
   if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
       HeaderP->MinorVersion != DefHeader.MinorVersion ||
       HeaderP->CheckSizes(DefHeader) == false)
      return _error->Error("The package cache file is an incompatible version");
   
   return true;
}
									/*}}}*/
// Cache::Hash - Hash a string						/*{{{*/
// ---------------------------------------------------------------------
/* This is used to generate the hash entries for the HashTable. With my
   package list from bo this function gets 94% table usage on a 512 item
   table (480 used items) */
unsigned long pkgCache::sHash(string Str)
{
   unsigned long Hash = 0;
   for (const char *I = Str.begin(); I != Str.end(); I++)
      Hash += *I * ((Str.end() - I + 1));
   Header H;
   return Hash % _count(H.HashTable);
}

unsigned long pkgCache::sHash(const char *Str)
{
   unsigned long Hash = 0;
   const char *End = Str + strlen(Str);
   for (const char *I = Str; I != End; I++)
      Hash += *I * ((End - I + 1));
   Header H;
   return Hash % _count(H.HashTable);
}

									/*}}}*/
// Cache::FindPkg - Locate a package by name				/*{{{*/
// ---------------------------------------------------------------------
/* Returns 0 on error, pointer to the package otherwise */
pkgCache::PkgIterator pkgCache::FindPkg(string Name)
{
   // Look at the hash bucket
   Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
   for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
   {
      if (Pkg->Name != 0 && StrP + Pkg->Name == Name)
	 return PkgIterator(*this,Pkg);
   }
   return PkgIterator(*this,0);
}
									/*}}}*/
// Cache::Priority - Convert a priority value to a string		/*{{{*/
// ---------------------------------------------------------------------
/* */
const char *pkgCache::Priority(unsigned char Prio)
{
   const char *Mapping[] = {0,"important","required","standard","optional","extra"};
   if (Prio < _count(Mapping))
      return Mapping[Prio];
   return 0;
}
									/*}}}*/

// Bases for iterator classes						/*{{{*/
void pkgCache::VerIterator::_dummy() {}
void pkgCache::DepIterator::_dummy() {}
void pkgCache::PrvIterator::_dummy() {}
									/*}}}*/
// PkgIterator::operator ++ - Postfix incr				/*{{{*/
// ---------------------------------------------------------------------
/* This will advance to the next logical package in the hash table. */
void pkgCache::PkgIterator::operator ++(int) 
{
   // Follow the current links
   if (Pkg != Owner->PkgP)
      Pkg = Owner->PkgP + Pkg->NextPackage;
   
   // Follow the hash table
   while (Pkg == Owner->PkgP && HashIndex < (signed)_count(Owner->HeaderP->HashTable))
   {
      HashIndex++;
      Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
   }
};
									/*}}}*/
// PkgIterator::State - Check the State of the package			/*{{{*/
// ---------------------------------------------------------------------
/* By this we mean if it is either cleanly installed or cleanly removed. */
pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
{
   if (Pkg->CurrentState == State::UnPacked ||
       Pkg->CurrentState == State::HalfConfigured)
      return NeedsConfigure;
   
   if (Pkg->CurrentState == State::UnInstalled ||
       Pkg->CurrentState == State::HalfInstalled ||
       Pkg->InstState != State::Ok)
      return NeedsUnpack;
      
   return NeedsNothing;
}
									/*}}}*/
// DepIterator::IsCritical - Returns true if the dep is important	/*{{{*/
// ---------------------------------------------------------------------
/* Currently critical deps are defined as depends, predepends and
   conflicts. */
bool pkgCache::DepIterator::IsCritical()
{
   if (Dep->Type == Dep::Conflicts || Dep->Type == Dep::Depends ||
       Dep->Type == Dep::PreDepends)
      return true;
   return false;
}
									/*}}}*/
// DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides	/*{{{*/
// ---------------------------------------------------------------------
/* This intellegently looks at dep target packages and tries to figure
   out which package should be used. This is needed to nicely handle
   provide mapping. If the target package has no other providing packages
   then it returned. Otherwise the providing list is looked at to 
   see if there is one one unique providing package if so it is returned.
   Otherwise true is returned and the target package is set. The return
   result indicates whether the node should be expandable */
bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
{
   Result = TargetPkg();
   
   // No provides at all
   if (Result->ProvidesList == 0)
      return false;
   
   // There is the Base package and the providing ones which is at least 2
   if (Result->VersionList != 0)
      return true;
      
   /* We have to skip over indirect provisions of the package that
      owns the dependency. For instance, if libc5-dev depends on the
      virtual package libc-dev which is provided by libc5-dev and libc6-dev
      we must ignore libc5-dev when considering the provides list. */ 
   PrvIterator PStart = Result.ProvidesList();
   for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);

   // Nothing but indirect self provides
   if (PStart.end() == true)
      return false;
   
   // Check for single packages in the provides list
   PrvIterator P = PStart;
   for (; P.end() != true; P++)
   {
      // Skip over self provides
      if (P.OwnerPkg() == ParentPkg())
	 continue;
      if (PStart.OwnerPkg() != P.OwnerPkg())
	 break;
   }
   
   // Check for non dups
   if (P.end() != true)
      return true;
   Result = PStart.OwnerPkg();
   return false;
}
									/*}}}*/
// DepIterator::AllTargets - Returns the set of all possible targets	/*{{{*/
// ---------------------------------------------------------------------
/* This is a more usefull version of TargetPkg() that follows versioned
   provides. It includes every possible package-version that could satisfy
   the dependency. The last item in the list has a 0. */
pkgCache::Version **pkgCache::DepIterator::AllTargets()
{
   Version **Res = 0;
   unsigned long Size =0;
   while (1)
   {
      Version **End = Res;
      PkgIterator DPkg = TargetPkg();

      // Walk along the actual package providing versions
      for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
      {
	 if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
	    continue;

	 if (Dep->Type == Dep::Conflicts && ParentPkg() == I.ParentPkg())
	    continue;
	 
	 Size++;
	 if (Res != 0)
	    *End++ = I;
      }
      
      // Follow all provides
      for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
      {
	 if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
	    continue;
	 
	 if (Dep->Type == Dep::Conflicts && ParentPkg() == I.OwnerPkg())
	    continue;
	 
	 Size++;
	 if (Res != 0)
	    *End++ = I.OwnerVer();
      }
      
      // Do it again and write it into the array
      if (Res == 0)
      {
	 Res = new Version *[Size+1];
	 Size = 0;
      }
      else
      {
	 *End = 0;
	 break;
      }      
   }
   
   return Res;
}
									/*}}}*/
// VerIterator::CompareVer - Fast version compare for same pkgs		/*{{{*/
// ---------------------------------------------------------------------
/* This just looks over the version list to see if B is listed before A. In
   most cases this will return in under 4 checks, ver lists are short. */
int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
{
   // Check if they are equal
   if (*this == B)
      return 0;
   if (end() == true)
      return -1;
   if (B.end() == true)
      return 1;
       
   /* Start at A and look for B. If B is found then A > B otherwise
      B was before A so A < B */
   VerIterator I = *this;
   for (;I.end() == false; I++)
      if (I == B)
	 return 1;
   return -1;
}
									/*}}}*/
// VerIterator::Downloadable - Checks if the version is downloadable	/*{{{*/
// ---------------------------------------------------------------------
/* */
bool pkgCache::VerIterator::Downloadable() const
{
   VerFileIterator Files = FileList();
   for (; Files.end() == false; Files++)
      if ((Files.File()->Flags & Flag::NotSource) != Flag::NotSource)
	 return true;
   return false;
}
									/*}}}*/
// PkgFileIterator::IsOk - Checks if the cache is in sync with the file	/*{{{*/
// ---------------------------------------------------------------------
/* This stats the file and compares its stats with the ones that were
   stored during generation. Date checks should probably also be 
   included here. */
bool pkgCache::PkgFileIterator::IsOk()
{
   struct stat Buf;
   if (stat(FileName(),&Buf) != 0)
      return false;

   if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
      return false;

   return true;
}
									/*}}}*/
Commit	Line	Data
578bfd0a AL	1	// -- mode: cpp; mode: fold --
578bfd0a AL	2	// Description /{{{/
ad00ae81	3	// $Id: pkgcache.cc,v 1.8 1998/07/19 04:22:00 jgg Exp $
578bfd0a AL	4	/* ######################################################################
	5
	6	Package Cache - Accessor code for the cache
	7
094a497d	8	Please see doc/apt-pkg/cache.sgml for a more detailed description of
578bfd0a AL	9	this format. Also be sure to keep that file up-to-date!!
	10
	11	This is the general utility functions for cache managment. They provide
	12	a complete set of accessor functions for the cache. The cacheiterators
	13	header contains the STL-like iterators that can be used to easially
	14	navigate the cache as well as seemlessly dereference the mmap'd
	15	indexes. Use these always.
	16
	17	The main class provides for ways to get package indexes and some
	18	general lookup functions to start the iterators.
	19
	20	##################################################################### */
	21	/}}}/
	22	// Include Files /{{{/
6c139d6e	23	#ifdef __GNUG__
094a497d AL	24	#pragma implementation "apt-pkg/pkgcache.h"
094a497d AL	25	#pragma implementation "apt-pkg/cacheiterators.h"
6c139d6e	26	#endif
094a497d AL	27	#include <apt-pkg/pkgcache.h>
	28	#include <apt-pkg/version.h>
	29	#include <apt-pkg/error.h>
578bfd0a AL	30	#include <system.h>
	31
	32	#include <string>
	33	#include <sys/stat.h>
	34	#include <unistd.h>
	35	/}}}/
	36
	37	// Cache::Header::Header - Constructor /{{{/
	38	// ---------------------------------------------------------------------
	39	/* Simply initialize the header */
	40	pkgCache::Header::Header()
	41	{
	42	Signature = 0x98FE76DC;
	43
	44	/* Whenever the structures change the major version should be bumped,
	45	whenever the generator changes the minor version should be bumped. */
	46	MajorVersion = 2;
	47	MinorVersion = 0;
	48	Dirty = true;
	49
	50	HeaderSz = sizeof(pkgCache::Header);
	51	PackageSz = sizeof(pkgCache::Package);
	52	PackageFileSz = sizeof(pkgCache::PackageFile);
	53	VersionSz = sizeof(pkgCache::Version);
	54	DependencySz = sizeof(pkgCache::Dependency);
	55	ProvidesSz = sizeof(pkgCache::Provides);
dcb79bae AL	56	VerFileSz = sizeof(pkgCache::VerFile);
dcb79bae AL	57
578bfd0a AL	58	PackageCount = 0;
	59	VersionCount = 0;
	60	DependsCount = 0;
	61	PackageFileCount = 0;
ad00ae81	62	MaxVerFileSize = 0;
578bfd0a AL	63
	64	FileList = 0;
	65	StringList = 0;
	66	memset(HashTable,0,sizeof(HashTable));
	67	memset(Pools,0,sizeof(Pools));
	68	}
	69	/}}}/
	70	// Cache::Header::CheckSizes - Check if the two headers have same sz /{{{*/
	71	// ---------------------------------------------------------------------
	72	/* */
	73	bool pkgCache::Header::CheckSizes(Header &Against) const
	74	{
	75	if (HeaderSz == Against.HeaderSz &&
	76	PackageSz == Against.PackageSz &&
	77	PackageFileSz == Against.PackageFileSz &&
	78	VersionSz == Against.VersionSz &&
dcb79bae AL	79	DependencySz == Against.DependencySz &&
dcb79bae AL	80	VerFileSz == Against.VerFileSz &&
578bfd0a AL	81	ProvidesSz == Against.ProvidesSz)
	82	return true;
	83	return false;
	84	}
	85	/}}}/
	86
	87	// Cache::pkgCache - Constructor /{{{/
	88	// ---------------------------------------------------------------------
	89	/* */
	90	pkgCache::pkgCache(MMap &Map) : Map(Map)
	91	{
	92	ReMap();
	93	}
	94	/}}}/
	95	// Cache::ReMap - Reopen the cache file /{{{/
	96	// ---------------------------------------------------------------------
	97	/* If the file is already closed then this will open it open it. */
	98	bool pkgCache::ReMap()
	99	{
	100	// Apply the typecasts.
	101	HeaderP = (Header *)Map.Data();
	102	PkgP = (Package *)Map.Data();
dcb79bae	103	VerFileP = (VerFile *)Map.Data();
578bfd0a AL	104	PkgFileP = (PackageFile *)Map.Data();
	105	VerP = (Version *)Map.Data();
	106	ProvideP = (Provides *)Map.Data();
	107	DepP = (Dependency *)Map.Data();
	108	StringItemP = (StringItem *)Map.Data();
	109	StrP = (char *)Map.Data();
	110
578bfd0a AL	111	if (Map.Size() == 0)
	112	return false;
	113
	114	// Check the header
	115	Header DefHeader;
	116	if (HeaderP->Signature != DefHeader.Signature \|\|
	117	HeaderP->Dirty == true)
	118	return _error->Error("The package cache file is corrupted");
	119
	120	if (HeaderP->MajorVersion != DefHeader.MajorVersion \|\|
	121	HeaderP->MinorVersion != DefHeader.MinorVersion \|\|
	122	HeaderP->CheckSizes(DefHeader) == false)
	123	return _error->Error("The package cache file is an incompatible version");
	124
	125	return true;
	126	}
	127	/}}}/
	128	// Cache::Hash - Hash a string /{{{/
	129	// ---------------------------------------------------------------------
	130	/* This is used to generate the hash entries for the HashTable. With my
	131	package list from bo this function gets 94% table usage on a 512 item
	132	table (480 used items) */
	133	unsigned long pkgCache::sHash(string Str)
	134	{
	135	unsigned long Hash = 0;
	136	for (const char *I = Str.begin(); I != Str.end(); I++)
	137	Hash += I ((Str.end() - I + 1));
	138	Header H;
	139	return Hash % _count(H.HashTable);
	140	}
	141
	142	unsigned long pkgCache::sHash(const char *Str)
	143	{
	144	unsigned long Hash = 0;
	145	const char *End = Str + strlen(Str);
	146	for (const char *I = Str; I != End; I++)
	147	Hash += I ((End - I + 1));
	148	Header H;
	149	return Hash % _count(H.HashTable);
	150	}
	151
	152	/}}}/
	153	// Cache::FindPkg - Locate a package by name /{{{/
	154	// ---------------------------------------------------------------------
	155	/* Returns 0 on error, pointer to the package otherwise */
	156	pkgCache::PkgIterator pkgCache::FindPkg(string Name)
	157	{
	158	// Look at the hash bucket
	159	Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
	160	for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
	161	{
	162	if (Pkg->Name != 0 && StrP + Pkg->Name == Name)
	163	return PkgIterator(*this,Pkg);
	164	}
	165	return PkgIterator(*this,0);
	166	}
	167	/}}}/
0149949b AL	168	// Cache::Priority - Convert a priority value to a string /{{{/
	169	// ---------------------------------------------------------------------
	170	/* */
	171	const char *pkgCache::Priority(unsigned char Prio)
	172	{
	173	const char *Mapping[] = {0,"important","required","standard","optional","extra"};
	174	if (Prio < _count(Mapping))
	175	return Mapping[Prio];
	176	return 0;
	177	}
	178	/}}}/
578bfd0a	179
f55a958f AL	180	// Bases for iterator classes /{{{/
	181	void pkgCache::VerIterator::_dummy() {}
	182	void pkgCache::DepIterator::_dummy() {}
	183	void pkgCache::PrvIterator::_dummy() {}
	184	/}}}/
	185	// PkgIterator::operator ++ - Postfix incr /{{{/
578bfd0a AL	186	// ---------------------------------------------------------------------
	187	/* This will advance to the next logical package in the hash table. */
	188	void pkgCache::PkgIterator::operator ++(int)
	189	{
	190	// Follow the current links
	191	if (Pkg != Owner->PkgP)
	192	Pkg = Owner->PkgP + Pkg->NextPackage;
	193
	194	// Follow the hash table
	195	while (Pkg == Owner->PkgP && HashIndex < (signed)_count(Owner->HeaderP->HashTable))
	196	{
	197	HashIndex++;
	198	Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
	199	}
	200	};
	201	/}}}/
578bfd0a AL	202	// PkgIterator::State - Check the State of the package /{{{/
	203	// ---------------------------------------------------------------------
	204	/* By this we mean if it is either cleanly installed or cleanly removed. */
	205	pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
	206	{
6c139d6e AL	207	if (Pkg->CurrentState == State::UnPacked \|\|
6c139d6e AL	208	Pkg->CurrentState == State::HalfConfigured)
578bfd0a AL	209	return NeedsConfigure;
578bfd0a AL	210
6c139d6e AL	211	if (Pkg->CurrentState == State::UnInstalled \|\|
	212	Pkg->CurrentState == State::HalfInstalled \|\|
	213	Pkg->InstState != State::Ok)
578bfd0a AL	214	return NeedsUnpack;
	215
	216	return NeedsNothing;
	217	}
	218	/}}}/
	219	// DepIterator::IsCritical - Returns true if the dep is important /{{{/
	220	// ---------------------------------------------------------------------
	221	/* Currently critical deps are defined as depends, predepends and
	222	conflicts. */
	223	bool pkgCache::DepIterator::IsCritical()
	224	{
6c139d6e AL	225	if (Dep->Type == Dep::Conflicts \|\| Dep->Type == Dep::Depends \|\|
6c139d6e AL	226	Dep->Type == Dep::PreDepends)
578bfd0a AL	227	return true;
	228	return false;
	229	}
	230	/}}}/
	231	// DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /{{{/
	232	// ---------------------------------------------------------------------
	233	/* This intellegently looks at dep target packages and tries to figure
	234	out which package should be used. This is needed to nicely handle
	235	provide mapping. If the target package has no other providing packages
	236	then it returned. Otherwise the providing list is looked at to
	237	see if there is one one unique providing package if so it is returned.
	238	Otherwise true is returned and the target package is set. The return
	239	result indicates whether the node should be expandable */
	240	bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
	241	{
	242	Result = TargetPkg();
	243
	244	// No provides at all
	245	if (Result->ProvidesList == 0)
	246	return false;
	247
	248	// There is the Base package and the providing ones which is at least 2
	249	if (Result->VersionList != 0)
	250	return true;
	251
	252	/* We have to skip over indirect provisions of the package that
	253	owns the dependency. For instance, if libc5-dev depends on the
	254	virtual package libc-dev which is provided by libc5-dev and libc6-dev
	255	we must ignore libc5-dev when considering the provides list. */
	256	PrvIterator PStart = Result.ProvidesList();
	257	for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);
	258
	259	// Nothing but indirect self provides
	260	if (PStart.end() == true)
	261	return false;
	262
	263	// Check for single packages in the provides list
	264	PrvIterator P = PStart;
	265	for (; P.end() != true; P++)
	266	{
	267	// Skip over self provides
	268	if (P.OwnerPkg() == ParentPkg())
	269	continue;
	270	if (PStart.OwnerPkg() != P.OwnerPkg())
	271	break;
	272	}
	273
	274	// Check for non dups
	275	if (P.end() != true)
	276	return true;
	277	Result = PStart.OwnerPkg();
	278	return false;
	279	}
	280	/}}}/
	281	// DepIterator::AllTargets - Returns the set of all possible targets /{{{/
	282	// ---------------------------------------------------------------------
	283	/* This is a more usefull version of TargetPkg() that follows versioned
	284	provides. It includes every possible package-version that could satisfy
	285	the dependency. The last item in the list has a 0. */
	286	pkgCache::Version **pkgCache::DepIterator::AllTargets()
	287	{
	288	Version **Res = 0;
	289	unsigned long Size =0;
	290	while (1)
291	{
292	Version **End = Res;
293	PkgIterator DPkg = TargetPkg();
294
295	// Walk along the actual package providing versions
296	for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
297	{
298	if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
299	continue;
300
6c139d6e	301	if (Dep->Type == Dep::Conflicts && ParentPkg() == I.ParentPkg())
578bfd0a AL	302	continue;
	303
	304	Size++;
	305	if (Res != 0)
	306	*End++ = I;
	307	}
	308
	309	// Follow all provides
	310	for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
	311	{
	312	if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
	313	continue;
	314
6c139d6e	315	if (Dep->Type == Dep::Conflicts && ParentPkg() == I.OwnerPkg())
578bfd0a AL	316	continue;
	317
	318	Size++;
	319	if (Res != 0)
	320	*End++ = I.OwnerVer();
	321	}
	322
	323	// Do it again and write it into the array
	324	if (Res == 0)
	325	{
	326	Res = new Version *[Size+1];
	327	Size = 0;
	328	}
	329	else
	330	{
	331	*End = 0;
	332	break;
	333	}
	334	}
	335
	336	return Res;
	337	}
	338	/}}}/
	339	// VerIterator::CompareVer - Fast version compare for same pkgs /{{{/
	340	// ---------------------------------------------------------------------
	341	/* This just looks over the version list to see if B is listed before A. In
	342	most cases this will return in under 4 checks, ver lists are short. */
	343	int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
	344	{
	345	// Check if they are equal
	346	if (*this == B)
	347	return 0;
	348	if (end() == true)
	349	return -1;
	350	if (B.end() == true)
	351	return 1;
	352
	353	/* Start at A and look for B. If B is found then A > B otherwise
	354	B was before A so A < B */
	355	VerIterator I = *this;
	356	for (;I.end() == false; I++)
	357	if (I == B)
	358	return 1;
	359	return -1;
	360	}
	361	/}}}/
b518cca6 AL	362	// VerIterator::Downloadable - Checks if the version is downloadable /{{{/
	363	// ---------------------------------------------------------------------
	364	/* */
	365	bool pkgCache::VerIterator::Downloadable() const
	366	{
	367	VerFileIterator Files = FileList();
	368	for (; Files.end() == false; Files++)
	369	if ((Files.File()->Flags & Flag::NotSource) != Flag::NotSource)
	370	return true;
	371	return false;
	372	}
	373	/}}}/
578bfd0a AL	374	// PkgFileIterator::IsOk - Checks if the cache is in sync with the file /{{{/
	375	// ---------------------------------------------------------------------
	376	/* This stats the file and compares its stats with the ones that were
	377	stored during generation. Date checks should probably also be
	378	included here. */
	379	bool pkgCache::PkgFileIterator::IsOk()
	380	{
	381	struct stat Buf;
	382	if (stat(FileName(),&Buf) != 0)
	383	return false;
	384
	385	if (Buf.st_size != (signed)File->Size \|\| Buf.st_mtime != File->mtime)
	386	return false;
	387
	388	return true;
	389	}
	390	/}}}/