/usr/include/apt-pkg/configuration.h is in libapt-pkg-dev 0.8.16~exp12ubuntu10.21.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 | // -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
// $Id: configuration.h,v 1.16 2002/11/11 06:55:50 doogie Exp $
/* ######################################################################
Configuration Class
This class provides a configuration file and command line parser
for a tree-oriented configuration environment. All runtime configuration
is stored in here.
Each configuration name is given as a fully scoped string such as
Foo::Bar
And has associated with it a text string. The Configuration class only
provides storage and lookup for this tree, other classes provide
configuration file formats (and parsers/emitters if needed).
Most things can get by quite happily with,
cout << _config->Find("Foo::Bar") << endl;
A special extension, support for ordered lists is provided by using the
special syntax, "block::list::" the trailing :: designates the
item as a list. To access the list you must use the tree function on
"block::list".
##################################################################### */
/*}}}*/
#ifndef PKGLIB_CONFIGURATION_H
#define PKGLIB_CONFIGURATION_H
#include <regex.h>
#include <string>
#include <vector>
#include <iostream>
#ifndef APT_8_CLEANER_HEADERS
using std::string;
#endif
class Configuration
{
public:
struct Item
{
std::string Value;
std::string Tag;
Item *Parent;
Item *Child;
Item *Next;
std::string FullTag(const Item *Stop = 0) const;
Item() : Parent(0), Child(0), Next(0) {};
};
private:
Item *Root;
bool ToFree;
Item *Lookup(Item *Head,const char *S,unsigned long const &Len,bool const &Create);
Item *Lookup(const char *Name,const bool &Create);
inline const Item *Lookup(const char *Name) const
{
return ((Configuration *)this)->Lookup(Name,false);
}
public:
std::string Find(const char *Name,const char *Default = 0) const;
std::string Find(std::string const &Name,const char *Default = 0) const {return Find(Name.c_str(),Default);};
std::string Find(std::string const &Name, std::string const &Default) const {return Find(Name.c_str(),Default.c_str());};
std::string FindFile(const char *Name,const char *Default = 0) const;
std::string FindDir(const char *Name,const char *Default = 0) const;
std::vector<std::string> FindVector(const char *Name) const;
std::vector<std::string> FindVector(std::string const &Name) const { return FindVector(Name.c_str()); };
int FindI(const char *Name,int const &Default = 0) const;
int FindI(std::string const &Name,int const &Default = 0) const {return FindI(Name.c_str(),Default);};
bool FindB(const char *Name,bool const &Default = false) const;
bool FindB(std::string const &Name,bool const &Default = false) const {return FindB(Name.c_str(),Default);};
std::string FindAny(const char *Name,const char *Default = 0) const;
inline void Set(const std::string &Name,const std::string &Value) {Set(Name.c_str(),Value);};
void CndSet(const char *Name,const std::string &Value);
void CndSet(const char *Name,const int Value);
void Set(const char *Name,const std::string &Value);
void Set(const char *Name,const int &Value);
inline bool Exists(const std::string &Name) const {return Exists(Name.c_str());};
bool Exists(const char *Name) const;
bool ExistsAny(const char *Name) const;
// clear a whole tree
void Clear(const std::string &Name);
// remove a certain value from a list (e.g. the list of "APT::Keep-Fds")
void Clear(std::string const &List, std::string const &Value);
void Clear(std::string const &List, int const &Value);
inline const Item *Tree(const char *Name) const {return Lookup(Name);};
inline void Dump() { Dump(std::clog); };
void Dump(std::ostream& str);
Configuration(const Item *Root);
Configuration();
~Configuration();
/** \brief match a string against a configurable list of patterns */
class MatchAgainstConfig
{
std::vector<regex_t *> patterns;
void clearPatterns();
public:
MatchAgainstConfig(char const * Config);
virtual ~MatchAgainstConfig();
/** \brief Returns \b true for a string matching one of the patterns */
bool Match(char const * str) const;
bool Match(std::string const &str) const { return Match(str.c_str()); };
/** \brief returns if the matcher setup was successful */
bool wasConstructedSuccessfully() const { return patterns.empty() == false; }
};
};
extern Configuration *_config;
bool ReadConfigFile(Configuration &Conf,const std::string &FName,
bool const &AsSectional = false,
unsigned const &Depth = 0);
bool ReadConfigDir(Configuration &Conf,const std::string &Dir,
bool const &AsSectional = false,
unsigned const &Depth = 0);
#endif
|