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>
#ifdef __clang__
#  pragma clang diagnostic push
// Hide warning message:
// boost/regex/v4/instances.hpp:128:17: warning: keyword is hidden by macro definition
#  pragma clang diagnostic ignored "-Wkeyword-macro"
#endif
#include <boost/regex.hpp>
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

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() = default;
        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 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();
    }
  } // namespace Utils
} // namespace Gaudi

#endif