TrigConf::LogicLeaf Class Reference

#include <Logic.h>

Inheritance diagram for TrigConf::LogicLeaf:

Collaboration diagram for TrigConf::LogicLeaf:

Public Types
enum	NodeType { LEAF , AND , OR }

Public Member Functions
	LogicLeaf ()=delete
	LogicLeaf (const std::string &content)
virtual	~LogicLeaf () override=default
void	setContent (const std::string &content)
bool	evaluate (const std::map< std::string, bool > &elements) const override
bool	evaluate (const std::map< std::string, unsigned int > &elementsCount) const override
std::map< std::string, bool >	elements () const override
std::map< std::string, unsigned int >	elementsCount () const override
NodeType	nodeType () const
void	setNegate (bool negate=true)
bool	negate () const
void	setExpression (const std::string &)
const std::string &	expression () const
void	print (std::ostream &=std::cout) const

Private Member Functions
virtual void	print (std::ostream &, size_t indSize, size_t indLevel) const override

Private Attributes
std::string	m_content { "" }
std::string	m_name { "" }
unsigned int	m_count { 1 }
NodeType	m_nodeType { LEAF }
bool	m_negate { false }
std::string	m_expression { "" }

Detailed Description

Definition at line 65 of file Logic.h.

Member Enumeration Documentation

NodeType

enum TrigConf::Logic::NodeType

inherited

Enumerator
LEAF
AND
OR

Definition at line 33 of file Logic.h.

{ LEAF, AND, OR };

Constructor & Destructor Documentation

LogicLeaf() [1/2]

TrigConf::LogicLeaf::LogicLeaf ( )

delete

LogicLeaf() [2/2]

TrigConf::LogicLeaf::LogicLeaf

(

const std::string &

content

)

Definition at line 46 of file Logic.cxx.

                                                      :
   Logic(Logic::LEAF)
{
   setContent(content);
}

~LogicLeaf()

virtual TrigConf::LogicLeaf::~LogicLeaf ( )

overridevirtualdefault

Member Function Documentation

elements()

std::map< std::string, bool > TrigConf::LogicLeaf::elements ( ) const

overridevirtual

Implements TrigConf::Logic.

Definition at line 84 of file Logic.cxx.

                                  {
   return {{m_name, true}};
}

elementsCount()

std::map< std::string, unsigned int > TrigConf::LogicLeaf::elementsCount ( ) const

overridevirtual

Implements TrigConf::Logic.

Definition at line 90 of file Logic.cxx.

                                       {
   return {{m_name, m_count}};
}

evaluate() [1/2]

bool TrigConf::LogicLeaf::evaluate ( const std::map< std::string, bool > & elements ) const

overridevirtual

Implements TrigConf::Logic.

Definition at line 64 of file Logic.cxx.

                                                                              {
   auto stateForThisLeaf = elementsState.find(m_content);
   if( stateForThisLeaf == elementsState.end() ) {
      throw LogicParsingException(std::string("Can't evaluate logic ") + m_content + " as it is missing in the state map");
   }
   return negate() ? !stateForThisLeaf->second : stateForThisLeaf->second;
}

evaluate() [2/2]

bool TrigConf::LogicLeaf::evaluate ( const std::map< std::string, unsigned int > & elementsCount ) const

overridevirtual

Implements TrigConf::Logic.

Definition at line 74 of file Logic.cxx.

                                                                                       {
   auto stateForThisLeaf = elementsCount.find(m_name);
   if( stateForThisLeaf == elementsCount.end() ) {
      throw LogicParsingException(std::string("Can't evaluate logic ") + m_content + " as " + m_name + " is missing in the counts map");
   }
   bool pass = stateForThisLeaf->second >= m_count;
   return negate() ? !pass : pass;
}

expression()

const std::string & TrigConf::Logic::expression ( ) const

inherited

Definition at line 32 of file Logic.cxx.

                                {
   return m_expression;
}

negate()

bool TrigConf::Logic::negate ( ) const

inherited

Definition at line 22 of file Logic.cxx.

                            {
   return m_negate;
}

nodeType()

NodeType TrigConf::Logic::nodeType ( ) const

inlineinherited

Definition at line 37 of file Logic.h.

{ return m_nodeType; }

print() [1/2]

void TrigConf::Logic::print ( std::ostream & o = std::cout ) const

inherited

Definition at line 37 of file Logic.cxx.

                                         {
   if(m_expression.size()>0) {
      o << m_expression << std::endl;
      o << std::string(m_expression.size(), '-') << std::endl;
   }
   print(o, 4, 0);
}

print() [2/2]

void TrigConf::LogicLeaf::print ( std::ostream & o, size_t indSize, size_t indLevel ) const

overrideprivatevirtual

Implements TrigConf::Logic.

Definition at line 96 of file Logic.cxx.

                                                                              {
   o << std::string(indSize*indLevel, ' ');
   if( negate() ) { o << "NOT "; }
   o << m_content << std::endl;
}

setContent()

void TrigConf::LogicLeaf::setContent

(

const std::string &

content

)

Definition at line 54 of file Logic.cxx.

                                                       {
   m_content = content;
   std::smatch sm;
   std::regex_match(content, sm, re);
   m_name = sm[1];
   m_count = sm[2].length() > 0 ? static_cast<unsigned int>(std::stoul(sm[2])) : 1;
}

setExpression()

void TrigConf::Logic::setExpression ( const std::string & expr )

inherited

Definition at line 27 of file Logic.cxx.

                                                   {
   m_expression = expr;
}

setNegate()

void TrigConf::Logic::setNegate ( bool negate = true )

inherited

Definition at line 17 of file Logic.cxx.

                                    {
   m_negate = negate;
}

Member Data Documentation

m_content

std::string TrigConf::LogicLeaf::m_content { "" }

private

Definition at line 81 of file Logic.h.

{ "" };

m_count

unsigned int TrigConf::LogicLeaf::m_count { 1 }

private

Definition at line 83 of file Logic.h.

{ 1 };

m_expression

std::string TrigConf::Logic::m_expression { "" }

privateinherited

Definition at line 61 of file Logic.h.

{ "" };

m_name

std::string TrigConf::LogicLeaf::m_name { "" }

private

Definition at line 82 of file Logic.h.

{ "" };

m_negate

bool TrigConf::Logic::m_negate { false }

privateinherited

Definition at line 60 of file Logic.h.

{ false };

m_nodeType

NodeType TrigConf::Logic::m_nodeType { LEAF }

privateinherited

Definition at line 59 of file Logic.h.

{ LEAF };

---

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

• Logic.h
• Logic.cxx