LogicalExpressions.h

#ifndef LogicalExpressions_h
#define LogicalExpressions_h 1

#include <map>
#include <string>
#include <list>
#include <vector>
#include <ostream>

typedef std::map< const std::string, std::string > ConditionsMap ;
typedef std::map< const std::string, bool > ResultMap ;


namespace marlin{


  struct Expression{

    Expression() : Operation( AND ), isNot( false ), Value("") {
    }
    enum Operator{ OR, AND } ;

    Operator Operation ;
    bool isNot ;
    std::string Value ;
  };
  
  std::ostream& operator<< (  std::ostream& s,  Expression& e ) ;

  class Tokenizer{

    enum state{
      newtoken,
      parenthesis,
      operation 
    } ;

    std::vector< Expression >& _tokens ;
    char _last ;
    bool needToken ;
    int openPar ;
    int closedPar ;
    state _state ;

  public:
    
    Tokenizer( std::vector< Expression >& tokens ) : _tokens(tokens) , needToken(true) 
                                                   , openPar(0), closedPar(0) ,
                                                     _state( newtoken ) {
    }
    
    
    void operator()(const char& c) { 

      if( c != ' ' && c != '\t'  ) {  // ignore whitespaces and tabs

        if( c == '(' ) ++openPar ;

        if( c == ')' ) ++closedPar ;

        switch( _state ){
          
        case( newtoken ):
          
          if( needToken ){
            _tokens.push_back( Expression() ) ; // create a new object
            needToken = false ;
          }
          if( c == '!' )
            _tokens.back().isNot = true ;
          
          else if( c == '(' )
            _state =  parenthesis ;

          else {
            _tokens.back().Value += c ;
            _state = operation ;
          }
          break ;

        case( parenthesis ):
          
          if( closedPar == openPar ) {

            _state = operation ;

          } else {

            _tokens.back().Value += c ;
          }
          break ;

        case( operation ): // need to accumulate values until && or || 

          if( c == '&' || c=='|' ){ 

            if ( c == '&' && _last == '&' ) {
              _tokens.push_back( Expression() ) ; // create a new object
              _tokens.back().Operation = Expression::AND ;
              _state = newtoken ;
            }
            if ( c == '|' && _last == '|' ) {
              _tokens.push_back( Expression() ) ; // create a new object
              _tokens.back().Operation = Expression::OR ;
              _state = newtoken ;
            }

          }  else { 

            _tokens.back().Value += c ;
          }

          break ;
        }

      }
      _last = c ;
    }

    ~Tokenizer(){
    }
    
    std::vector<Expression> & result()  { 
      
      return _tokens ; 
      
    }
  };

  class LogicalExpressions {
    
  public:
    
    LogicalExpressions() ;
    
    virtual ~LogicalExpressions() {} 
    
    void addCondition( const std::string& name, const std::string& expression ) ;

    void clear() ;

    bool conditionIsTrue( const std::string& name ) ;

    bool expressionIsTrue( const std::string& expression ) ;

    void setValue( const std::string& key, bool val ) ;


  protected:

    ConditionsMap _condMap ;
    ResultMap _resultMap ;

  } ;
} // end namespace 

#endif

---