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);
 
   // 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