configuration.h
// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
/* ######################################################################
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 <iostream>
#include <string>
#include <string_view>
#include <vector>
#include <apt-pkg/macros.h>
class APT_PUBLIC 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 const_cast<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, std::string const &Default = "", bool const Keys = false) const;
std::vector<std::string> FindVector(std::string const &Name, std::string const &Default = "", bool const Keys = false) const { return FindVector(Name.c_str(), Default, Keys); };
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_view &Value) {Set(Name.c_str(),Value);};
void CndSet(const char *Name,const std::string_view &Value);
void CndSet(const char *Name,const int Value);
void Set(const char *Name,const std::string_view &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;
void MoveSubTree(char const * const OldRoot, char const * const NewRoot);
void MoveSubTree(char const *const OldRoot, char const *const NewRoot, bool Overwrite);
// clear a whole tree
void Clear(const std::string &Name);
void Clear();
// 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);
void Dump(std::ostream& str, char const * const root,
char const * const format, bool const emptyValue);
#ifdef APT_COMPILING_APT
bool SectionInSubTree(char const *const SubTree, std::string_view Needle);
#endif
explicit Configuration(const Item *Root);
Configuration();
~Configuration();
class MatchAgainstConfig
{
std::vector<regex_t *> patterns;
APT_HIDDEN void clearPatterns();
public:
explicit MatchAgainstConfig(char const * Config);
virtual ~MatchAgainstConfig();
bool Match(char const * str) const;
bool Match(std::string const &str) const { return Match(str.c_str()); };
bool wasConstructedSuccessfully() const { return patterns.empty() == false; }
};
};
APT_PUBLIC extern Configuration *_config;
APT_PUBLIC bool ReadConfigFile(Configuration &Conf,const std::string &FName,
bool const &AsSectional = false,
unsigned const &Depth = 0);
APT_PUBLIC bool ReadConfigDir(Configuration &Conf,const std::string &Dir,
bool const &AsSectional = false,
unsigned const &Depth = 0);
#endif
Configuration::MatchAgainstConfig::wasConstructedSuccessfully
bool wasConstructedSuccessfully() const
returns if the matcher setup was successful
Definition configuration.h:143
Configuration::MatchAgainstConfig::Match
bool Match(char const *str) const
Returns true for a string matching one of the patterns.
Definition configuration.cc:1228
Configuration
Definition configuration.h:41
Configuration::Item
Definition configuration.h:45