ModuleCondition Class Reference

Wraps a condition set on a Module instance. More...

#include <ModuleCondition.h>

Public Types
enum	EConditionOperators {   c_GT ,   c_ST ,   c_GE ,   c_SE ,   c_EQ ,   c_NE }
	The supported condition operators. More...
enum class	EAfterConditionPath {   c_End ,   c_Continue }
	Different options for behaviour after a conditional path was executed. More...

Public Member Functions
	ModuleCondition (std::string expression, std::shared_ptr< Path > conditionPath, EAfterConditionPath afterConditionPath)
	initialize from string expression (see class doc).
	~ModuleCondition ()=default
	Destructor, nothing to see here.
	ModuleCondition (const ModuleCondition &other)=default
	default copy constructor.
ModuleCondition &	operator= (const ModuleCondition &other)=default
	and default assignment operator
bool	evaluate (int value) const
	evaluate the condition using the given value.
const std::shared_ptr< Path > &	getPath () const
	Returns the path of the condition.
int	getConditionValue () const
	Returns the value of the condition.
EConditionOperators	getConditionOperator () const
	Returns the value of the condition.
EAfterConditionPath	getAfterConditionPath () const
	What to do after a conditional path is finished.
std::string	getString () const
	A string representation of this condition.

Static Public Member Functions
static void	exposePythonAPI ()
	Exposes methods of the ModuleCondition class to Python.

Private Member Functions
	ModuleCondition ()=delete
	no default constructed objects.

Private Attributes
std::shared_ptr< Path >	m_conditionPath
	The path which which will be executed if the condition is evaluated to true.
EConditionOperators	m_conditionOperator
	The operator of the condition (set by parsing the condition expression).
int	m_conditionValue
	Numeric value used in the condition (set by parsing the condition expression).
EAfterConditionPath	m_afterConditionPath
	What to do after a conditional path is finished.

Detailed Description

Wraps a condition set on a Module instance.

It supports conditions of the form [comparison operator][integer] e.g. ">5", "=7", "!= 0"

Additional spaces in front of the operator, between operator and integer number and after the integer number are allowed.

Supported operators are: "> , < , = , == , >= , <= , !="

Definition at line 29 of file ModuleCondition.h.

Member Enumeration Documentation

EAfterConditionPath

enum class EAfterConditionPath

strong

Different options for behaviour after a conditional path was executed.

Enumerator
c_End	End current event after the conditional path.
c_Continue	After the conditional path, resume execution after this module.

Definition at line 42 of file ModuleCondition.h.

                                   {
      c_End, 
      c_Continue, 
    };

EConditionOperators

enum EConditionOperators

The supported condition operators.

Enumerator
c_GT	Greater than: ">"
c_ST	Smaller than: "<"
c_GE	Greater or equal than: ">=".
c_SE	Smaller or equal than: "<=".
c_EQ	Equal: "=" or "=="
c_NE	Not equal: "!=".

Definition at line 32 of file ModuleCondition.h.

                             {
      c_GT,    
      c_ST,    
      c_GE,    
      c_SE,    
      c_EQ,    
      c_NE     
    };

Constructor & Destructor Documentation

ModuleCondition()

ModuleCondition	(	std::string	expression,
		std::shared_ptr< Path >	conditionPath,
		EAfterConditionPath	afterConditionPath
	)

initialize from string expression (see class doc).

Throws runtime_error if expression is invalid.

Maps the operator string to a EConditionOperators value.

