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