CutNodes.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
#include <memory>
#include <iostream>
#include <functional>
 
#include <framework/utilities/AbstractNodes.h>
#include <framework/utilities/NodeFactory.h>
#include <framework/logging/Logger.h>
 
#include <boost/algorithm/string.hpp>
#include <boost/python/tuple.hpp>
 
namespace py = boost::python;
typedef const py::tuple& Nodetuple;
 
namespace Belle2 {
  bool almostEqualDouble(const double& a, const double& b);
 
  template <template <typename type> class operation>
  struct Visitor {
    bool operator()(const double& val0, const double& val1)
    {
      return operation<double> {}(val0, val1);
    }
    bool operator()(const double& val0, const int& val1)
    {
      return operation<double> {}(val0, val1);
    }
    bool operator()(const double& val0, const bool& val1)
    {
      return operation<double> {}(val0, val1);
    }
    bool operator()(const int& val0, const int& val1)
    {
      return operation<int> {}(val0, val1);
    }
    bool operator()(const int& val0, const bool& val1)
    {
      return operation<int> {}(val0, val1);
    }
    bool operator()(const int& val0, const double& val1)
    {
      return operation<double> {}(val0, val1);
    }
    bool operator()(const bool& val0, const bool& val1)
    {
      return operation<bool> {}(val0, val1);
    }
    bool operator()(const bool& val0, const double& val1)
    {
      return operation<double> {}(val0, val1);
    }
    bool operator()(const bool& val0, const int& val1)
    {
      return operation<int> {}(val0, val1);
    }
  };
 
  struct EqualVisitor {
    bool operator()(const double& val0, const double& val1)
    {
      return almostEqualDouble(val0, val1);
    }
    bool operator()(const double& val0, const int& val1)
    {
      return almostEqualDouble(val0, val1);
    }
    bool operator()(const double& val0, const bool& val1)
    {
      return almostEqualDouble(val0, val1);
    }
    bool operator()(const int& val0, const int& val1)
    {
      return std::equal_to<int> {}(val0, val1);
    }
    bool operator()(const int& val0, const bool& val1)
    {
      return std::equal_to<int> {}(val0, val1);
    }
    bool operator()(const int& val0, const double& val1)
    {
      return almostEqualDouble(val0, val1);
    }
    bool operator()(const bool& val0, const bool& val1)
    {
      return std::equal_to<bool> {}(val0, val1);
    }
    bool operator()(const bool& val0, const double& val1)
    {
      return almostEqualDouble(val0, val1);
    }
    bool operator()(const bool& val0, const int& val1)
    {
      return std::equal_to<int> {}(val0, val1);
    }
 
  };
 
 
  template<class AVariableManager>
  class UnaryBooleanNode : public AbstractBooleanNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
  public:
    bool check(const Object* p) const override
    {
      // Return negated result of child node evaluation if m_negation is true.
      if (m_negation) return !m_bnode->check(p);
 
      return m_bnode->check(p);
    }
 
    void print() const override
    {
      if (m_negation) std::cout << "not ";
      if (m_bracketized) std::cout << "[";
      m_bnode->print();
      if (m_bracketized) std::cout << "]";
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      if (m_negation) stringstream << "not "; // Add negation keyword
 
      if (m_bracketized) stringstream << "["; // Add opening bracket
      stringstream << m_bnode->decompile();
      if (m_bracketized) stringstream << "]"; // Add closing bracket
 
      return stringstream.str();
    }
    ~UnaryBooleanNode() {}
 
  private:
    friend class NodeFactory; // friend declaration so that NodeFactory can call the private constructor
    explicit UnaryBooleanNode(Nodetuple node, bool negation, bool bracketized)
      : m_bnode{NodeFactory::compile_boolean_node<AVariableManager>(node)}, m_negation{negation}, m_bracketized{bracketized}
    {
    }
 
