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 OpProgress;
  42
  43 class IndexTarget                                                       /*{{{*/
  44 /** \brief Information about an index file. */
  45 {
  46    public:
  47    /** \brief A URI from which the index file can be downloaded. */
  48    std::string URI;
  49
  50    /** \brief A description of the index file. */
  51    std::string Description;
  52
  53    /** \brief A shorter description of the index file. */
  54    std::string ShortDesc;
  55
  56    /** \brief The key by which this index file should be
  57        looked up within the meta index file. */
  58    std::string MetaKey;
  59
  60    /** \brief Is it okay if the file isn't found in the meta index */
  61    bool IsOptional;
  62
  63    /** \brief options with which this target was created
  64        Prefer the usage of #Option if at all possible.
  65        Beware: Not all of these options are intended for public use */
  66    std::map<std::string, std::string> Options;
  67
  68    IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
  69          std::string const &LongDesc, std::string const &URI, bool const IsOptional,
  70          std::map<std::string, std::string> const &Options);
  71
  72    enum OptionKeys {
  73       SITE,
  74       RELEASE,
  75       COMPONENT,
  76       LANGUAGE,
  77       ARCHITECTURE,
  78       BASE_URI,
  79       REPO_URI,
  80       CREATED_BY,
  81       TARGET_OF,
  82       FILENAME,
  83       EXISTING_FILENAME,
  84    };
  85    std::string Option(OptionKeys const Key) const;
  86    std::string Format(std::string format) const;
  87 };
  88                                                                         /*}}}*/
  89
  90 class pkgIndexFile
  91 {
  92    void * const d;
  93    protected:
  94    bool Trusted;
  95
  96    public:
  97
  98    class Type
  99    {
 100       public:
 101
 102       // Global list of Items supported
 103       static Type **GlobalList;
 104       static unsigned long GlobalListLen;
 105       static Type *GetType(const char *Type) APT_PURE;
 106
 107       const char *Label;
 108
 109       virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator /*File*/) const {return 0;};
 110       virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string /*File*/) const {return 0;};
 111       Type();
 112       virtual ~Type() {};
 113    };
 114
 115    virtual const Type *GetType() const = 0;
 116
 117    // Return descriptive strings of various sorts
 118    virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const;
 119    virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
 120                              pkgSrcRecords::File const &File) const;
 121    virtual std::string Describe(bool Short = false) const = 0;
 122
 123    // Interface for acquire
 124    virtual std::string ArchiveURI(std::string /*File*/) const {return std::string();};
 125
 126    // Interface for the record parsers
 127    virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
 128
 129    // Interface for the Cache Generator
 130    virtual bool Exists() const = 0;
 131    virtual bool HasPackages() const = 0;
 132    virtual unsigned long Size() const = 0;
 133    virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* /*Prog*/) const { return false; };
 134    APT_DEPRECATED virtual bool Merge(pkgCacheGenerator &Gen, OpProgress &Prog) const
 135       { return Merge(Gen, &Prog); };
 136    virtual bool MergeFileProvides(pkgCacheGenerator &/*Gen*/,OpProgress* /*Prog*/) const {return true;};
 137    APT_DEPRECATED virtual bool MergeFileProvides(pkgCacheGenerator &Gen, OpProgress &Prog) const
 138       {return MergeFileProvides(Gen, &Prog);};
 139    virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;
 140
 141    static bool TranslationsAvailable();
 142    static bool CheckLanguageCode(const char *Lang);
 143    static std::string LanguageCode();
 144
 145    bool IsTrusted() const { return Trusted; };
 146
 147    explicit pkgIndexFile(bool Trusted);
 148    virtual ~pkgIndexFile();
 149 };
 150
 151 class pkgIndexTargetFile : public pkgIndexFile
 152 {
 153    void * const d;
 154 protected:
 155    IndexTarget const Target;
 156
 157    std::string IndexFileName() const;
 158
 159 public:
 160    virtual std::string ArchiveURI(std::string File) const;
 161    virtual std::string Describe(bool Short = false) const;
 162    virtual bool Exists() const;
 163    virtual unsigned long Size() const;
 164
 165    pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted);
 166    virtual ~pkgIndexTargetFile();
 167 };
 168
 169 #endif