You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

830 lines
31 KiB

// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
/**\file pkgcache.h
\brief pkgCache - Structure definitions for the cache file
The goal of the cache file is two fold:
Firstly to speed loading and processing of the package file array and
secondly to reduce memory consumption of the package file array.
The implementation is aimed at an environment with many primary package
files, for instance someone that has a Package file for their CD-ROM, a
Package file for the latest version of the distribution on the CD-ROM and a
package file for the development version. Always present is the information
contained in the status file which might be considered a separate package
file.
Please understand, this is designed as a <b>Cache file</b> it is not meant to be
used on any system other than the one it was created for. It is not meant to
be authoritative either, i.e. if a system crash or software failure occurs it
must be perfectly acceptable for the cache file to be in an inconsistent
state. Furthermore at any time the cache file may be erased without losing
any information.
Also the structures and storage layout is optimized for use by the APT
and may not be suitable for all purposes. However it should be possible
to extend it with associate cache files that contain other information.
To keep memory use down the cache file only contains often used fields and
fields that are inexpensive to store, the Package file has a full list of
fields. Also the client may assume that all items are perfectly valid and
need not perform checks against their correctness. Removal of information
from the cache is possible, but blanks will be left in the file, and
unused strings will also be present. The recommended implementation is to
simply rebuild the cache each time any of the data files change. It is
possible to add a new package file to the cache without any negative side
effects.
<b>Note on Pointer access</b>
Clients should always use the CacheIterators classes for access to the
cache and the data in it. They also provide a simple STL-like method for
traversing the links of the datastructure.
Every item in every structure is stored as the index to that structure.
What this means is that once the files is mmaped every data access has to
go through a fix up stage to get a real memory pointer. This is done
by taking the index, multiplying it by the type size and then adding
it to the start address of the memory block. This sounds complex, but
in C it is a single array dereference. Because all items are aligned to
their size and indexes are stored as multiples of the size of the structure
the format is immediately portable to all possible architectures - BUT the
generated files are -NOT-.
This scheme allows code like this to be written:
<example>
void *Map = mmap(...);
Package *PkgList = (Package *)Map;
Header *Head = (Header *)Map;
char *Strings = (char *)Map;
cout << (Strings + PkgList[Head->HashTable[0]]->Name) << endl;
</example>
Notice the lack of casting or multiplication. The net result is to return
the name of the first package in the first hash bucket, without error
checks.
The generator uses allocation pools to group similarly sized structures in
large blocks to eliminate any alignment overhead. The generator also
assures that no structures overlap and all indexes are unique. Although
at first glance it may seem like there is the potential for two structures
to exist at the same point the generator never allows this to happen.
(See the discussion of free space pools)
See \ref pkgcachegen.h for more information about generating cache structures. */
/*}}}*/
#ifndef PKGLIB_PKGCACHE_H
#define PKGLIB_PKGCACHE_H
#define __PKGLIB_IN_PKGCACHE_H
#include <apt-pkg/macros.h>
#include <apt-pkg/mmap.h>
#include <string>
#include <stdint.h>
#include <time.h>
#ifdef APT_PKG_EXPOSE_STRING_VIEW
#include <apt-pkg/string_view.h>
#endif
#ifndef APT_8_CLEANER_HEADERS
using std::string;
#endif
// size of (potentially big) files like debs or the install size of them
typedef uint64_t map_filesize_t;
// storing file sizes of indexes, which are way below 4 GB for now
typedef uint32_t map_filesize_small_t;
// each package/group/dependency gets an id
typedef uint32_t map_id_t;
// some files get an id, too, but in far less absolute numbers
typedef uint16_t map_fileid_t;
// relative pointer from cache start
typedef uint32_t map_pointer_t;
// same as the previous, but documented to be to a string item
typedef map_pointer_t map_stringitem_t;
// we have only a small amount of flags for each item
typedef uint8_t map_flags_t;
typedef uint8_t map_number_t;
class pkgVersioningSystem;
class pkgCache /*{{{*/
{
public:
// Cache element predeclarations
struct Header;
struct Group;
struct Package;
struct ReleaseFile;
struct PackageFile;
struct Version;
struct Description;
struct Provides;
struct Dependency;
struct DependencyData;
struct StringItem;
struct VerFile;
struct DescFile;
// Iterators
template<typename Str, typename Itr> class Iterator;
class GrpIterator;
class PkgIterator;
class VerIterator;
class DescIterator;
class DepIterator;
class PrvIterator;
class RlsFileIterator;
class PkgFileIterator;
class VerFileIterator;
class DescFileIterator;
class Namespace;
// These are all the constants used in the cache structures
// WARNING - if you change these lists you must also edit
// the stringification in pkgcache.cc and also consider whether
// the cache file will become incompatible.
struct Dep
{
enum DepType {Depends=1,PreDepends=2,Suggests=3,Recommends=4,
Conflicts=5,Replaces=6,Obsoletes=7,DpkgBreaks=8,Enhances=9};
/** \brief available compare operators
The lower 4 bits are used to indicate what operator is being specified and
the upper 4 bits are flags. OR indicates that the next package is
or'd with the current package. */
enum DepCompareOp {NoOp=0,LessEq=0x1,GreaterEq=0x2,Less=0x3,
Greater=0x4,Equals=0x5,NotEquals=0x6,
Or=0x10, /*!< or'ed with the next dependency */
MultiArchImplicit=0x20, /*!< generated internally, not spelled out in the index */
ArchSpecific=0x40 /*!< was decorated with an explicit architecture in index */
};
};
struct State
{
/** \brief priority of a package version
Zero is used for unparsable or absent Priority fields. */
enum VerPriority {Required=1,Important=2,Standard=3,Optional=4,Extra=5};
enum PkgSelectedState {Unknown=0,Install=1,Hold=2,DeInstall=3,Purge=4};
enum PkgInstState {Ok=0,ReInstReq=1,HoldInst=2,HoldReInstReq=3};
enum PkgCurrentState {NotInstalled=0,UnPacked=1,HalfConfigured=2,
HalfInstalled=4,ConfigFiles=5,Installed=6,
TriggersAwaited=7,TriggersPending=8};
};
struct Flag
{
enum PkgFlags {Auto=(1<<0),Essential=(1<<3),Important=(1<<4)};
enum PkgFFlags {
NotSource=(1<<0), /*!< packages can't be fetched from here, e.g. dpkg/status file */
LocalSource=(1<<1), /*!< local sources can't and will not be verified by hashes */
NoPackages=(1<<2), /*!< the file includes no package records itself, but additions like Translations */
};
enum ReleaseFileFlags {
NotAutomatic=(1<<0), /*!< archive has a default pin of 1 */
ButAutomaticUpgrades=(1<<1), /*!< (together with the previous) archive has a default pin of 100 */
};
enum ProvidesFlags {
MultiArchImplicit=pkgCache::Dep::MultiArchImplicit, /*!< generated internally, not spelled out in the index */
ArchSpecific=pkgCache::Dep::ArchSpecific /*!< was decorated with an explicit architecture in index */
};
};
protected:
// Memory mapped cache file
std::string CacheFile;
MMap &Map;
#ifdef APT_PKG_EXPOSE_STRING_VIEW
APT_HIDDEN map_id_t sHash(APT::StringView S) const APT_PURE;
#endif
map_id_t sHash(const std::string &S) const APT_PURE;
map_id_t sHash(const char *S) const APT_PURE;
public:
// Pointers to the arrays of items
Header *HeaderP;
Group *GrpP;
Package *PkgP;
VerFile *VerFileP;
DescFile *DescFileP;
ReleaseFile *RlsFileP;
PackageFile *PkgFileP;
Version *VerP;
Description *DescP;
Provides *ProvideP;
Dependency *DepP;
DependencyData *DepDataP;
APT_DEPRECATED_MSG("Not used anymore in cache generation and without a replacement") StringItem *StringItemP;
char *StrP;
virtual bool ReMap(bool const &Errorchecks = true);
inline bool Sync() {return Map.Sync();}
inline MMap &GetMap() {return Map;}
inline void *DataEnd() {return ((unsigned char *)Map.Data()) + Map.Size();}
// String hashing function (512 range)
#ifdef APT_PKG_EXPOSE_STRING_VIEW
APT_HIDDEN inline map_id_t Hash(APT::StringView S) const {return sHash(S);}
#endif
inline map_id_t Hash(const std::string &S) const {return sHash(S);}
inline map_id_t Hash(const char *S) const {return sHash(S);}
APT_HIDDEN uint32_t CacheHash();
// Useful transformation things
static const char *Priority(unsigned char Priority);
// Accessors
#ifdef APT_PKG_EXPOSE_STRING_VIEW
APT_HIDDEN GrpIterator FindGrp(APT::StringView Name);
APT_HIDDEN PkgIterator FindPkg(APT::StringView Name);
APT_HIDDEN PkgIterator FindPkg(APT::StringView Name, APT::StringView Arch);
#endif
#ifdef APT_PKG_EXPOSE_STRING_VIEW
APT::StringView ViewString(map_stringitem_t idx) const
{
char *name = StrP + idx;
uint16_t len = *reinterpret_cast<const uint16_t*>(name - sizeof(uint16_t));
return APT::StringView(name, len);
}
#endif
GrpIterator FindGrp(const std::string &Name);
PkgIterator FindPkg(const std::string &Name);
PkgIterator FindPkg(const std::string &Name, const std::string &Arch);
Header &Head() {return *HeaderP;}
inline GrpIterator GrpBegin();
inline GrpIterator GrpEnd();
inline PkgIterator PkgBegin();
inline PkgIterator PkgEnd();
inline PkgFileIterator FileBegin();
inline PkgFileIterator FileEnd();
inline RlsFileIterator RlsFileBegin();
inline RlsFileIterator RlsFileEnd();
inline bool MultiArchCache() const { return MultiArchEnabled; }
inline char const * NativeArch();
// Make me a function
pkgVersioningSystem *VS;
// Converters
static const char *CompTypeDeb(unsigned char Comp) APT_PURE;
static const char *CompType(unsigned char Comp) APT_PURE;
static const char *DepType(unsigned char Dep);
pkgCache(MMap *Map,bool DoMap = true);
virtual ~pkgCache();
private:
void * const d;
bool MultiArchEnabled;
};
/*}}}*/
// Header structure /*{{{*/
struct pkgCache::Header
{
/** \brief Signature information
This must contain the hex value 0x98FE76DC which is designed to
verify that the system loading the image has the same byte order
and byte size as the system saving the image */
uint32_t Signature;
/** These contain the version of the cache file */
map_number_t MajorVersion;
map_number_t MinorVersion;
/** \brief indicates if the cache should be erased
Dirty is true if the cache file was opened for reading, the client
expects to have written things to it and have not fully synced it.
The file should be erased and rebuilt if it is true. */
bool Dirty;
/** \brief Size of structure values
All *Sz variables contains the sizeof() that particular structure.
It is used as an extra consistency check on the structure of the file.
If any of the size values do not exactly match what the client expects
then the client should refuse the load the file. */
uint16_t HeaderSz;
map_number_t GroupSz;
map_number_t PackageSz;
map_number_t ReleaseFileSz;
map_number_t PackageFileSz;
map_number_t VersionSz;
map_number_t DescriptionSz;
map_number_t DependencySz;
map_number_t DependencyDataSz;
map_number_t ProvidesSz;
map_number_t VerFileSz;
map_number_t DescFileSz;
/** \brief Structure counts
These indicate the number of each structure contained in the cache.
PackageCount is especially useful for generating user state structures.
See Package::Id for more info. */
map_id_t GroupCount;
map_id_t PackageCount;
map_id_t VersionCount;
map_id_t DescriptionCount;
map_id_t DependsCount;
map_id_t DependsDataCount;
map_fileid_t ReleaseFileCount;
map_fileid_t PackageFileCount;
map_fileid_t VerFileCount;
map_fileid_t DescFileCount;
map_id_t ProvidesCount;
/** \brief index of the first PackageFile structure
The PackageFile structures are singly linked lists that represent
all package files that have been merged into the cache. */
map_pointer_t FileList;
/** \brief index of the first ReleaseFile structure */
map_pointer_t RlsFileList;
/** \brief String representing the version system used */
map_pointer_t VerSysName;
/** \brief native architecture the cache was built against */
map_pointer_t Architecture;
/** \brief all architectures the cache was built against */
map_pointer_t Architectures;
/** \brief The maximum size of a raw entry from the original Package file */
map_filesize_t MaxVerFileSize;
/** \brief The maximum size of a raw entry from the original Translation file */
map_filesize_t MaxDescFileSize;
/** \brief The Pool structures manage the allocation pools that the generator uses
Start indicates the first byte of the pool, Count is the number of objects
remaining in the pool and ItemSize is the structure size (alignment factor)
of the pool. An ItemSize of 0 indicates the pool is empty. There should be
the same number of pools as there are structure types. The generator
stores this information so future additions can make use of any unused pool
blocks. */
DynamicMMap::Pool Pools[12];
increase hashtable size for packages/groups by factor 5 It also makes the size configureable, so it can be adapted in the future without the need for an abi break - and even by users… The increase was long overdue as it gives a >10% decrease in runtime of e.g. 'apt-get check -s'. Some (useless) benchmark with 69933 groups and 187796 packages without a pre-built cache: time apt-get check -so APT::Cache-HashTableSize=1 → 20m time apt-get check -so APT::Cache-HashTableSize=1000 → 6,41s time apt-get check -so APT::Cache-HashTableSize=2000 → 5,64s (old) time apt-get check -so APT::Cache-HashTableSize=3000 → 5,30s time apt-get check -so APT::Cache-HashTableSize=5000 → 5,08s time apt-get check -so APT::Cache-HashTableSize=6000 → 5,05s time apt-get check -so APT::Cache-HashTableSize=7000 → 5,02s time apt-get check -so APT::Cache-HashTableSize=8000 → 5,00s time apt-get check -so APT::Cache-HashTableSize=9000 → 4,98s time apt-get check -so APT::Cache-HashTableSize=10000 → 4,96s (new) time apt-get check -so APT::Cache-HashTableSize=15000 → 4,90s time apt-get check -so APT::Cache-HashTableSize=20000 → 4,86s time apt-get check -so APT::Cache-HashTableSize=30000 → 4,77s time apt-get check -so APT::Cache-HashTableSize=40000 → 4,74s time apt-get check -so APT::Cache-HashTableSize=50000 → 4,73s time apt-get check -so APT::Cache-HashTableSize=60000 → 4,71s The gap increases further for operations which have more package lookups. Factor 5 was chosen as higher values do not provide any really significant timing advantage anymore compared to the memory increase in my testing and there is always the possibility to increase it now if that changes. (also most users will not have 3 releases and 4 architectures in the cache, so theirs will be much smaller and faster).
8 years ago
/** \brief hash tables providing rapid group/package name lookup
increase hashtable size for packages/groups by factor 5 It also makes the size configureable, so it can be adapted in the future without the need for an abi break - and even by users… The increase was long overdue as it gives a >10% decrease in runtime of e.g. 'apt-get check -s'. Some (useless) benchmark with 69933 groups and 187796 packages without a pre-built cache: time apt-get check -so APT::Cache-HashTableSize=1 → 20m time apt-get check -so APT::Cache-HashTableSize=1000 → 6,41s time apt-get check -so APT::Cache-HashTableSize=2000 → 5,64s (old) time apt-get check -so APT::Cache-HashTableSize=3000 → 5,30s time apt-get check -so APT::Cache-HashTableSize=5000 → 5,08s time apt-get check -so APT::Cache-HashTableSize=6000 → 5,05s time apt-get check -so APT::Cache-HashTableSize=7000 → 5,02s time apt-get check -so APT::Cache-HashTableSize=8000 → 5,00s time apt-get check -so APT::Cache-HashTableSize=9000 → 4,98s time apt-get check -so APT::Cache-HashTableSize=10000 → 4,96s (new) time apt-get check -so APT::Cache-HashTableSize=15000 → 4,90s time apt-get check -so APT::Cache-HashTableSize=20000 → 4,86s time apt-get check -so APT::Cache-HashTableSize=30000 → 4,77s time apt-get check -so APT::Cache-HashTableSize=40000 → 4,74s time apt-get check -so APT::Cache-HashTableSize=50000 → 4,73s time apt-get check -so APT::Cache-HashTableSize=60000 → 4,71s The gap increases further for operations which have more package lookups. Factor 5 was chosen as higher values do not provide any really significant timing advantage anymore compared to the memory increase in my testing and there is always the possibility to increase it now if that changes. (also most users will not have 3 releases and 4 architectures in the cache, so theirs will be much smaller and faster).
8 years ago
Each group/package name is inserted into a hash table using pkgCache::Hash(const &string)
By iterating over each entry in the hash table it is possible to iterate over
the entire list of packages. Hash Collisions are handled with a singly linked
list of packages based at the hash item. The linked list contains only
packages that match the hashing function.
In the PkgHashTable is it possible that multiple packages have the same name -
these packages are stored as a sequence in the list.
increase hashtable size for packages/groups by factor 5 It also makes the size configureable, so it can be adapted in the future without the need for an abi break - and even by users… The increase was long overdue as it gives a >10% decrease in runtime of e.g. 'apt-get check -s'. Some (useless) benchmark with 69933 groups and 187796 packages without a pre-built cache: time apt-get check -so APT::Cache-HashTableSize=1 → 20m time apt-get check -so APT::Cache-HashTableSize=1000 → 6,41s time apt-get check -so APT::Cache-HashTableSize=2000 → 5,64s (old) time apt-get check -so APT::Cache-HashTableSize=3000 → 5,30s time apt-get check -so APT::Cache-HashTableSize=5000 → 5,08s time apt-get check -so APT::Cache-HashTableSize=6000 → 5,05s time apt-get check -so APT::Cache-HashTableSize=7000 → 5,02s time apt-get check -so APT::Cache-HashTableSize=8000 → 5,00s time apt-get check -so APT::Cache-HashTableSize=9000 → 4,98s time apt-get check -so APT::Cache-HashTableSize=10000 → 4,96s (new) time apt-get check -so APT::Cache-HashTableSize=15000 → 4,90s time apt-get check -so APT::Cache-HashTableSize=20000 → 4,86s time apt-get check -so APT::Cache-HashTableSize=30000 → 4,77s time apt-get check -so APT::Cache-HashTableSize=40000 → 4,74s time apt-get check -so APT::Cache-HashTableSize=50000 → 4,73s time apt-get check -so APT::Cache-HashTableSize=60000 → 4,71s The gap increases further for operations which have more package lookups. Factor 5 was chosen as higher values do not provide any really significant timing advantage anymore compared to the memory increase in my testing and there is always the possibility to increase it now if that changes. (also most users will not have 3 releases and 4 architectures in the cache, so theirs will be much smaller and faster).
8 years ago
The size of both tables is the same. */
uint32_t HashTableSize;
uint32_t GetHashTableSize() const { return HashTableSize; }
void SetHashTableSize(unsigned int const sz) { HashTableSize = sz; }
map_pointer_t GetArchitectures() const { return Architectures; }
void SetArchitectures(map_pointer_t const idx) { Architectures = idx; }
map_pointer_t * PkgHashTableP() const { return (map_pointer_t*) (this + 1); }
map_pointer_t * GrpHashTableP() const { return PkgHashTableP() + GetHashTableSize(); }
/** \brief Hash of the file (TODO: Rename) */
map_filesize_small_t CacheFileSize;
bool CheckSizes(Header &Against) const APT_PURE;
Header();
};
/*}}}*/
// Group structure /*{{{*/
/** \brief groups architecture depending packages together
On or more packages with the same name form a group, so we have
a simple way to access a package built for different architectures
Group exists in a singly linked list of group records starting at
the hash index of the name in the pkgCache::Header::GrpHashTable */
struct pkgCache::Group
{
/** \brief Name of the group */
map_stringitem_t Name;
// Linked List
/** \brief Link to the first package which belongs to the group */
map_pointer_t FirstPackage; // Package
/** \brief Link to the last package which belongs to the group */
map_pointer_t LastPackage; // Package
/** \brief Link to the next Group */
map_pointer_t Next; // Group
/** \brief unique sequel ID */
map_id_t ID;
};
/*}}}*/
// Package structure /*{{{*/
/** \brief contains information for a single unique package
There can be any number of versions of a given package.
Package exists in a singly linked list of package records starting at
the hash index of the name in the pkgCache::Header::PkgHashTable
A package can be created for every architecture so package names are
not unique, but it is guaranteed that packages with the same name
are sequencel ordered in the list. Packages with the same name can be
accessed with the Group.
*/
struct pkgCache::Package
{
/** \brief Name of the package
* Note that the access method Name() will remain. It is just this data member
* deprecated as this information is already stored and available via the
* associated Group so it is wasting precious binary cache space */
APT_DEPRECATED_MSG("Use the .Name() method instead of accessing the member directly") map_stringitem_t Name;
/** \brief Architecture of the package */
map_stringitem_t Arch;
/** \brief Base of a singly linked list of versions
Each structure represents a unique version of the package.
The version structures contain links into PackageFile and the
original text file as well as detailed information about the size
and dependencies of the specific package. In this way multiple
versions of a package can be cleanly handled by the system.
Furthermore, this linked list is guaranteed to be sorted
from Highest version to lowest version with no duplicate entries. */
map_pointer_t VersionList; // Version
/** \brief index to the installed version */
map_pointer_t CurrentVer; // Version
/** \brief index of the group this package belongs to */
map_pointer_t Group; // Group the Package belongs to
// Linked list
/** \brief Link to the next package in the same bucket */
map_pointer_t NextPackage; // Package
/** \brief List of all dependencies on this package */
map_pointer_t RevDepends; // Dependency
/** \brief List of all "packages" this package provide */
map_pointer_t ProvidesList; // Provides
// Install/Remove/Purge etc
/** \brief state that the user wishes the package to be in */
map_number_t SelectedState; // What
/** \brief installation state of the package
This should be "ok" but in case the installation failed
it will be different.
*/
map_number_t InstState; // Flags
/** \brief indicates if the package is installed */
map_number_t CurrentState; // State
/** \brief unique sequel ID
ID is a unique value from 0 to Header->PackageCount assigned by the generator.
This allows clients to create an array of size PackageCount and use it to store
state information for the package map. For instance the status file emitter uses
this to track which packages have been emitted already. */
map_id_t ID;
/** \brief some useful indicators of the package's state */
map_flags_t Flags;
};
/*}}}*/
// Release File structure /*{{{*/
/** \brief stores information about the release files used to generate the cache
PackageFiles reference ReleaseFiles as we need to keep record of which
version belongs to which release e.g. for pinning. */
struct pkgCache::ReleaseFile
{
/** \brief physical disk file that this ReleaseFile represents */
map_stringitem_t FileName;
/** \brief the release information
Please see the files document for a description of what the
release information means. */
map_stringitem_t Archive;
map_stringitem_t Codename;
map_stringitem_t Version;
map_stringitem_t Origin;
map_stringitem_t Label;
/** \brief The site the index file was fetched from */
map_stringitem_t Site;
/** \brief Size of the file
Used together with the modification time as a
simple check to ensure that the Packages
file has not been altered since Cache generation. */
map_filesize_t Size;
/** \brief Modification time for the file */
time_t mtime;
/** @TODO document PackageFile::Flags */
map_flags_t Flags;
// Linked list
/** \brief Link to the next ReleaseFile in the Cache */
map_pointer_t NextFile;
/** \brief unique sequel ID */
map_fileid_t ID;
};
/*}}}*/
// Package File structure /*{{{*/
/** \brief stores information about the files used to generate the cache
Package files are referenced by Version structures to be able to know
after the generation still from which Packages file includes this Version
as we need this information later on e.g. for pinning. */
struct pkgCache::PackageFile
{
/** \brief physical disk file that this PackageFile represents */
map_stringitem_t FileName;
/** \brief the release information */
map_pointer_t Release;
map_stringitem_t Component;
map_stringitem_t Architecture;
/** \brief indicates what sort of index file this is
@TODO enumerate at least the possible indexes */
map_stringitem_t IndexType;
/** \brief Size of the file
Used together with the modification time as a
simple check to ensure that the Packages
file has not been altered since Cache generation. */
map_filesize_t Size;
/** \brief Modification time for the file */
time_t mtime;
/** @TODO document PackageFile::Flags */
map_flags_t Flags;
// Linked list
/** \brief Link to the next PackageFile in the Cache */
map_pointer_t NextFile; // PackageFile
/** \brief unique sequel ID */
map_fileid_t ID;
};
/*}}}*/
// VerFile structure /*{{{*/
/** \brief associates a version with a PackageFile
This allows a full description of all Versions in all files
(and hence all sources) under consideration. */
struct pkgCache::VerFile
{
/** \brief index of the package file that this version was found in */
map_pointer_t File; // PackageFile
/** \brief next step in the linked list */
map_pointer_t NextFile; // PkgVerFile
/** \brief position in the package file */
map_filesize_t Offset; // File offset
/** @TODO document pkgCache::VerFile::Size */
map_filesize_t Size;
};
/*}}}*/
// DescFile structure /*{{{*/
/** \brief associates a description with a Translation file */
struct pkgCache::DescFile
{
/** \brief index of the file that this description was found in */
map_pointer_t File; // PackageFile
/** \brief next step in the linked list */
map_pointer_t NextFile; // PkgVerFile
/** \brief position in the file */
map_filesize_t Offset; // File offset