]>
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 | using std::string; | |
38 | ||
39 | class Configuration | |
40 | { | |
41 | public: | |
42 | ||
43 | struct Item | |
44 | { | |
45 | string Value; | |
46 | string Tag; | |
47 | Item *Parent; | |
48 | Item *Child; | |
49 | Item *Next; | |
50 | ||
51 | string FullTag(const Item *Stop = 0) const; | |
52 | ||
53 | Item() : Parent(0), Child(0), Next(0) {}; | |
54 | }; | |
55 | ||
56 | private: | |
57 | ||
58 | Item *Root; | |
59 | bool ToFree; | |
60 | ||
61 | Item *Lookup(Item *Head,const char *S,unsigned long const &Len,bool const &Create); | |
62 | Item *Lookup(const char *Name,const bool &Create); | |
63 | inline const Item *Lookup(const char *Name) const | |
64 | { | |
65 | return ((Configuration *)this)->Lookup(Name,false); | |
66 | } | |
67 | ||
68 | public: | |
69 | ||
70 | string Find(const char *Name,const char *Default = 0) const; | |
71 | string Find(string const &Name,const char *Default = 0) const {return Find(Name.c_str(),Default);}; | |
72 | string Find(string const &Name, string const &Default) const {return Find(Name.c_str(),Default.c_str());}; | |
73 | string FindFile(const char *Name,const char *Default = 0) const; | |
74 | string FindDir(const char *Name,const char *Default = 0) const; | |
75 | std::vector<string> FindVector(const char *Name) const; | |
76 | std::vector<string> FindVector(string const &Name) const { return FindVector(Name.c_str()); }; | |
77 | int FindI(const char *Name,int const &Default = 0) const; | |
78 | int FindI(string const &Name,int const &Default = 0) const {return FindI(Name.c_str(),Default);}; | |
79 | bool FindB(const char *Name,bool const &Default = false) const; | |
80 | bool FindB(string const &Name,bool const &Default = false) const {return FindB(Name.c_str(),Default);}; | |
81 | string FindAny(const char *Name,const char *Default = 0) const; | |
82 | ||
83 | inline void Set(const string &Name,const string &Value) {Set(Name.c_str(),Value);}; | |
84 | void CndSet(const char *Name,const string &Value); | |
85 | void Set(const char *Name,const string &Value); | |
86 | void Set(const char *Name,const int &Value); | |
87 | ||
88 | inline bool Exists(const string &Name) const {return Exists(Name.c_str());}; | |
89 | bool Exists(const char *Name) const; | |
90 | bool ExistsAny(const char *Name) const; | |
91 | ||
92 | // clear a whole tree | |
93 | void Clear(const string &Name); | |
94 | ||
95 | // remove a certain value from a list (e.g. the list of "APT::Keep-Fds") | |
96 | void Clear(string const &List, string const &Value); | |
97 | void Clear(string const &List, int const &Value); | |
98 | ||
99 | inline const Item *Tree(const char *Name) const {return Lookup(Name);}; | |
100 | ||
101 | inline void Dump() { Dump(std::clog); }; | |
102 | void Dump(std::ostream& str); | |
103 | ||
104 | Configuration(const Item *Root); | |
105 | Configuration(); | |
106 | ~Configuration(); | |
107 | ||
108 | /** \brief match a string against a configurable list of patterns */ | |
109 | class MatchAgainstConfig | |
110 | { | |
111 | std::vector<regex_t *> patterns; | |
112 | void clearPatterns(); | |
113 | ||
114 | public: | |
115 | MatchAgainstConfig(char const * Config); | |
116 | virtual ~MatchAgainstConfig(); | |
117 | ||
118 | /** \brief Returns \b true for a string matching one of the patterns */ | |
119 | bool Match(char const * str) const; | |
120 | bool Match(std::string const &str) const { return Match(str.c_str()); }; | |
121 | ||
122 | /** \brief returns if the matcher setup was successful */ | |
123 | bool wasConstructedSuccessfully() const { return patterns.empty() == false; } | |
124 | }; | |
125 | }; | |
126 | ||
127 | extern Configuration *_config; | |
128 | ||
129 | bool ReadConfigFile(Configuration &Conf,const string &FName, | |
130 | bool const &AsSectional = false, | |
131 | unsigned const &Depth = 0); | |
132 | ||
133 | bool ReadConfigDir(Configuration &Conf,const string &Dir, | |
134 | bool const &AsSectional = false, | |
135 | unsigned const &Depth = 0); | |
136 | ||
137 | #endif |