    std::unique_ptr<const AbstractBooleanNode<AVariableManager>> m_bnode; 
    const bool m_negation; 
    const bool
    m_bracketized; 
  };
 
 
  template<class AVariableManager>
  class BinaryBooleanNode : public AbstractBooleanNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
  public:
    bool check(const Object* p) const override
    {
 
      switch (m_boperator) {
        case BooleanOperator::AND:
          return m_left_bnode->check(p) && m_right_bnode->check(p);
          break;
        case BooleanOperator::OR:
          return m_left_bnode->check(p) || m_right_bnode->check(p);
          break;
        default:
          throw std::runtime_error("BinaryBooleanNode has an invalid BooleanOperator");
      }
      return false;
    }
 
    void print() const override
    {
      m_left_bnode->print();
      injectBooleanOperatorToStream(std::cout, m_boperator);
      m_right_bnode->print();
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      stringstream << m_left_bnode->decompile(); // decompile left AbstractBooleanNode
      injectBooleanOperatorToStream(stringstream, m_boperator);
      stringstream << m_right_bnode->decompile(); // decompile right AbstractBooleanNode
 
      return stringstream.str();
    }
    ~BinaryBooleanNode() {}
 
  private:
    friend class NodeFactory; // friend declaration so that NodeFactory can call the private constructor
    explicit BinaryBooleanNode(Nodetuple left_node, Nodetuple right_node, BooleanOperator boperator)
      : m_left_bnode{NodeFactory::compile_boolean_node<AVariableManager>(left_node)}, m_right_bnode{NodeFactory::compile_boolean_node<AVariableManager>(right_node)},
        m_boperator{boperator}
    {
    }
    std::unique_ptr<const AbstractBooleanNode<AVariableManager>> m_left_bnode; 
    std::unique_ptr<const AbstractBooleanNode<AVariableManager>> m_right_bnode; 
    const BooleanOperator m_boperator; 
  };
 
  template<class AVariableManager>
  class UnaryRelationalNode : public AbstractBooleanNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
  public:
    bool check(const Object* p) const override
    {
      typename AVariableManager::VarVariant ret = m_enode->evaluate(p);
      if (std::holds_alternative<bool>(ret)) {
        return std::get<bool>(ret);
      } else if (std::holds_alternative<int>(ret)) {
        return static_cast<bool>(std::get<int>(ret));
      } else if (std::holds_alternative<double>(ret)) {
        if (static_cast<bool>(std::get<double>(ret))) {
          // nan is considered false.
          if (std::isnan(std::get<double>(ret))) {
            return false;
          }
          if (std::get<double>(ret) != 1.0)
            B2WARNING("Static casting of double value to bool in cutstring evaluation." <<  LogVar("Cut substring",
                      m_enode->decompile()) << LogVar(" Casted value", std::get<double>(ret)) << LogVar("Casted to", "true"));
        } else {
          if (std::get<double>(ret) != 0.0)
            B2WARNING("Static casting of double value to bool in cutstring evaluation." <<  LogVar("Cut substring",
                      m_enode->decompile()) << LogVar(" Casted value", std::get<double>(ret)) << LogVar("Casted to", "false"));
        }
 
        return static_cast<bool>(std::get<double>(ret));
      } else {
        throw std::runtime_error("UnaryRelationalNode should evaluate to bool.");
      }
    }
 
    void print() const override
    {
      m_enode->print();
    }
 
    std::string decompile() const override
    {
      return m_enode->decompile();
    }
    ~UnaryRelationalNode() {}
 
  private:
    friend class NodeFactory; // friend declaration so that NodeFactory can call the private constructor
    explicit UnaryRelationalNode(Nodetuple node) : m_enode{NodeFactory::compile_expression_node<AVariableManager>(node)}
    {}
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_enode; 
  };
 
  template<class AVariableManager>
  class BinaryRelationalNode : public AbstractBooleanNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
  public:
    bool check(const Object* p) const override
    {
      // Get std::variant values of children node
      typename AVariableManager::VarVariant left_eval = m_left_enode->evaluate(p);
      typename AVariableManager::VarVariant right_eval = m_right_enode->evaluate(p);
      switch (m_coperator) {
        case ComparisonOperator::EQUALEQUAL:
          return std::visit(EqualVisitor{}, left_eval, right_eval);
          break;
        case ComparisonOperator::GREATEREQUAL:
          return std::visit(Visitor<std::greater_equal> {}, left_eval, right_eval);
          break;
        case ComparisonOperator::LESSEQUAL:
          return std::visit(Visitor<std::less_equal> {}, left_eval, right_eval);
          break;
        case ComparisonOperator::GREATER:
          return std::visit(Visitor<std::greater> {}, left_eval, right_eval);
          break;
        case ComparisonOperator::LESS:
          return std::visit(Visitor<std::less> {}, left_eval, right_eval);
          break;
 
        case ComparisonOperator::NOTEQUAL:
          return !std::visit(EqualVisitor{}, left_eval, right_eval);
          break;
        default:
          throw std::runtime_error("BinaryRelationalNode has an invalid ComparisonOperator.");
      }
      return false;
    }
 
    void print() const override
    {
      m_left_enode->print();
      injectComparisonOperatorToStream(std::cout, m_coperator);
      m_right_enode->print();
    }
    std::string decompile() const override
    {
      std::stringstream stringstream;
 
      stringstream << m_left_enode->decompile();
      injectComparisonOperatorToStream(stringstream, m_coperator);
      stringstream << m_right_enode->decompile();
 
      return stringstream.str();
    }
    ~BinaryRelationalNode() {}
 
  private:
    friend class NodeFactory; // friend declaration so that NodeFactory can call the private constructor
    explicit BinaryRelationalNode(Nodetuple left_node, Nodetuple right_node, ComparisonOperator coperator)
      : m_left_enode{NodeFactory::compile_expression_node<AVariableManager>(left_node)}, m_right_enode{NodeFactory::compile_expression_node<AVariableManager>(right_node)},
        m_coperator{coperator}
    {
    }
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_left_enode; 
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_right_enode; 
    const ComparisonOperator m_coperator; 
  };
 
  template<class AVariableManager>
  class TernaryRelationalNode : public AbstractBooleanNode<AVariableManager> {
    typedef typename AbstractBooleanNode<AVariableManager>::Object Object;
  public:
    bool check(const Object* p) const override
    {
      typename AVariableManager::VarVariant left_eval = m_left_enode->evaluate(p);
      typename AVariableManager::VarVariant center_eval = m_center_enode->evaluate(p);
      typename AVariableManager::VarVariant right_eval = m_right_enode->evaluate(p);
 
      switch (m_lc_coperator) {
        case ComparisonOperator::EQUALEQUAL:
          if (not std::visit(EqualVisitor {}, left_eval, center_eval)) return false;
          break;
        case ComparisonOperator::GREATEREQUAL:
          if (not std::visit(Visitor<std::greater_equal> {}, left_eval, center_eval)) return false;
          break;
        case ComparisonOperator::LESSEQUAL:
          if (not std::visit(Visitor<std::less_equal> {}, left_eval, center_eval)) return false;
          break;
        case ComparisonOperator::GREATER:
          if (not std::visit(Visitor<std::greater> {}, left_eval, center_eval)) return false;
          break;
        case ComparisonOperator::LESS:
          if (not std::visit(Visitor<std::less> {}, left_eval, center_eval)) return false;
          break;
        case ComparisonOperator::NOTEQUAL:
          if (std::visit(EqualVisitor {}, left_eval, center_eval)) return false;
          break;
        default:
          throw std::runtime_error("TernaryRelational has an invalid m_lc_operator");
      }
      switch (m_cr_coperator) {
        case ComparisonOperator::EQUALEQUAL:
          if (not std::visit(EqualVisitor {}, center_eval, right_eval)) return false;
          break;
        case ComparisonOperator::GREATEREQUAL:
          if (not std::visit(Visitor<std::greater_equal> {}, center_eval, right_eval)) return false;
          break;
        case ComparisonOperator::LESSEQUAL:
          if (not std::visit(Visitor<std::less_equal> {}, center_eval, right_eval)) return false;
          break;
        case ComparisonOperator::GREATER:
          if (not std::visit(Visitor<std::greater> {}, center_eval, right_eval)) return false;
          break;
        case ComparisonOperator::LESS:
          if (not std::visit(Visitor<std::less> {}, center_eval, right_eval)) return false;
          break;
        case ComparisonOperator::NOTEQUAL:
          if (std::visit(EqualVisitor {}, center_eval, right_eval)) return false;
          break;
        default:
          throw std::runtime_error("TernaryRelational has an invalid m_cr_operator");
      }
      return true;
    }
    void print() const override
    {
      m_left_enode->print();
      injectComparisonOperatorToStream(std::cout, m_lc_coperator);
      m_center_enode->print();
      injectComparisonOperatorToStream(std::cout, m_cr_coperator);
      m_right_enode->print();
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      stringstream << m_left_enode->decompile();
      injectComparisonOperatorToStream(stringstream, m_lc_coperator);
      stringstream << m_center_enode->decompile();
      injectComparisonOperatorToStream(stringstream, m_cr_coperator);
      stringstream << m_right_enode->decompile();
      return stringstream.str();
    }
    ~TernaryRelationalNode() {}
 
  private:
    friend class NodeFactory;
    explicit TernaryRelationalNode(Nodetuple left_node, Nodetuple center_node, Nodetuple right_node, ComparisonOperator lc_coperator,
                                   ComparisonOperator cr_coperator)
      : m_left_enode{NodeFactory::compile_expression_node<AVariableManager>(left_node)}, m_center_enode{NodeFactory::compile_expression_node<AVariableManager>(center_node)},
        m_right_enode{NodeFactory::compile_expression_node<AVariableManager>(right_node)},  m_lc_coperator{lc_coperator},
        m_cr_coperator{cr_coperator}
    {
    }
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>>
        m_left_enode; 
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>>
        m_center_enode; 
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>>
        m_right_enode; 
    const ComparisonOperator
    m_lc_coperator; 
    const ComparisonOperator
    m_cr_coperator; 
  };
 
  template<class AVariableManager>
  class UnaryExpressionNode : public AbstractExpressionNode<AVariableManager> {
    typedef typename AbstractExpressionNode<AVariableManager>::Object Object;
  public:
    typename AVariableManager::VarVariant evaluate(const Object* p) const override
    {
      typename AVariableManager::VarVariant ret = m_enode->evaluate(p);
      if (m_unary_minus) {
        if (std::holds_alternative<int>(ret)) return -1 * std::get<int>(ret);
        if (std::holds_alternative<double>(ret)) return -1.0 * std::get<double>(ret);
        throw std::runtime_error("Attempted unary sign with boolean type value.");
      }
      return ret;
    }
    void print() const override
    {
      if (m_unary_minus) std::cout << "-";
      if (m_parenthesized) std::cout << "( ";
      m_enode->print();
      if (m_parenthesized) std::cout << " )";
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      if (m_unary_minus) stringstream << "-";
      if (m_parenthesized) stringstream << "( ";
      stringstream << m_enode->decompile();
      if (m_parenthesized) stringstream << " )";
      return stringstream.str();
    }
    ~UnaryExpressionNode() {}
 
  private:
    friend class NodeFactory;
    explicit UnaryExpressionNode(Nodetuple node, bool unary_minus, bool parenthesized) : m_enode{NodeFactory::compile_expression_node<AVariableManager>(node)},
      m_unary_minus{unary_minus}, m_parenthesized{parenthesized}
    {
    }
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_enode; 
    const bool m_unary_minus; 
    const bool m_parenthesized; 
  };
 
  template<class AVariableManager>
  class BinaryExpressionNode : public AbstractExpressionNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
  public:
    typename AVariableManager::VarVariant evaluate(const Object* p) const override
    {
      typename AVariableManager::VarVariant l_val, r_val, ret;
      l_val = m_left_enode->evaluate(p);
      r_val = m_right_enode->evaluate(p);
      switch (m_aoperation) {
        case ArithmeticOperation::PLUS:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) + std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) + std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) + std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) + std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in plus operation.");
          }
          break;
        case ArithmeticOperation::MINUS:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) - std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) - std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) - std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) - std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in minus operation.");
          }
          break;
        case ArithmeticOperation::PRODUCT:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) * std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) * std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) * std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) * std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in product operation.");
          }
          break;
        case ArithmeticOperation::DIVISION:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            // Always do double division
            double d = std::get<int>(r_val);
            ret = std::get<int>(l_val) / d;
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) / std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) / std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) / std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in division operation.");
          }
          break;
        case ArithmeticOperation::POWER:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::pow(std::get<int>(l_val), std::get<int>(r_val));
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::pow(std::get<double>(l_val), std::get<double>(r_val));
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::pow(std::get<double>(l_val), std::get<int>(r_val));
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::pow(std::get<int>(l_val), std::get<double>(r_val));
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in power operation.");
          }
          break;
        default:
          throw std::runtime_error("Operation not valid");
      }
      ret = false;
      return ret;
    }
    void print() const override
    {
      m_left_enode->print();
      injectArithmeticOperatorToStream(std::cout, m_aoperation);
      m_right_enode->print();
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      stringstream << m_left_enode->decompile();
      injectArithmeticOperatorToStream(stringstream, m_aoperation);
      stringstream << m_right_enode->decompile();
 
      return stringstream.str();
    }
    ~BinaryExpressionNode() {}
 
  private:
    friend class NodeFactory;
    explicit BinaryExpressionNode(Nodetuple left_node, Nodetuple right_node, ArithmeticOperation aoperation) : m_left_enode{NodeFactory::compile_expression_node<AVariableManager>(left_node)},
      m_right_enode{NodeFactory::compile_expression_node<AVariableManager>(right_node)},  m_aoperation{aoperation}
    {
    }
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_left_enode; 
    std::unique_ptr<const AbstractExpressionNode<AVariableManager>> m_right_enode; 
    ArithmeticOperation m_aoperation; 
  };
 
  template<class AVariableManager, typename T>
  class DataNode : public AbstractExpressionNode<AVariableManager> {
  private:
    friend class NodeFactory;
    typedef typename AbstractExpressionNode<AVariableManager>::Object Object;
    explicit DataNode(T value) : m_value{value} {};
    const T m_value; 
  public:
    typename AVariableManager::VarVariant evaluate(const Object* p) const override
    {
      (void)p;
      typename AVariableManager::VarVariant ret{m_value};
      return ret;
    }
    void print() const override
    {
      std::cout << std::boolalpha;
      std::cout << m_value;
    }
 
    std::string decompile() const override
    {
      std::stringstream stringstream;
      stringstream << std::boolalpha;
      stringstream << m_value;
      return stringstream.str();
    }
    ~DataNode() {}
 
  };
 
  template<class AVariableManager>
  class IdentifierNode : public AbstractExpressionNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
    typedef typename AVariableManager::Var Var;
  public:
    typename AVariableManager::VarVariant evaluate(const Object* p) const override
    {
      if (m_var != nullptr) {
        return m_var->function(p);
      } else {
        throw std::runtime_error("Cut string has an invalid format: Neither number nor variable name");
      }
    }
    void print() const override
    {
      std::cout << m_name;
    }
 
    std::string decompile() const override
    {
      return m_name;
    }
 
    void processVariable()
    {
      AVariableManager& manager = AVariableManager::Instance();
      m_var = manager.getVariable(m_name);
      if (m_var == nullptr) {
        throw std::runtime_error(
          "Cut string has an invalid format: Variable not found: " + m_name);
      }
    }
    ~IdentifierNode() {}
 
  private:
    friend class NodeFactory;
    explicit IdentifierNode(const std::string& name) : m_name{name}, m_var{nullptr} {processVariable();}
    const std::string m_name; 
    const Var* m_var; 
  };
 
  template<class AVariableManager>
  class FunctionNode: public AbstractExpressionNode<AVariableManager> {
    typedef typename AVariableManager::Object Object;
    typedef typename AVariableManager::Var Var;
  public:
    typename AVariableManager::VarVariant evaluate(const Object* p) const override
    {
      return m_var->function(p);
    }
    void print() const override
    {
      std::string fullname = m_name + "(" + boost::algorithm::join(m_arguments, ", ") + ")";
      std::cout << fullname;
    }
 
    std::string decompile() const override
    {
      std::string fullname = m_name + "(" + boost::algorithm::join(m_arguments, ", ") + ")";
      return fullname;
    }
 
    void processMetaVariable()
    {
      // Initialize Variable
      AVariableManager& manager = AVariableManager::Instance();
      m_var = manager.getVariable(m_name, m_arguments);
      if (m_var == nullptr) {
        auto fullname = m_name + "(" + boost::algorithm::join(m_arguments, ", ") + ")";
 
        throw std::runtime_error(
          "Cut string has an invalid format: Metavariable not found: " + fullname);
      }
    }
    ~FunctionNode() {}
 
  private:
    friend class NodeFactory;
    explicit FunctionNode(const std::string& functionName, const std::vector<std::string>& functionArguments): m_name{functionName},
      m_arguments{functionArguments}
    {processMetaVariable();}
    const std::string m_name; 
    const std::vector<std::string> m_arguments; 
    const Var* m_var; 
  };
 
 
}