summaryrefslogtreecommitdiff
path: root/apt-pkg/indexfile.h
blob: 220c415acb7dbb07b5db3bcd7fbf7a2668ff1360 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: indexfile.h,v 1.6.2.1 2003/12/24 23:09:17 mdz Exp $
/* ######################################################################

   Index File - Abstraction for an index of archive/source file.
   
   There are 4 primary sorts of index files, all represented by this 
   class:
   
   Binary index files 
   Binary translation files 
   Binary index files describing the local system
   Source index files
   
   They are all bundled together here, and the interfaces for 
   sources.list, acquire, cache gen and record parsing all use this class
   to access the underlying representation.
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_INDEXFILE_H
#define PKGLIB_INDEXFILE_H

#include <apt-pkg/srcrecords.h>
#include <apt-pkg/pkgrecords.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/macros.h>

#include <map>
#include <string>

#ifndef APT_8_CLEANER_HEADERS
using std::string;
#endif
#ifndef APT_10_CLEANER_HEADERS
class pkgAcquire;
#endif

class pkgCacheGenerator;
class OpProgress;

class IndexTarget							/*{{{*/
/** \brief Information about an index file. */
{
   public:
   /** \brief A URI from which the index file can be downloaded. */
   std::string URI;

   /** \brief A description of the index file. */
   std::string Description;

   /** \brief A shorter description of the index file. */
   std::string ShortDesc;

   /** \brief The key by which this index file should be
       looked up within the meta index file. */
   std::string MetaKey;

   /** \brief Is it okay if the file isn't found in the meta index */
   bool IsOptional;

   /** \brief options with which this target was created
       Prefer the usage of #Option if at all possible.
       Beware: Not all of these options are intended for public use */
   std::map<std::string, std::string> Options;

   IndexTarget(std::string const &MetaKey, std::string const &ShortDesc,
	 std::string const &LongDesc, std::string const &URI, bool const IsOptional,
	 std::map<std::string, std::string> const &Options);

   enum OptionKeys {
      SITE,
      RELEASE,
      COMPONENT,
      LANGUAGE,
      ARCHITECTURE,
      BASE_URI,
      REPO_URI,
      CREATED_BY,
      TARGET_OF,
      FILENAME,
   };
   std::string Option(OptionKeys const Key) const;
   std::string Format(std::string format) const;
};
									/*}}}*/

class pkgIndexFile
{
   protected:
   bool Trusted;

   public:

   class Type
   {
      public:

      // Global list of Items supported
      static Type **GlobalList;
      static unsigned long GlobalListLen;
      static Type *GetType(const char *Type) APT_PURE;

      const char *Label;

      virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator /*File*/) const {return 0;};
      virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string /*File*/) const {return 0;};
      Type();
      virtual ~Type() {};
   };

   virtual const Type *GetType() const = 0;
   
   // Return descriptive strings of various sorts
   virtual std::string ArchiveInfo(pkgCache::VerIterator Ver) const;
   virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
			     pkgSrcRecords::File const &File) const;
   virtual std::string Describe(bool Short = false) const = 0;

   // Interface for acquire
   virtual std::string ArchiveURI(std::string /*File*/) const {return std::string();};

   // Interface for the record parsers
   virtual pkgSrcRecords::Parser *CreateSrcParser() const {return 0;};
   
   // Interface for the Cache Generator
   virtual bool Exists() const = 0;
   virtual bool HasPackages() const = 0;
   virtual unsigned long Size() const = 0;
   virtual bool Merge(pkgCacheGenerator &/*Gen*/, OpProgress* /*Prog*/) const { return false; };
   APT_DEPRECATED virtual bool Merge(pkgCacheGenerator &Gen, OpProgress &Prog) const
      { return Merge(Gen, &Prog); };
   virtual bool MergeFileProvides(pkgCacheGenerator &/*Gen*/,OpProgress* /*Prog*/) const {return true;};
   APT_DEPRECATED virtual bool MergeFileProvides(pkgCacheGenerator &Gen, OpProgress &Prog) const
      {return MergeFileProvides(Gen, &Prog);};
   virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const;

   static bool TranslationsAvailable();
   static bool CheckLanguageCode(const char *Lang);
   static std::string LanguageCode();

   bool IsTrusted() const { return Trusted; };

   pkgIndexFile(bool Trusted);
   virtual ~pkgIndexFile() {};
};

class pkgIndexTargetFile : public pkgIndexFile
{
protected:
   IndexTarget const Target;

   std::string IndexFileName() const;

public:
   virtual std::string ArchiveURI(std::string File) const;
   virtual std::string Describe(bool Short = false) const;
   virtual bool Exists() const;
   virtual unsigned long Size() const;

   pkgIndexTargetFile(IndexTarget const &Target, bool const Trusted);
};

#endif