#include <LogicExpression.h>

Collaboration diagram for TrigConf::LogicExpression:

Public Member Functions
	LogicExpression (std::ostream &o=std::cout)
	constructor More...

virtual	~LogicExpression ()=default
	destructor More...

	LogicExpression (const std::string &name, std::ostream &o=std::cout)

virtual int	parse (const std::string &expr, bool enclosed=false)

virtual std::string	logicRep () const

void	setState (char s)

void	setElement (const std::string &e)

void	addSubLogic (const LogicExpression &sub)

char	state () const

const std::string &	element () const

const LogicV_t &	subLogics () const

const std::shared_ptr< LogicExpression >	subLogic (int i) const

bool	isPlaceHolder () const

int	totalNumberOfElements () const

void	markPlaceHolder ()

void	normalize ()

void	printError (const std::string &message, int i)

void	printCurrentState ()

void	print (const std::string &indent="")

void	clear ()

Static Public Member Functions
static bool	isValidElementChar (char c)

static std::string	extractElementName (const std::string &expr)

Static Public Attributes
static const char	kAND = '&'
	AND of sub-logics. More...

static const char	kOR = '\|'
	OR of sub-logics. More...

static const char	kNOT = '!'
	NOT of a sub-logic. (only one sub-logic) More...

static const char	kELEMENT = '#'
	simple element. More...

static const char	kOPEN = '('
	empty logic but may have sub-logics. More...

static const char	kCLOSE = ')'
	')' is a valid symbol, but not allowed as a state. More...

Protected Attributes
std::string	m_LogicRep

char	m_State

LogicV_t	m_SubLogics

std::string	m_Element

std::ostream &	m_ostream
	output stream for all messages More...

Detailed Description

Definition at line 27 of file LogicExpression.h.

Constructor & Destructor Documentation

◆ LogicExpression() [1/2]

LogicExpression::LogicExpression ( std::ostream & o = std::cout )

constructor

Definition at line 14 of file LogicExpression.cxx.

                                                : 
    m_State(kELEMENT),
    m_Element(""),
    m_ostream(o)
 {}

◆ ~LogicExpression()

virtual TrigConf::LogicExpression::~LogicExpression ( )

virtualdefault

destructor

◆ LogicExpression() [2/2]

LogicExpression::LogicExpression	(	const std::string &	name,
		std::ostream &	o = `std::cout`
	)

Definition at line 21 of file LogicExpression.cxx.

    : m_State(kELEMENT),
      m_Element(name),
      m_ostream(o)
 {}

Member Function Documentation

◆ addSubLogic()

void TrigConf::LogicExpression::addSubLogic ( const LogicExpression & sub )

inline

Definition at line 56 of file LogicExpression.h.

                                                    {
          m_SubLogics.emplace_back(std::make_shared<LogicExpression>(sub));
       }

◆ clear()

void LogicExpression::clear ( )

Definition at line 293 of file LogicExpression.cxx.

                        {
    m_State = kELEMENT;
    m_SubLogics.clear();
    m_Element = "";
 }

◆ element()

const std::string& TrigConf::LogicExpression::element ( ) const

inline

Definition at line 61 of file LogicExpression.h.

61 { return m_Element; }

◆ extractElementName()

std::string LogicExpression::extractElementName ( const std::string & expr )

static

Definition at line 40 of file LogicExpression.cxx.

                                                          {
    std::string name="";
    for (unsigned int i=0; i<expr.size(); ++i) {
       if (isValidElementChar(expr[i])) name += expr[i];
       else break;
    }
    return name;
 }

◆ isPlaceHolder()

bool TrigConf::LogicExpression::isPlaceHolder ( ) const

inline

Definition at line 64 of file LogicExpression.h.

64 { return (m_State==kOPEN && m_SubLogics.size()==1); }

◆ isValidElementChar()

bool LogicExpression::isValidElementChar ( char c )

static

