NodeFactory Class Reference

Wrapper class for static node compile functions. More...

#include <NodeFactory.h>

Static Public Member Functions
template<class AVariableManager >
static std::unique_ptr< const AbstractBooleanNode< AVariableManager > >	compile_boolean_node (Nodetuple tuple)
	This template function creates a boolean node from a boost::python::tuple The Python Parser encodes the node type as int as the first argument of each tuple. More...
template<class AVariableManager >
static std::unique_ptr< const AbstractExpressionNode< AVariableManager > >	compile_expression_node (Nodetuple tuple)
	This template function creates a ExpressionNode from a boost::python::tuple The Python Parser encodes the node type as int in the first argument of each tuple. More...

Detailed Description

Wrapper class for static node compile functions.

Definition at line 64 of file NodeFactory.h.

Member Function Documentation

compile_boolean_node()

static std::unique_ptr<const AbstractBooleanNode<AVariableManager> > compile_boolean_node ( Nodetuple  tuple )

inlinestatic

This template function creates a boolean node from a boost::python::tuple The Python Parser encodes the node type as int as the first argument of each tuple.

Node types are decoded via the NodeType enum defined in framework/utilities/include/AbstractNodes.h e.g (2, (11, True)) is a UnaryRelationalNode (nodetype value 2), which has a BooleanNode(nodetype value 11) as a child. List of Nodes:

• UnaryBooleanNode
• BinaryBooleanNode
• UnaryRelationalNode
• BinaryRelationalNode
• TernaryRelationalNode

  Parameters

  tuple

  (const boost::python::tuple&): python tuple generated from the parser

Definition at line 80 of file NodeFactory.h.

    {
      if (py::len(tuple) == 0) B2FATAL("BooleanNode tuple is empty, this is invalid.");
      // First argument of every NodeTuple is an integer indicating the NodeType
      NodeType node_type = static_cast<NodeType>(static_cast<int>(py::extract<int>(tuple[0])));
 
      if (node_type == NodeType::UnaryBooleanNode) {
        // Extract first child tuple
        if (py::len(tuple) != 4) B2FATAL("UnaryBooleanNode tuple has to have length 4." << LogVar("actual length", py::len(tuple)));
        Nodetuple child = static_cast<const py::tuple>(tuple[1]);
        bool negation = py::extract<bool>(tuple[2]);
        bool bracketized = py::extract<bool>(tuple[3]);
        return std::unique_ptr<const AbstractBooleanNode<AVariableManager>>(new UnaryBooleanNode<AVariableManager>(child, negation,
               bracketized));
 
      } else if (node_type == NodeType::BinaryBooleanNode) {
        if (py::len(tuple) != 4) B2FATAL("BinaryBooleanNode tuple has to have length 4." << LogVar("actual length", py::len(tuple)));
        Nodetuple left_node = static_cast<const py::tuple>(tuple[1]);
        Nodetuple right_node = static_cast<const py::tuple>(tuple[2]);
        BooleanOperator boperator = static_cast<BooleanOperator>(static_cast<int>(py::extract<int>(tuple[3])));
        return std::unique_ptr<const AbstractBooleanNode<AVariableManager>>(new BinaryBooleanNode<AVariableManager>(left_node, right_node,
               boperator));
      } else if (node_type == NodeType::UnaryRelationalNode) {
        if (py::len(tuple) != 2) B2FATAL("UnaryRelationalNode tuple has to have length 2." << LogVar("actual length", py::len(tuple)));
        Nodetuple node = static_cast<const py::tuple>(tuple[1]);
        return std::unique_ptr<const AbstractBooleanNode<AVariableManager>>(new UnaryRelationalNode<AVariableManager>(node));
      } else if (node_type == NodeType::BinaryRelationalNode) {
        if (py::len(tuple) != 4) B2FATAL("BinaryRelationalNode tuple has to have length 4." << LogVar("actual length", py::len(tuple)));
        Nodetuple left_node = static_cast<const py::tuple>(tuple[1]);
        Nodetuple right_node = static_cast<const py::tuple>(tuple[2]);
        ComparisonOperator coperator = static_cast<ComparisonOperator>(static_cast<int>(py::extract<int>(tuple[3])));
        return std::unique_ptr<const AbstractBooleanNode<AVariableManager>>(new BinaryRelationalNode<AVariableManager>(left_node,
               right_node, coperator));
      } else if (node_type == NodeType::TernaryRelationalNode) {
        if (py::len(tuple) != 6) B2FATAL("TernaryRelationalNode tuple has to have length 6." << LogVar("actual length", py::len(tuple)));
        Nodetuple left_node = static_cast<const py::tuple>(tuple[1]);
        Nodetuple center_node = static_cast<const py::tuple>(tuple[2]);
        Nodetuple right_node = static_cast<const py::tuple>(tuple[3]);
        ComparisonOperator lc_coperator = static_cast<ComparisonOperator>(static_cast<int>(py::extract<int>(tuple[4])));
        ComparisonOperator cr_coperator = static_cast<ComparisonOperator>(static_cast<int>(py::extract<int>(tuple[5])));
 
        return std::unique_ptr<const AbstractBooleanNode<AVariableManager>>(new TernaryRelationalNode<AVariableManager>(left_node,
               center_node, right_node,
               lc_coperator, cr_coperator));
      } else {
        throw std::runtime_error("error NodeFactory::compile_boolean_node: got invalid boolean NodeType.");
      }
    }

compile_expression_node()

static std::unique_ptr<const AbstractExpressionNode<AVariableManager> > compile_expression_node ( Nodetuple  tuple )

inlinestatic

This template function creates a ExpressionNode from a boost::python::tuple The Python Parser encodes the node type as int in the first argument of each tuple.

Node types are decoded via the NodeType enum defined in framework/utilities/include/AbstractNodes.h e.g (9, 1.2) is a DataNode<double> with value 1.2 List of Nodes:

• UnaryExpressionNode
• BinaryExpressionNode
• DataNode<double>
• DataNode<int>
• DataNode<bool>

Definition at line 141 of file NodeFactory.h.

---

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

• framework/utilities/include/NodeFactory.h