AttribStringParser.h

Go to the documentation of this file.

#ifndef _ATTRIB_STRING_PARSER_H_
#define _ATTRIB_STRING_PARSER_H_

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/System.h"
#include <iterator>
#include <boost/regex.hpp>

namespace Gaudi {
  namespace Utils {
    class AttribStringParser {
    public:
      struct Attrib {
        std::string tag;
        std::string value;
      };

      // This class is essentially a wrapper around boost::sregex_iterator.
      class Iterator: public std::iterator<std::input_iterator_tag, Attrib> {
      public:
        Iterator() {}
        Iterator(const boost::sregex_iterator& it, bool expand_vars):
          m_it(it),
          m_expandVars(expand_vars)
        {
          //i_setAttrib();
        }
        Iterator(const Iterator& other): Iterator(other.m_it, other.m_expandVars)
        {
        }
        Iterator(Iterator&& other):
          m_it(std::move(other.m_it)),
          m_expandVars(other.m_expandVars)
        {
        }
        Iterator operator++(int) {
          ++m_it;
          return *this;
        }
        Iterator operator++() {
          auto old = *this;
          ++m_it;
          return std::move(old);
        }
        reference operator*() {
          i_setAttrib();
          return m_attrib;
        }
        bool operator==(const Iterator& other) {
          return m_it == other.m_it;
        }
        bool operator!=(const Iterator& other) {
          return m_it != other.m_it;
        }
      private:
        boost::sregex_iterator m_it;
        bool m_expandVars = false;
        Attrib m_attrib;
        void i_setAttrib() {
          static const boost::sregex_iterator endmark;
          if (m_it != endmark) {
            // if we have a match, we cache the values
            m_attrib = Attrib{(*m_it)[1], (*m_it)[2]};
            if (m_expandVars && m_attrib.value.find("${") != std::string::npos) {
              static const boost::regex varexp{"\\$\\{([^}]+)\\}"};
              auto i = 1;
              while (i) {
                i = 0;
                m_attrib.value = boost::regex_replace(m_attrib.value,
                    varexp, [&i] (const boost::smatch& m) -> std::string {
                      const std::string name = m[1];
                      const char* cname = name.c_str();
                      if (System::isEnvSet(cname)) {
                        ++i;
                        return System::getEnv(cname);
                      }
                      return m[0]; // do not expand unknown vars
                    },
                    boost::match_default | boost::format_all);
              }
            }
          } else {
            // otherwise we clean the cache
            m_attrib = Attrib();
          }
        }
      };

      AttribStringParser(std::string data, bool expand_vars=true):
        m_data(data),
        m_expandVars(expand_vars) {
      }

    private:
      std::string m_data;
      bool m_expandVars;

      boost::sregex_iterator parse() const {
        static const boost::regex exp{"[[:space:]]*([^[:space:]]+)[[:space:]]*=[[:space:]]*'(.*?)'"};
        return boost::sregex_iterator(begin(m_data), end(m_data), exp);
      }
      friend Iterator begin(const AttribStringParser&);
    };
    inline AttribStringParser::Iterator begin(const AttribStringParser& parser) {
      return AttribStringParser::Iterator(parser.parse(), parser.m_expandVars);
    }
    inline AttribStringParser::Iterator end(const AttribStringParser& /*parser*/) {
      return AttribStringParser::Iterator();
    }
  }
}

#endif