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 marlinmt{


  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 ) const ;

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

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


  protected:

    bool getValue( const std::string& key ) const ;

    ConditionsMap _condMap{};
    ResultMap _resultMap{};

  } ;
} // end namespace

#endif