File: sourcelist.h

package info (click to toggle)
apt 1.0.9.8.4
  • links: PTS, VCS
  • area: main
  • in suites: jessie
  • size: 15,080 kB
  • ctags: 5,307
  • sloc: cpp: 50,972; sh: 12,111; xml: 4,130; makefile: 855; perl: 209; python: 28
file content (124 lines) | stat: -rw-r--r-- 3,568 bytes parent folder | download | duplicates (2)
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
// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: sourcelist.h,v 1.12.2.1 2003/12/24 23:09:17 mdz Exp $
/* ######################################################################

   SourceList - Manage a list of sources
   
   The Source List class provides access to a list of sources. It 
   can read them from a file and generate a list of all the distinct
   sources.
   
   All sources have a type associated with them that defines the layout
   of the archive. The exact format of the file is documented in
   files.sgml.

   The types are mapped through a list of type definitions which handle
   the actual construction of the back end type. After loading a source 
   list all you have is a list of package index files that have the ability
   to be Acquired.
   
   The vendor machanism is similar, except the vendor types are hard 
   wired. Before loading the source list the vendor list is loaded.
   This doesn't load key data, just the checks to perform.
   
   ##################################################################### */
									/*}}}*/
#ifndef PKGLIB_SOURCELIST_H
#define PKGLIB_SOURCELIST_H

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

#include <time.h>

#include <string>
#include <vector>
#include <map>

#ifndef APT_8_CLEANER_HEADERS
#include <apt-pkg/tagfile.h>
#endif
#ifndef APT_8_CLEANER_HEADERS
#include <apt-pkg/metaindex.h>
using std::string;
using std::vector;
#endif

class FileFd;
class pkgTagSection;
class pkgAcquire;
class pkgIndexFile;
class metaIndex;

class pkgSourceList
{
   public:
   
   // List of supported source list types
   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 *Name;
      const char *Label;

      bool FixupURI(std::string &URI) const;
      virtual bool ParseStanza(std::vector<metaIndex *> &List,
                               pkgTagSection &Tags,
                               int stanza_n,
                               FileFd &Fd);
      virtual bool ParseLine(std::vector<metaIndex *> &List,
			     const char *Buffer,
			     unsigned long const &CurLine,std::string const &File) const;
      virtual bool CreateItem(std::vector<metaIndex *> &List,std::string const &URI,
			      std::string const &Dist,std::string const &Section,
			      std::map<std::string, std::string> const &Options) const = 0;
      Type();
      virtual ~Type() {};
   };
   
   typedef std::vector<metaIndex *>::const_iterator const_iterator;
   
   protected:

   std::vector<metaIndex *> SrcList;

   int ParseFileDeb822(std::string File);
   bool ParseFileOldStyle(std::string File);

   public:

   bool ReadMainList();
   bool Read(std::string File);

   // CNC:2003-03-03
   void Reset();
   bool ReadAppend(std::string File);
   bool ReadSourceDir(std::string Dir);
   
   // List accessors
   inline const_iterator begin() const {return SrcList.begin();};
   inline const_iterator end() const {return SrcList.end();};
   inline unsigned int size() const {return SrcList.size();};
   inline bool empty() const {return SrcList.empty();};

   bool FindIndex(pkgCache::PkgFileIterator File,
		  pkgIndexFile *&Found) const;
   bool GetIndexes(pkgAcquire *Owner, bool GetAll=false) const;
   
   // query last-modified time
   time_t GetLastModifiedTime();

   pkgSourceList();
   pkgSourceList(std::string File);
   ~pkgSourceList();      
};

#endif