mirror of
https://github.com/ukui/apt.git
synced 2026-03-09 09:35:45 -07:00
d6f3458bad
An interactive tool like aptitude needs these flags current far more often than we do as a user can see them in apt only in one very well defined place – the autoremove display block – so we don't need to run it up to four times while a normal "apt install" is processed as that is just busywork. The effect on runtime is minimal, as a single run doesn't take too long anyhow, but it cuts down tremendously on debug output at the expense of requiring some manual handholding. This is opt-in so that aptitude doesn't need to change nor do we need to change our own tools like "apt list" where it is working correctly as intended. A special flag and co is needed as we want to prevent the ActionGroup inside pkgDepCache::Init to be inhibited already so we need to insert ourselves while the DepCache is still in the process of being built. This is also the reason why the debug output in some tests changed to all unmarked, but that is fine as the marking could have been already obsoleted by the actions taken, just inhibited by a proper action group.
91 lines
3.3 KiB
C++
91 lines
3.3 KiB
C++
// -*- mode: cpp; mode: fold -*-
|
|
// Description /*{{{*/
|
|
/* ######################################################################
|
|
|
|
CacheFile - Simple wrapper class for opening, generating and whatnot
|
|
|
|
This class implements a simple 2 line mechanism to open various sorts
|
|
of caches. It can operate as root, as not root, show progress and so on,
|
|
it transparently handles everything necessary.
|
|
|
|
This means it can rebuild caches from the source list and instantiates
|
|
and prepares the standard policy mechanism.
|
|
|
|
##################################################################### */
|
|
/*}}}*/
|
|
#ifndef PKGLIB_CACHEFILE_H
|
|
#define PKGLIB_CACHEFILE_H
|
|
|
|
#include <stddef.h>
|
|
|
|
#include <apt-pkg/depcache.h>
|
|
#include <apt-pkg/macros.h>
|
|
#include <apt-pkg/pkgcache.h>
|
|
|
|
|
|
class MMap;
|
|
class pkgPolicy;
|
|
class pkgSourceList;
|
|
class pkgIndexFile;
|
|
class OpProgress;
|
|
|
|
class APT_PUBLIC pkgCacheFile
|
|
{
|
|
struct Private;
|
|
/** \brief dpointer placeholder (for later in case we need it) */
|
|
Private *const d;
|
|
bool ExternOwner;
|
|
|
|
protected:
|
|
MMap *Map;
|
|
pkgCache *Cache;
|
|
pkgDepCache *DCache;
|
|
pkgSourceList *SrcList;
|
|
|
|
public:
|
|
pkgPolicy *Policy;
|
|
|
|
// We look pretty much exactly like a pointer to a dep cache
|
|
inline operator pkgCache &() const {return *Cache;};
|
|
inline operator pkgCache *() const {return Cache;};
|
|
inline operator pkgDepCache &() const {return *DCache;};
|
|
inline operator pkgDepCache *() const {return DCache;};
|
|
inline operator pkgPolicy &() const {return *Policy;};
|
|
inline operator pkgPolicy *() const {return Policy;};
|
|
inline operator pkgSourceList &() const {return *SrcList;};
|
|
inline operator pkgSourceList *() const {return SrcList;};
|
|
inline pkgDepCache *operator ->() const {return DCache;};
|
|
inline pkgDepCache &operator *() const {return *DCache;};
|
|
inline pkgDepCache::StateCache &operator [](pkgCache::PkgIterator const &I) const {return (*DCache)[I];};
|
|
inline unsigned char &operator [](pkgCache::DepIterator const &I) const {return (*DCache)[I];};
|
|
|
|
bool BuildCaches(OpProgress *Progress = NULL,bool WithLock = true);
|
|
bool BuildSourceList(OpProgress *Progress = NULL);
|
|
bool BuildPolicy(OpProgress *Progress = NULL);
|
|
bool BuildDepCache(OpProgress *Progress = NULL);
|
|
bool Open(OpProgress *Progress = NULL, bool WithLock = true);
|
|
inline bool ReadOnlyOpen(OpProgress *Progress = NULL) { return Open(Progress, false); };
|
|
static void RemoveCaches();
|
|
void Close();
|
|
|
|
bool AddIndexFile(pkgIndexFile * const File);
|
|
// Starts DepCache with a claim of one ActionGroup already active
|
|
void InhibitActionGroups(bool yes);
|
|
|
|
inline pkgCache* GetPkgCache() { BuildCaches(NULL, false); return Cache; };
|
|
inline pkgDepCache* GetDepCache() { BuildDepCache(); return DCache; };
|
|
inline pkgPolicy* GetPolicy() { BuildPolicy(); return Policy; };
|
|
inline pkgSourceList* GetSourceList() { BuildSourceList(); return SrcList; };
|
|
|
|
inline bool IsPkgCacheBuilt() const { return (Cache != NULL); };
|
|
inline bool IsDepCacheBuilt() const { return (DCache != NULL); };
|
|
inline bool IsPolicyBuilt() const { return (Policy != NULL); };
|
|
inline bool IsSrcListBuilt() const { return (SrcList != NULL); };
|
|
|
|
pkgCacheFile();
|
|
explicit pkgCacheFile(pkgDepCache * const Owner);
|
|
virtual ~pkgCacheFile();
|
|
};
|
|
|
|
#endif
|