Definition at line 29 of file LogicExpression.cxx.

                                           {
    std::string valid_sym = "_";
    if (isalpha(c) || isdigit(c) || valid_sym.find(c)!=std::string::npos) {
       return true;
    } else {
       return false;
    }
 }

◆ logicRep()

std::string LogicExpression::logicRep ( ) const

virtual

Definition at line 176 of file LogicExpression.cxx.

                                 {
    std::string s="";
    if (m_State == kELEMENT) {
       s = m_Element;
    } else if (m_State == kAND || m_State == kOR) {
       LogicV_t::const_iterator p;
       s = kOPEN;
       for (p=subLogics().begin(); p!=subLogics().end(); ++p) {
          s += (*p)->logicRep();
          s += m_State;
       }
       if (s.size() > 1) s[s.size()-1] = kCLOSE;
       else s += kCLOSE;
    } else if (m_State == kNOT) {
       s = kNOT;
       s += kOPEN;
       if (subLogics().size() == 1) s += subLogics()[0]->logicRep();
       s += kCLOSE;
    } else if (m_State == kOPEN) {
       s += kOPEN;
       if (subLogics().size() == 1) s += subLogics()[0]->logicRep();
       s += kCLOSE;
    }
    return s;
 }

◆ markPlaceHolder()

void LogicExpression::markPlaceHolder ( )

Definition at line 169 of file LogicExpression.cxx.

                                  {
    if (m_State == kELEMENT && subLogics().size() == 1 && m_Element=="") {
       m_State = kOPEN;
    }
 }

◆ normalize()

void LogicExpression::normalize ( )

Definition at line 204 of file LogicExpression.cxx.

                            {
    LogicV_t::const_iterator p;
    for (p=subLogics().begin(); p!=subLogics().end(); ++p) {
       (*p)->normalize();
    }
    if (isPlaceHolder()) {
       char s = subLogics()[0]->state();
       std::string e = subLogics()[0]->element();
       LogicV_t sublogics = subLogics()[0]->subLogics();
       clear();
       setState(s);
       setElement(e);
       for (p=sublogics.begin(); p!=sublogics.end(); ++p) {
          addSubLogic(**p);
       }
    }
 }

◆ parse()

int LogicExpression::parse	(	const std::string &	expr,
		bool	enclosed = `false`
	)

virtual

