TrigConf::LogicExpression Class Reference

#include <LogicExpression.h>

Collaboration diagram for TrigConf::LogicExpression:

Public Member Functions
	LogicExpression (std::ostream &o=std::cout)
	constructor
virtual	~LogicExpression ()=default
	destructor
	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.
static const char	kOR = '|'
	OR of sub-logics.
static const char	kNOT = '!'
	NOT of a sub-logic. (only one sub-logic)
static const char	kELEMENT = '#'
	simple element.
static const char	kOPEN = '('
	empty logic but may have sub-logics.
static const char	kCLOSE = ')'
	')' is a valid symbol, but not allowed as a state.

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

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.

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

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

{ m_Element = e; }

setState()

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

inline

Definition at line 54 of file LogicExpression.h.

{ m_State = s; }

state()

char TrigConf::LogicExpression::state ( ) const

inline

Definition at line 60 of file LogicExpression.h.

{ return m_State; }

subLogic()

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

inline

Definition at line 63 of file LogicExpression.h.

{ return subLogics()[i]; }

subLogics()

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

inline

Definition at line 62 of file LogicExpression.h.

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

• LogicExpression.h
• LogicExpression.cxx