Definition at line 23 of file ModuleCondition.cc.

                                                                        :
  m_conditionPath(std::move(conditionPath)),
  m_afterConditionPath(afterConditionPath)
{
  std::map<std::string, EConditionOperators> m_conditionOperatorMap;
  m_conditionOperatorMap[">"]  = c_GT;
  m_conditionOperatorMap["<"]  = c_ST;
  m_conditionOperatorMap[">="] = c_GE;
  m_conditionOperatorMap["<="] = c_SE;
  m_conditionOperatorMap["="]  = c_EQ;
  m_conditionOperatorMap["=="] = c_EQ;
  m_conditionOperatorMap["!="] = c_NE;
 
  //Remove all spaces from the string
  boost::erase_all(expression, " ");
 
  //Find the operator
  unsigned int iOperator = 0;
  while ((iOperator < expression.length()) && (!isdigit(expression[iOperator]) && (expression[iOperator] != '-'))) iOperator++;
  if (iOperator == 0) //if iOperator is 0, there is either no operator or the string is empty
    throw std::runtime_error("Invalid condition: could not parse condition: '" + expression + "'!");
  std::string opString = expression.substr(0, iOperator);
 
  //Try to get the operator for the found string from the map
  auto foundIter = m_conditionOperatorMap.find(opString);
  if (foundIter == m_conditionOperatorMap.end())
    throw std::runtime_error("Invalid condition: could not parse condition: '" + expression + "'!");
 
  m_conditionOperator = foundIter->second;
  //Try to translate the remaining text to a number
  m_conditionValue = convertString<int>(expression.substr(iOperator, expression.length() - 1));
}

Member Function Documentation

evaluate()

bool evaluate

(

int

value

)

const

evaluate the condition using the given value.

E.g. for a condition ">5", this would return "value>5"

Definition at line 58 of file ModuleCondition.cc.

{
  switch (m_conditionOperator) {
    case c_GT : return value >  m_conditionValue;
    case c_ST : return value <  m_conditionValue;
    case c_GE : return value >= m_conditionValue;
    case c_SE : return value <= m_conditionValue;
    case c_EQ : return value == m_conditionValue;
    case c_NE : return value != m_conditionValue;
  }
  return false;
}

exposePythonAPI()

void exposePythonAPI ( )

static

Exposes methods of the ModuleCondition class to Python.

Definition at line 94 of file ModuleCondition.cc.

{
  docstring_options options(true, true, false); //userdef, py sigs, c++ sigs
 
  //Python class definition
  class_<ModuleCondition, boost::noncopyable>("ModuleCondition", no_init)
  .def("__str__", &ModuleCondition::getString)
  .def("get_value", &ModuleCondition::getConditionValue)
  .def("get_operator", &ModuleCondition::getConditionOperator)
  .def("get_after_path", &ModuleCondition::getAfterConditionPath)
  .def("get_path", &_getPathPython)
  ;
}

getAfterConditionPath()

EAfterConditionPath getAfterConditionPath ( ) const

inline

What to do after a conditional path is finished.

Definition at line 69 of file ModuleCondition.h.

{ return m_afterConditionPath; }

getConditionOperator()

EConditionOperators getConditionOperator ( ) const

inline

Returns the value of the condition.

Definition at line 66 of file ModuleCondition.h.

{return m_conditionOperator; }

getConditionValue()

int getConditionValue ( ) const

inline

Returns the value of the condition.

Definition at line 63 of file ModuleCondition.h.

{return m_conditionValue; }

getPath()

const std::shared_ptr< Path > & getPath ( ) const

inline

Returns the path of the condition.

Definition at line 60 of file ModuleCondition.h.

{return m_conditionPath; }

getString()

std::string getString

(

)

const

A string representation of this condition.

Definition at line 71 of file ModuleCondition.cc.

{
  std::string output = "(? ";
  switch (m_conditionOperator) {
    case c_GT: output += ">"; break;
    case c_ST: output += "<"; break;
    case c_GE: output += ">="; break;
    case c_SE: output += "<="; break;
    case c_NE: output += "!="; break;
    case c_EQ: output += "=="; break;
    default: output += "???";
  }
  output += std::to_string(m_conditionValue);
  output += m_conditionPath->getPathString();
  output += " )";
  return output;
}

Member Data Documentation

m_afterConditionPath

EAfterConditionPath m_afterConditionPath

private

What to do after a conditional path is finished.

Definition at line 86 of file ModuleCondition.h.

m_conditionOperator

EConditionOperators m_conditionOperator

private

The operator of the condition (set by parsing the condition expression).

Definition at line 84 of file ModuleCondition.h.

m_conditionPath

std::shared_ptr<Path> m_conditionPath

private

The path which which will be executed if the condition is evaluated to true.

Definition at line 83 of file ModuleCondition.h.

m_conditionValue

int m_conditionValue

private

Numeric value used in the condition (set by parsing the condition expression).

Definition at line 85 of file ModuleCondition.h.

---

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

• framework/core/include/ModuleCondition.h
• framework/core/src/ModuleCondition.cc