Definition at line 51 of file LogicExpression.cxx.

                                                            {
    unsigned int i=0;
    char c;
    bool no_problem=true;
    char prev = ' ';
    int n;
  
    m_LogicRep = expr;
    while (no_problem && i < expr.size()) {
       c = expr[i];
  
       switch (c) {
       case kOPEN:
          {
             LogicExpression sub(m_ostream);
             if ( (n = sub.parse(expr.substr(i+1), true)) > 0) {
                addSubLogic(sub);
                prev = kELEMENT;
                i += n;
             } else {
                no_problem = false;
             }
          }
          break;
       case kCLOSE:
          if ( ( (m_State == kAND || m_State == kOR) && subLogics().size()>=2) ||
               (m_State == kNOT && subLogics().size()==1) || 
               (m_State == kELEMENT && subLogics().size()<=1 && m_Element=="")) {
             prev = kELEMENT;
             markPlaceHolder();
             return i + 1;
          } else {
             std::ostringstream formatedoutput;
             formatedoutput << "Invalid logic: State=" << m_State << " Nsublogics=" << subLogics().size() << " Element=" << m_Element;
             printError(formatedoutput.str(), i);
             no_problem = false;
          }
          break;
       case kAND: case kOR:
          if (prev == kELEMENT && 
              ( (subLogics().size() >= 2 && m_State==c) || 
                (subLogics().size()==1 && m_State==kELEMENT))
              ) {
             m_State = c;
             prev = c;
          } else {
             std::ostringstream formatedoutput;
             formatedoutput << kAND << " or " << kOR << " must come after a logic element";
             printError(formatedoutput.str(), i);
             no_problem = false;
          }
          break;
       case kNOT:
          if (kELEMENT != prev) {
             LogicExpression sub(m_ostream);
             sub.setState(kNOT);
             if ( (i+1)<expr.size() && isValidElementChar(expr[i+1])) {
                std::string name = extractElementName(expr.substr(i+1));
                sub.addSubLogic(LogicExpression(name,m_ostream));
                i += name.size();
                addSubLogic(sub);
             } else if ( (i+1)<expr.size() && expr[i+1]==kOPEN) {
                LogicExpression sub2(m_ostream);
                if ( (n = sub2.parse(expr.substr(i+2), true)) > 0) {
                   sub.addSubLogic(sub2);
                   i += (n+1);
                   addSubLogic(sub);
                } else {
                   no_problem = false;
                }
             } else {
                printError("Was expecting a sub-logic after !", i);
                no_problem = false;
             }
          } else {
             printError("! must not come directly after a logic element", i);
             no_problem = false;
          }
          prev = kELEMENT;
          break;
       default:
          // Start of a candidate of an element string.
          if (subLogics().size()==0 || 
              (subLogics().size()>0 && m_State != kELEMENT)) {
             std::string name = extractElementName(expr.substr(i));
             if (name.size() > 0) {
                addSubLogic(LogicExpression(name,m_ostream));
                i += name.size()-1;
             } else {
                printError("Unrecognized string", i);
                no_problem = false;
             }
             prev = kELEMENT;
          } else {
             printError("A logic element may not come immediately after another logic element", i);
             no_problem = false;
          }
          break;
       }
       i ++;
  
    }
    if (!no_problem) {
       return -1;
    }
  
    if (enclosed) {
       // The logic expression started with a '(' but didn't find ')' and 
       // reached the end of the string. 
       printError("The expression started with a '(' but ')' not found.", i);
       return 0;
    }
    markPlaceHolder();
  
    return i;
 }

◆ print()

void LogicExpression::print ( const std::string & indent = "" )

Definition at line 268 of file LogicExpression.cxx.

                                               {
    std::string s=indent;
    if (m_State == kELEMENT) {
       m_ostream << indent << m_Element << std::endl;
    } else if (m_State == kAND || m_State == kOR) {
       if (m_State==kAND) m_ostream << indent << "AND" << std::endl;
       if (m_State==kOR) m_ostream << indent << "OR" << std::endl;
       LogicV_t::const_iterator p;
       for (p=subLogics().begin(); p!=subLogics().end(); ++p) {
          (*p)->print(indent + "  ");
       }
    } else if (m_State == kNOT) {
       m_ostream << indent << "NOT" << std::endl;
       if (subLogics().size() == 1) {
          subLogic(0)->print(indent + "  ");
       }
    } else if (m_State == kOPEN) {
       if (subLogics().size() == 1) subLogic(0)->print(indent);
    } else {
       m_ostream << indent << "ERROR" << std::endl;
    }
 }

◆ printCurrentState()

void LogicExpression::printCurrentState ( )

Definition at line 259 of file LogicExpression.cxx.

                                    {
    char aaa[100];
    sprintf(aaa, "Current state: State=%c Nsublogics=%d Element=%s", 
            m_State, (int)subLogics().size(), m_Element.c_str());
    m_ostream << aaa << std::endl;
 }

◆ printError()

void LogicExpression::printError	(	const std::string &	message,
		int	i
	)

Definition at line 246 of file LogicExpression.cxx.

                                                            {
    std::string m="Error while parsing : ";
    std::string s="";
    int n = m.size();
    for (int j=0; j<(n+i); ++j) s += " ";
    s += "^";
    m_ostream << m << m_LogicRep << " at " << i << "-th character" << std::endl;
    m_ostream << s << std::endl;
    m_ostream << message << std::endl;
 }

◆ setElement()

void TrigConf::LogicExpression::setElement ( const std::string & e )

inline

Definition at line 55 of file LogicExpression.h.

