]>
Commit | Line | Data |
---|---|---|
1 | // -*- mode: cpp; mode: fold -*- | |
2 | // Description /*{{{*/ | |
3 | // $Id: configuration.h,v 1.16 2002/11/11 06:55:50 doogie Exp $ | |
4 | /* ###################################################################### | |
5 | ||
6 | Configuration Class | |
7 | ||
8 | This class provides a configuration file and command line parser | |
9 | for a tree-oriented configuration environment. All runtime configuration | |
10 | is stored in here. | |
11 | ||
12 | Each configuration name is given as a fully scoped string such as | |
13 | Foo::Bar | |
14 | And has associated with it a text string. The Configuration class only | |
15 | provides storage and lookup for this tree, other classes provide | |
16 | configuration file formats (and parsers/emitters if needed). | |
17 | ||
18 | Most things can get by quite happily with, | |
19 | cout << _config->Find("Foo::Bar") << endl; | |
20 | ||
21 | A special extension, support for ordered lists is provided by using the | |
22 | special syntax, "block::list::" the trailing :: designates the | |
23 | item as a list. To access the list you must use the tree function on | |
24 | "block::list". | |
25 | ||
26 | ##################################################################### */ | |
27 | /*}}}*/ | |
28 | #ifndef PKGLIB_CONFIGURATION_H | |
29 | #define PKGLIB_CONFIGURATION_H | |
30 | ||
31 | #include <regex.h> | |
32 | ||
33 | #include <string> | |
34 | #include <vector> | |
35 | #include <iostream> | |
36 | ||
37 | #ifndef APT_8_CLEANER_HEADERS | |
38 | using std::string; | |
39 | #endif | |
40 | ||
41 | class Configuration | |
42 | { | |
43 | public: | |
44 | ||
45 | struct Item | |
46 | { | |
47 | std::string Value; | |
48 | std::string Tag; | |
49 | Item *Parent; | |
50 | Item *Child; | |
51 | Item *Next; | |
52 | ||
53 | std::string FullTag(const Item *Stop = 0) const; | |
54 | ||
55 | Item() : Parent(0), Child(0), Next(0) {}; | |
56 | }; | |
57 | ||
58 | private: | |
59 | ||
60 | Item *Root; | |
61 | bool ToFree; | |
62 | ||
63 | Item *Lookup(Item *Head,const char *S,unsigned long const &Len,bool const &Create); | |
64 | Item *Lookup(const char *Name,const bool &Create); | |
65 | inline const Item *Lookup(const char *Name) const | |
66 | { | |
67 | return ((Configuration *)this)->Lookup(Name,false); | |
68 | } | |
69 | ||
70 | public: | |
71 | ||
72 | std::string Find(const char *Name,const char *Default = 0) const; | |
73 | std::string Find(std::string const &Name,const char *Default = 0) const {return Find(Name.c_str(),Default);}; | |
74 | std::string Find(std::string const &Name, std::string const &Default) const {return Find(Name.c_str(),Default.c_str());}; | |
75 | std::string FindFile(const char *Name,const char *Default = 0) const; | |
76 | std::string FindDir(const char *Name,const char *Default = 0) const; | |
77 | std::vector<std::string> FindVector(const char *Name) const; | |
78 | std::vector<std::string> FindVector(std::string const &Name) const { return FindVector(Name.c_str()); }; | |
79 | int FindI(const char *Name,int const &Default = 0) const; | |
80 | int FindI(std::string const &Name,int const &Default = 0) const {return FindI(Name.c_str(),Default);}; | |
81 | bool FindB(const char *Name,bool const &Default = false) const; | |
82 | bool FindB(std::string const &Name,bool const &Default = false) const {return FindB(Name.c_str(),Default);}; | |
83 | std::string FindAny(const char *Name,const char *Default = 0) const; | |
84 | ||
85 | inline void Set(const std::string &Name,const std::string &Value) {Set(Name.c_str(),Value);}; | |
86 | void CndSet(const char *Name,const std::string &Value); | |
87 | void CndSet(const char *Name,const int Value); | |
88 | void Set(const char *Name,const std::string &Value); | |
89 | void Set(const char *Name,const int &Value); | |
90 | ||
91 | inline bool Exists(const std::string &Name) const {return Exists(Name.c_str());}; | |
92 | bool Exists(const char *Name) const; | |
93 | bool ExistsAny(const char *Name) const; | |
94 | ||
95 | // clear a whole tree | |
96 | void Clear(const std::string &Name); | |
97 | void Clear(); | |
98 | ||
99 | // remove a certain value from a list (e.g. the list of "APT::Keep-Fds") | |
100 | void Clear(std::string const &List, std::string const &Value); | |
101 | void Clear(std::string const &List, int const &Value); | |
102 | ||
103 | inline const Item *Tree(const char *Name) const {return Lookup(Name);}; | |
104 | ||
105 | inline void Dump() { Dump(std::clog); }; | |
106 | void Dump(std::ostream& str); | |
107 | ||
108 | Configuration(const Item *Root); | |
109 | Configuration(); | |
110 | ~Configuration(); | |
111 | ||
112 | /** \brief match a string against a configurable list of patterns */ | |
113 | class MatchAgainstConfig | |
114 | { | |
115 | std::vector<regex_t *> patterns; | |
116 | void clearPatterns(); | |
117 | ||
118 | public: | |
119 | MatchAgainstConfig(char const * Config); | |
120 | virtual ~MatchAgainstConfig(); | |
121 | ||
122 | /** \brief Returns \b true for a string matching one of the patterns */ | |
123 | bool Match(char const * str) const; | |
124 | bool Match(std::string const &str) const { return Match(str.c_str()); }; | |
125 | ||
126 | /** \brief returns if the matcher setup was successful */ | |
127 | bool wasConstructedSuccessfully() const { return patterns.empty() == false; } | |
128 | }; | |
129 | }; | |
130 | ||
131 | extern Configuration *_config; | |
132 | ||
133 | bool ReadConfigFile(Configuration &Conf,const std::string &FName, | |
134 | bool const &AsSectional = false, | |
135 | unsigned const &Depth = 0); | |
136 | ||
137 | bool ReadConfigDir(Configuration &Conf,const std::string &Dir, | |
138 | bool const &AsSectional = false, | |
139 | unsigned const &Depth = 0); | |
140 | ||
141 | #endif |