apt-pkg/indexfile.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    Index File - Abstraction for an index of archive/source file.
   6
   7    There are 4 primary sorts of index files, all represented by this
   8    class:
   9
  10    Binary index files
  11    Binary translation files
  12    Binary index files describing the local system
  13    Source index files
  14
  15    They are all bundled together here, and the interfaces for
  16    sources.list, acquire, cache gen and record parsing all use this class
  17    to access the underlying representation.
  18
  19    ##################################################################### */
  20                                                                         /*}}}*/
  21 #ifndef PKGLIB_INDEXFILE_H
  22 #define PKGLIB_INDEXFILE_H
  23
  24 #include <apt-pkg/srcrecords.h>
  25 #include <apt-pkg/pkgrecords.h>
  26 #include <apt-pkg/pkgcache.h>
  27 #include <apt-pkg/cacheiterators.h>
  28 #include <apt-pkg/macros.h>
  29
  30 #include <map>
  31 #include <string>
  32
  33 #ifndef APT_8_CLEANER_HEADERS
  34 using std::string;
  35 #endif
  36 #ifndef APT_10_CLEANER_HEADERS
  37 class pkgAcquire;
  38 #endif
  39
  40 class pkgCacheGenerator;
  41 class pkgCacheListParser;
  42 class OpProgress;
  43
  44 class IndexTarget                                                       /*{{{*/
  45 /** \brief Information about an index file. */
  46 {
  47    public:
  48    /** \brief A URI from which the index file can be downloaded. */
  49    std::string URI;
  50
  51    /** \brief A description of the index file. */
  52    std::string Description;
  53
  54    /** \brief A shorter description of the index file. */
  55    std::string ShortDesc;
  56
  57    /** \brief The key by which this index file should be
  58        looked up within the meta index file. */
  59    std::string MetaKey;
  60
  61    /** \brief Is it okay if the file isn't found in the meta index */
  62    bool IsOptional;
  63
  64    /** \brief If the file is downloaded compressed, do not unpack it */
  65    bool KeepCompressed;
  66
  67    /** \brief options with which this target was created
  68        Prefer the usage of #Option if at all possible.
  69        Beware: Not all of these options are intended for public use */
  70    std::map<std::string, std::string> Options;
  71
  72    IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
  73          std::string const &LongDesc, std::string const &URI, bool const IsOptional,
  74          bool const KeepCompressed, std::map<std::string, std::string> const &Options);
  75
  76    enum OptionKeys {
  77       SITE,
  78       RELEASE,
  79       COMPONENT,
  80       LANGUAGE,
  81       ARCHITECTURE,
  82       BASE_URI,
  83       REPO_URI,
  84       CREATED_BY,
  85       TARGET_OF,
  86       FILENAME,
  87       EXISTING_FILENAME,
  88       PDIFFS,
  89       COMPRESSIONTYPES,
  90       DEFAULTENABLED,
  91       SOURCESENTRY,
  92       BY_HASH,
  93    };
  94    std::string Option(OptionKeys const Key) const;
  95    bool OptionBool(OptionKeys const Key) const;
  96    std::string Format(std::string format) const;
  97 };
  98                                                                         /*}}}*/
  99
 100 class pkgIndexFile
 101 {
 102    void * const d;
 103    protected:
 104    bool Trusted;
 105
 106    public:
 107
 108    class Type
 109    {
 110       public:
 111
 112       // Global list of Items supported
 113       static Type **GlobalList;
 114       static unsigned long GlobalListLen;
 115       static Type *GetType(const char * const Type) APT_PURE;
 116
 117       const char *Label;
 118
 119       virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &/*File*/) const {return 0;};
 120       virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &/*File*/) const {return 0;};
 121       Type();
 122       virtual ~Type() {};
 123    };
 124
 125    virtual const Type *GetType() const = 0;
 126
 127    // Return descriptive strings of various sorts
 128    virtual std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const;
 129    virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
 130                              pkgSrcRecords::File const &File) const;
 131    virtual std::string Describe(bool const Short = false) const = 0;
 132
 133    // Interface for acquire
 134    virtual std::string ArchiveURI(std::string const &/*File*/) const {return std::string();};
 135
 136    // Interface for the record parsers
 137    virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
 138
 139    // Interface for the Cache Generator
 140    virtual bool Exists() const = 0;
 141    virtual bool HasPackages() const = 0;
 142    virtual unsigned long Size() const = 0;
 143    virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* const /*Prog*/) { return true; };
 144    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
 145
 146    static bool TranslationsAvailable();
 147    static bool CheckLanguageCode(const char * const Lang);
 148    static std::string LanguageCode();
 149
 150    bool IsTrusted() const { return Trusted; };
 151
 152    explicit pkgIndexFile(bool const Trusted);
 153    virtual ~pkgIndexFile();
 154 };
 155
 156 class pkgDebianIndexFile : public pkgIndexFile
 157 {
 158 protected:
 159    virtual std::string IndexFileName() const = 0;
 160    virtual std::string GetComponent() const = 0;
 161    virtual std::string GetArchitecture() const = 0;
 162    virtual std::string GetProgressDescription() const = 0;
 163    virtual uint8_t GetIndexFlags() const = 0;
 164    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) = 0;
 165    APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg);
 166
 167 public:
 168    virtual bool Merge(pkgCacheGenerator &Gen, OpProgress* const Prog) APT_OVERRIDE;
 169    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
 170
 171    explicit pkgDebianIndexFile(bool const Trusted);
 172    virtual ~pkgDebianIndexFile();
 173 };
 174
 175 class pkgDebianIndexTargetFile : public pkgDebianIndexFile
 176 {
 177    void * const d;
 178 protected:
 179    IndexTarget const Target;
 180
 181    virtual std::string IndexFileName() const APT_OVERRIDE;
 182    virtual std::string GetComponent() const APT_OVERRIDE;
 183    virtual std::string GetArchitecture() const APT_OVERRIDE;
 184    virtual std::string GetProgressDescription() const APT_OVERRIDE;
 185    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
 186
 187 public:
 188    virtual std::string ArchiveURI(std::string const &File) const APT_OVERRIDE;
 189    virtual std::string Describe(bool const Short = false) const APT_OVERRIDE;
 190    virtual bool Exists() const APT_OVERRIDE;
 191    virtual unsigned long Size() const APT_OVERRIDE;
 192
 193    pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted);
 194    virtual ~pkgDebianIndexTargetFile();
 195 };
 196
 197 class pkgDebianIndexRealFile : public pkgDebianIndexFile
 198 {
 199    void * const d;
 200 protected:
 201    std::string File;
 202
 203    virtual std::string IndexFileName() const APT_OVERRIDE;
 204    virtual std::string GetProgressDescription() const APT_OVERRIDE;
 205    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
 206 public:
 207    virtual std::string Describe(bool const /*Short*/ = false) const APT_OVERRIDE;
 208    virtual bool Exists() const APT_OVERRIDE;
 209    virtual unsigned long Size() const APT_OVERRIDE;
 210    virtual std::string ArchiveURI(std::string const &/*File*/) const APT_OVERRIDE;
 211
 212    pkgDebianIndexRealFile(std::string const &File, bool const Trusted);
 213    virtual ~pkgDebianIndexRealFile();
 214 };
 215
 216 #endif