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    };
  91    std::string Option(OptionKeys const Key) const;
  92    bool OptionBool(OptionKeys const Key) const;
  93    std::string Format(std::string format) const;
  94 };
  95                                                                         /*}}}*/
  96
  97 class pkgIndexFile
  98 {
  99    void * const d;
 100    protected:
 101    bool Trusted;
 102
 103    public:
 104
 105    class Type
 106    {
 107       public:
 108
 109       // Global list of Items supported
 110       static Type **GlobalList;
 111       static unsigned long GlobalListLen;
 112       static Type *GetType(const char * const Type) APT_PURE;
 113
 114       const char *Label;
 115
 116       virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &/*File*/) const {return 0;};
 117       virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &/*File*/) const {return 0;};
 118       Type();
 119       virtual ~Type() {};
 120    };
 121
 122    virtual const Type *GetType() const = 0;
 123
 124    // Return descriptive strings of various sorts
 125    virtual std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const;
 126    virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
 127                              pkgSrcRecords::File const &File) const;
 128    virtual std::string Describe(bool const Short = false) const = 0;
 129
 130    // Interface for acquire
 131    virtual std::string ArchiveURI(std::string const &/*File*/) const {return std::string();};
 132
 133    // Interface for the record parsers
 134    virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
 135
 136    // Interface for the Cache Generator
 137    virtual bool Exists() const = 0;
 138    virtual bool HasPackages() const = 0;
 139    virtual unsigned long Size() const = 0;
 140    virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* const /*Prog*/) { return true; };
 141    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
 142
 143    static bool TranslationsAvailable();
 144    static bool CheckLanguageCode(const char * const Lang);
 145    static std::string LanguageCode();
 146
 147    bool IsTrusted() const { return Trusted; };
 148
 149    explicit pkgIndexFile(bool const Trusted);
 150    virtual ~pkgIndexFile();
 151 };
 152
 153 class pkgDebianIndexFile : public pkgIndexFile
 154 {
 155 protected:
 156    virtual std::string IndexFileName() const = 0;
 157    virtual std::string GetComponent() const = 0;
 158    virtual std::string GetArchitecture() const = 0;
 159    virtual std::string GetProgressDescription() const = 0;
 160    virtual uint8_t GetIndexFlags() const = 0;
 161    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) = 0;
 162    APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg);
 163
 164 public:
 165    virtual bool Merge(pkgCacheGenerator &Gen, OpProgress* const Prog) APT_OVERRIDE;
 166    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
 167
 168    pkgDebianIndexFile(bool const Trusted);
 169    virtual ~pkgDebianIndexFile();
 170 };
 171
 172 class pkgDebianIndexTargetFile : public pkgDebianIndexFile
 173 {
 174    void * const d;
 175 protected:
 176    IndexTarget const Target;
 177
 178    virtual std::string IndexFileName() const APT_OVERRIDE;
 179    virtual std::string GetComponent() const APT_OVERRIDE;
 180    virtual std::string GetArchitecture() const APT_OVERRIDE;
 181    virtual std::string GetProgressDescription() const APT_OVERRIDE;
 182    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
 183
 184 public:
 185    virtual std::string ArchiveURI(std::string const &File) const APT_OVERRIDE;
 186    virtual std::string Describe(bool const Short = false) const APT_OVERRIDE;
 187    virtual bool Exists() const APT_OVERRIDE;
 188    virtual unsigned long Size() const APT_OVERRIDE;
 189
 190    pkgDebianIndexTargetFile(IndexTarget const &Target, bool const Trusted);
 191    virtual ~pkgDebianIndexTargetFile();
 192 };
 193
 194 class pkgDebianIndexRealFile : public pkgDebianIndexFile
 195 {
 196    void * const d;
 197 protected:
 198    std::string File;
 199
 200    virtual std::string IndexFileName() const APT_OVERRIDE;
 201    virtual std::string GetProgressDescription() const APT_OVERRIDE;
 202    virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
 203 public:
 204    virtual std::string Describe(bool const /*Short*/ = false) const APT_OVERRIDE;
 205    virtual bool Exists() const APT_OVERRIDE;
 206    virtual unsigned long Size() const APT_OVERRIDE;
 207    virtual std::string ArchiveURI(std::string const &/*File*/) const APT_OVERRIDE;
 208
 209    pkgDebianIndexRealFile(std::string const &File, bool const Trusted);
 210    virtual ~pkgDebianIndexRealFile();
 211 };
 212
 213 #endif