AsyncConfig.h

Go to the documentation of this file.

 
#ifndef ASYNC_CONFIG_INCLUDED
#define ASYNC_CONFIG_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <stdio.h>
#include <sigc++/sigc++.h>
 
#include <string>
#include <map>
#include <list>
#include <memory>
#include <sstream>
#include <locale>
#include <vector>
#include <cassert>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
  
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class Config
{
  public:
    Config(void) {}
  
    ~Config(void);
  
    bool open(const std::string& name);
    
    const std::string &getValue(const std::string& section,
                                 const std::string& tag) const;
 
    bool getValue(const std::string& section, const std::string& tag,
                  std::string& value, bool missing_ok = false) const;
 
    template <typename Rsp>
    bool getValue(const std::string& section, const std::string& tag,
                  Rsp &rsp, bool missing_ok = false) const
    {
      std::string str_val;
      if (!getValue(section, tag, str_val))
      {
        return missing_ok;
      }
      std::stringstream ssval(str_val);
      Rsp tmp;
      ssval >> tmp;
      if(!ssval.eof())
      {
        ssval >> std::ws;
      }
      if (ssval.fail() || !ssval.eof())
      {
        return false;
      }
      rsp = tmp;
      return true;
    } /* Config::getValue */
 
    template <template <typename, typename> class Container,
              typename Value>
    bool getValue(const std::string& section, const std::string& tag,
                  Container<Value, std::allocator<Value> > &c,
                  bool missing_ok = false) const
    {
      std::string str_val;
      if (!getValue(section, tag, str_val))
      {
        return missing_ok;
      }
      if (str_val.empty())
      {
        c.clear();
        return true;
      }
      std::stringstream ssval(str_val);
      ssval.imbue(std::locale(ssval.getloc(), new csv_whitespace));
      while (!ssval.eof())
      {
        Value tmp;
        ssval >> tmp;
        if(!ssval.eof())
        {
          ssval >> std::ws;
        }
        if (ssval.fail())
        {
          return false;
        }
        c.push_back(tmp);
      }
      return true;
    } /* Config::getValue */
 
    template <template <typename, typename, typename> class Container,
              typename Key>
    bool getValue(const std::string& section, const std::string& tag,
                  Container<Key, std::less<Key>, std::allocator<Key> > &c,
                  bool missing_ok = false) const
    {
      std::string str_val;
      if (!getValue(section, tag, str_val))
      {
        return missing_ok;
      }
      if (str_val.empty())
      {
        c.clear();
        return true;
      }
      std::stringstream ssval(str_val);
      ssval.imbue(std::locale(ssval.getloc(), new csv_whitespace));
      while (!ssval.eof())
      {
        Key tmp;
        ssval >> tmp;
        if(!ssval.eof())
        {
          ssval >> std::ws;
        }
        if (ssval.fail())
        {
          return false;
        }
        c.insert(tmp);
      }
      return true;
    } /* Config::getValue */
 
    template <template <typename, typename, typename, typename> class Container,
              class Key, class T, class Compare=std::less<Key>,
              class Allocator=std::allocator<std::pair<const Key, T>>>
    bool getValue(const std::string& section, const std::string& tag,
                  Container<Key, T, Compare, Allocator>& c,
                  char sep = ':', bool missing_ok = false) const
    {
      std::string str_val;
      if (!getValue(section, tag, str_val))
      {
        return missing_ok;
      }
      if (str_val.empty())
      {
        c.clear();
        return true;
      }
      std::stringstream ssval(str_val);
      ssval.imbue(std::locale(ssval.getloc(), new csv_whitespace));
      while (!ssval.eof())
      {
        std::string entry;
        ssval >> entry;
        std::string::size_type seppos = entry.find(sep);
        if (seppos == std::string::npos)
        {
          return false;
        }
        std::string keystr(entry.substr(0, seppos));
        std::string valuestr(entry.substr(seppos+1));
        Key key;
        T value;
        if (!setValueFromString(key, keystr) ||
           !setValueFromString(value, valuestr))
        {
          return false;
        }
        if(!ssval.eof())
        {
          ssval >> std::ws;
        }
        if (ssval.fail())
        {
          return false;
        }
        c.insert(std::pair<Key, T>(key, value));
      }
      return true;
    } /* Config::getValue */
 
    template <typename Rsp>
    bool getValue(const std::string& section, const std::string& tag,
                  const Rsp& min, const Rsp& max, Rsp &rsp,
                  bool missing_ok = false) const
    {
      std::string str_val;
      if (!getValue(section, tag, str_val))
      {
        return missing_ok;
      }
      std::stringstream ssval(str_val);
      Rsp tmp;
      ssval >> tmp;
      if(!ssval.eof())
      {
        ssval >> std::ws;
      }
      if (ssval.fail() || !ssval.eof() || (tmp < min) || (tmp > max))
      {
        return false;
      }
      rsp = tmp;
      return true;
    } /* Config::getValue */
 
    template <typename F=std::function<void(const char*)>>
    void subscribeValue(const std::string& section, const std::string& tag,
                        const char* def, F func)
    {
      subscribeValue(section, tag, std::string(def),
          [=](const std::string& str_val) -> void
          {
            func(str_val.c_str());
          });
    } /* subscribeValue */
 
    template <typename Rsp, typename F=std::function<void(const Rsp&)>>
    void subscribeValue(const std::string& section, const std::string& tag,
                        const Rsp& def, F func)
    {
      Value& v = getValueP(section, tag, def);
      v.subs.push_back(
          [=](const std::string& str_val) -> void
          {
            std::stringstream ssval(str_val);
            ssval.imbue(std::locale(ssval.getloc(), new empty_ctype));
            Rsp tmp;
            ssval >> tmp;
            func(tmp);
          });
      v.subs.back()(v.val);
    } /* subscribeValue */
 
    template <template <typename, typename> class Container,
              typename Rsp, typename F=std::function<void(const Rsp&)>>
    void subscribeValue(const std::string& section, const std::string& tag,
                        const Container<Rsp, std::allocator<Rsp>>& def, F func)
    {
      Value& v = getValueP(section, tag, def);
      v.subs.push_back(
          [=](const std::string& str_val) -> void
          {
            std::stringstream ssval(str_val);
            ssval.imbue(std::locale(ssval.getloc(), new csv_whitespace));
            Container<Rsp, std::allocator<Rsp>> c;
            while (!ssval.eof())
            {
              Rsp tmp;
              ssval >> tmp;
              if(!ssval.eof())
              {
                ssval >> std::ws;
              }
              if (ssval.fail())
              {
                return;
              }
              c.push_back(tmp);
            }
            func(std::move(c));
          });
      v.subs.back()(v.val);
    } /* Config::subscribeValue */
 
    std::list<std::string> listSections(void);
 
    std::list<std::string> listSection(const std::string& section);
 
    void setValue(const std::string& section, const std::string& tag,
                  const std::string& value);
 
    template <typename Rsp>
    void setValue(const std::string& section, const std::string& tag,
                  const Rsp& value)
    {
      std::ostringstream ss;
      ss << value;
      setValue(section, tag, ss.str());
    }
 
    template <template <typename, typename> class Container,
              typename Rsp>
    void setValue(const std::string& section, const std::string& tag,
                  const Container<Rsp, std::allocator<Rsp>>& c)
    {
      std::ostringstream ss;
      bool first_val = true;
      for (const auto& val : c)
      {
        if (!first_val)
        {
          ss << ",";
        }
        first_val = false;
        ss << val;
      }
      setValue(section, tag, ss.str());
    } /* setValue */
 
    sigc::signal<void, const std::string&, const std::string&> valueUpdated;
 
  private:
    using Subscriber = std::function<void(const std::string&)>;
    struct Value
    {
      std::string             val;
      std::vector<Subscriber> subs;
    };
    typedef std::map<std::string, Value>  Values;
    typedef std::map<std::string, Values> Sections;
 
      // Really wanted to use classic_table() but it returns nullptr on Alpine
    static const std::ctype<char>::mask* empty_table()
    {
      static const auto table_size = std::ctype<char>::table_size;
      static std::ctype<char>::mask v[table_size];
      std::fill(&v[0], &v[table_size], 0);
      return &v[0];
    }
 
    struct empty_ctype : std::ctype<char>
    {
      static const mask* make_table(void) { return empty_table(); }
      empty_ctype(std::size_t refs=0) : ctype(make_table(), false, refs) {}
    };
 
    struct csv_whitespace : std::ctype<char>
    {
      static const mask* make_table()
      {
        auto tbl = empty_table();
        static std::vector<mask> v(tbl, tbl + table_size);
        v[' '] |= space;
        v[','] |= space;
        return &v[0];
      }
      csv_whitespace(std::size_t refs=0) : ctype(make_table(), false, refs) {}
    };
 
    Sections  sections;
 
    bool parseCfgFile(FILE *file);
    char *trimSpaces(char *line);
    char *parseSection(char *line);
    char *parseDelimitedString(char *str, char begin_tok, char end_tok);
    bool parseValueLine(char *line, std::string& tag, std::string& value);
    char *parseValue(char *value);
    char *translateEscapedChars(char *val);
 
    template <class T>
    bool setValueFromString(T& val, const std::string &str) const
    {
      std::istringstream ss(str);
      ss >> std::noskipws >> val;
      if(!ss.eof())
      {
        ss >> std::ws;
      }
      return !ss.fail() && ss.eof();
    }
 
    template <typename T>
    Value& getValueP(const std::string& section, const std::string& tag,
                     const T& def)
    {
      Values::iterator val_it = sections[section].find(tag);
      if (val_it == sections[section].end())
      {
        setValue(section, tag, def);
      }
 
      return sections[section][tag];
    } /* getValueP */
 
}; /* class Config */
 
 
} /* namespace */
 
#endif /* ASYNC_CONFIG_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */