LogicalExpressions.h

Go to the documentation of this file.

#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) , _last(0), 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:
    
    bool getValue( const std::string& key );
  
    ConditionsMap _condMap{};
    ResultMap _resultMap{};

  } ;
} // end namespace 

#endif