55 { m_Element = e; }

◆ setState()

void TrigConf::LogicExpression::setState ( char s )

inline

Definition at line 54 of file LogicExpression.h.

54 { m_State = s; }

◆ state()

char TrigConf::LogicExpression::state ( ) const

inline

Definition at line 60 of file LogicExpression.h.

60 { return m_State; }

◆ subLogic()

const std::shared_ptr<LogicExpression> TrigConf::LogicExpression::subLogic ( int i ) const

inline

Definition at line 63 of file LogicExpression.h.

63 { return subLogics()[i]; }

◆ subLogics()

const LogicV_t& TrigConf::LogicExpression::subLogics ( ) const

inline

Definition at line 62 of file LogicExpression.h.

62 { return m_SubLogics; }

◆ totalNumberOfElements()

int LogicExpression::totalNumberOfElements ( ) const

Definition at line 224 of file LogicExpression.cxx.

                                              {
    int n = 0;
    LogicV_t::const_iterator p;
  
    switch (m_State) {
    case kELEMENT:
       n = 1;
       break;
    case kAND: case kOR: case kNOT: case kOPEN:
       for (p=subLogics().begin(); p!=subLogics().end(); ++p) {
          n += (*p)->totalNumberOfElements();
       }
       break;
    default:
       n = 0;
       break;
    }
    return n;
 }

Member Data Documentation

◆ kAND

const char TrigConf::LogicExpression::kAND = '&'

static

AND of sub-logics.

Definition at line 32 of file LogicExpression.h.

◆ kCLOSE

const char TrigConf::LogicExpression::kCLOSE = ')'

static

')' is a valid symbol, but not allowed as a state.

Definition at line 37 of file LogicExpression.h.

◆ kELEMENT

const char TrigConf::LogicExpression::kELEMENT = '#'

static

simple element.

Definition at line 35 of file LogicExpression.h.

◆ kNOT

const char TrigConf::LogicExpression::kNOT = '!'

static

NOT of a sub-logic. (only one sub-logic)

Definition at line 34 of file LogicExpression.h.

◆ kOPEN

const char TrigConf::LogicExpression::kOPEN = '('

static

empty logic but may have sub-logics.

Definition at line 36 of file LogicExpression.h.

◆ kOR

const char TrigConf::LogicExpression::kOR = '|'

static

OR of sub-logics.

Definition at line 33 of file LogicExpression.h.

◆ m_Element

std::string TrigConf::LogicExpression::m_Element

protected

Definition at line 85 of file LogicExpression.h.

◆ m_LogicRep

std::string TrigConf::LogicExpression::m_LogicRep

protected

Definition at line 80 of file LogicExpression.h.

◆ m_ostream

std::ostream& TrigConf::LogicExpression::m_ostream

protected

output stream for all messages

Definition at line 87 of file LogicExpression.h.

◆ m_State

char TrigConf::LogicExpression::m_State

protected

Definition at line 82 of file LogicExpression.h.

◆ m_SubLogics

LogicV_t TrigConf::LogicExpression::m_SubLogics

protected

Definition at line 84 of file LogicExpression.h.

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LogicExpression() [1/2]

◆ ~LogicExpression()

◆ LogicExpression() [2/2]

Member Function Documentation

◆ addSubLogic()

◆ clear()

◆ element()

◆ extractElementName()

◆ isPlaceHolder()

◆ isValidElementChar()

◆ logicRep()

◆ markPlaceHolder()

◆ normalize()

◆ parse()

◆ print()

◆ printCurrentState()

◆ printError()

◆ setElement()

◆ setState()

◆ state()

◆ subLogic()

◆ subLogics()

◆ totalNumberOfElements()

Member Data Documentation

◆ kAND

◆ kCLOSE

◆ kELEMENT

◆ kNOT

◆ kOPEN

◆ kOR

◆ m_Element

◆ m_LogicRep

◆ m_ostream

◆ m_State

◆ m_SubLogics