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