blob: 5d4ba37d7535790b6542eba3ee5bebcd240e662f (
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
|
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: pkgrecords.h,v 1.6 2001/03/13 06:51:46 jgg Exp $
/* ######################################################################
Package Records - Allows access to complete package description records
directly from the file.
The package record system abstracts the actual parsing of the
package files. This is different than the generators parser in that
it is used to access information not generate information. No
information touched by the generator should be parable from here as
it can always be retrieved directly from the cache.
##################################################################### */
/*}}}*/
#ifndef PKGLIB_PKGRECORDS_H
#define PKGLIB_PKGRECORDS_H
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/hashes.h>
#include <apt-pkg/macros.h>
#include <string>
#include <vector>
class pkgRecords /*{{{*/
{
public:
class Parser;
private:
/** \brief dpointer placeholder (for later in case we need it) */
void * const d;
pkgCache &Cache;
std::vector<Parser *>Files;
public:
// Lookup function
Parser &Lookup(pkgCache::VerFileIterator const &Ver);
Parser &Lookup(pkgCache::DescFileIterator const &Desc);
// Construct destruct
explicit pkgRecords(pkgCache &Cache);
virtual ~pkgRecords();
};
/*}}}*/
class pkgRecords::Parser /*{{{*/
{
protected:
virtual bool Jump(pkgCache::VerFileIterator const &Ver) = 0;
virtual bool Jump(pkgCache::DescFileIterator const &Desc) = 0;
public:
friend class pkgRecords;
// These refer to the archive file for the Version
virtual std::string FileName() {return std::string();};
virtual std::string SourcePkg() {return std::string();};
virtual std::string SourceVer() {return std::string();};
/** return all known hashes in this record.
*
* For authentication proposes packages come with hashsums which
* this method is supposed to parse and return so that clients can
* choose the hash to be used.
*/
virtual HashStringList Hashes() const { return HashStringList(); };
APT_DEPRECATED_MSG("Use .Hashes instead of a hardcoded hash algorithm") std::string MD5Hash() const { return GetHashFromHashes("MD5Sum"); };
APT_DEPRECATED_MSG("Use .Hashes instead of a hardcoded hash algorithm") std::string SHA1Hash() const { return GetHashFromHashes("SHA1"); };
APT_DEPRECATED_MSG("Use .Hashes instead of a hardcoded hash algorithm") std::string SHA256Hash() const { return GetHashFromHashes("SHA256"); };
APT_DEPRECATED_MSG("Use .Hashes instead of a hardcoded hash algorithm") std::string SHA512Hash() const { return GetHashFromHashes("SHA512"); };
// These are some general stats about the package
virtual std::string Maintainer() {return std::string();};
/** return short description in language from record.
*
* @see #LongDesc
*/
virtual std::string ShortDesc(std::string const &/*lang*/) {return std::string();};
/** return long description in language from record.
*
* If \b lang is empty the "best" available language will be
* returned as determined by the APT::Languages configuration.
* If a (requested) language can't be found in this record an empty
* string will be returned.
*/
virtual std::string LongDesc(std::string const &/*lang*/) {return std::string();};
std::string ShortDesc() {return ShortDesc("");};
std::string LongDesc() {return LongDesc("");};
virtual std::string Name() {return std::string();};
virtual std::string Display() {return std::string();}
virtual std::string Homepage() {return std::string();}
// An arbitrary custom field
virtual std::string RecordField(const char * /*fieldName*/) { return std::string();};
// The record in binary form
virtual void GetRec(const char *&Start,const char *&Stop) {Start = Stop = 0;};
// Locate a tag
virtual bool Find(const char *Tag,const char *&Start, const char *&End) {Start = End = 0; return false;};
Parser();
virtual ~Parser();
private:
void * const d;
APT_HIDDEN std::string GetHashFromHashes(char const * const type) const
{
HashStringList const hashes = Hashes();
HashString const * const hs = hashes.find(type);
return hs != NULL ? hs->HashValue() : "";
};
};
/*}}}*/
#endif
|
