GeneralCut.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 <boost/python.hpp>
#include <framework/utilities/CutNodes.h>
#include <framework/utilities/NodeFactory.h>
 
#include <string>
#include <memory>
 
#include <sstream>
 
#include <iostream>
#include <stdexcept>
 
#include <variant>
 
namespace py = boost::python;
typedef const py::tuple& Nodetuple;
 
namespace Belle2 {
  template <class AVariableManager>
  class GeneralCut {
    typedef typename AVariableManager::Object Object;
    typedef typename AVariableManager::Var Var;
 
  public:
    static std::unique_ptr<GeneralCut> compile(const std::string& cut)
    {
      // Here we parse
      Py_Initialize();
      try {
        py::object b2parser_namespace = py::import("b2parser");
        py::tuple tuple = py::extract<py::tuple>(b2parser_namespace.attr("parse")(cut));
        return std::unique_ptr<GeneralCut>(new GeneralCut(tuple));
      } catch (py::error_already_set&) {
        PyErr_Print();
        B2FATAL("Parsing error on cutstring:\n" + cut);
      }
    }
    bool check(const Object* p) const
    {
      if (m_root != nullptr) return m_root->check(p);
      throw std::runtime_error("GeneralCut m_root is not initialized.");
    }
 
    void print() const
    {
      m_root->print();
    }
 
    std::string decompile() const
    {
      std::stringstream stringstream;
      stringstream << m_root->decompile();
      return stringstream.str();
    }
 
 
  private:
    explicit GeneralCut(Nodetuple tuple) : m_root{NodeFactory::compile_boolean_node<AVariableManager>(tuple)} {}
 
    GeneralCut(const GeneralCut&) = delete;
 
    GeneralCut& operator=(const GeneralCut&) = delete;
 
    std::unique_ptr<const AbstractBooleanNode<AVariableManager>> m_root; 
  };
}