GeneralCut.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Keck, Nils Braun                                  *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <framework/utilities/Conversion.h>
 
#include <string>
#include <vector>
#include <memory>
 
#include <boost/algorithm/string.hpp>
#include <sstream>
 
#include <iostream>
#include <stdexcept>
 
 
namespace Belle2 {
  unsigned long int findMatchedParenthesis(std::string str, char open = '[', char close = ']');
 
  std::vector<std::string> splitOnDelimiterAndConserveParenthesis(std::string str, char delimiter, char open, char close);
 
  unsigned long int findIgnoringParenthesis(std::string str, std::string pattern, unsigned int begin = 0);
 
  bool almostEqualFloat(const float& a, const float& b);
 
  bool almostEqualDouble(const double& a, const double& b);
 
  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)
    {
      return std::unique_ptr<GeneralCut>(new GeneralCut(cut));
    }
    bool check(const Object* p) const
    {
      switch (m_operation) {
        case EMPTY:
          return true;
        case NONE:
          return this->get(p);
        case AND:
          return m_left->check(p) and m_right->check(p);
        case OR:
          return m_left->check(p) or m_right->check(p);
        case LT:
          return m_left->get(p) < m_right->get(p);
        case LE:
          return m_left->get(p) <= m_right->get(p);
        case GT:
          return m_left->get(p) > m_right->get(p);
        case GE:
          return m_left->get(p) >= m_right->get(p);
        case EQ:
          return almostEqualDouble(m_left->get(p), m_right->get(p));
        case NE:
          return not almostEqualDouble(m_left->get(p), m_right->get(p));
      }
      throw std::runtime_error("Cut string has an invalid format: Invalid operation");
      return false;
    }
 
    void print() const
    {
      switch (m_operation) {
        case EMPTY: std::cout << "EMPTY" << std::endl; break;
        case NONE: std::cout << "NONE" << std::endl; break;
        case AND: std::cout << "AND" << std::endl; break;
        case OR: std::cout << "OR" << std::endl; break;
        case LT: std::cout << "LT" << std::endl; break;
        case LE: std::cout << "LE" << std::endl; break;
        case GT: std::cout << "GT" << std::endl; break;
        case GE: std::cout << "GE" << std::endl; break;
        case EQ: std::cout << "EQ" << std::endl; break;
        case NE: std::cout << "NE" << std::endl; break;
      }
      if (m_left != nullptr) {
        std::cout << "Left " << std::endl;
        m_left->print();
        std::cout << "End Left" << std::endl;
      }
      if (m_right != nullptr) {
        std::cout << "Right " << std::endl;
        m_right->print();
        std::cout << "End Right" << std::endl;
      }
    }
 
    std::string decompile() const
    {
      std::stringstream stringstream;
      if (m_operation == EMPTY) {
        return "";
      } else if (m_left != nullptr and m_right != nullptr) {
 
        stringstream << "[";
        stringstream << m_left->decompile();
 
        switch (m_operation) {
          case AND: stringstream << " and "; break;
          case OR: stringstream << " or "; break;
          case LT: stringstream << " < "; break;
          case LE: stringstream << " <= "; break;
          case GT: stringstream << " > "; break;
          case GE: stringstream << " >= "; break;
          case EQ: stringstream << " == "; break;
          case NE: stringstream << " != "; break;
          default: throw std::runtime_error("Cut string has an invalid format: Operator does not support left and right!"); break;
        }
 
        stringstream << m_right->decompile();
        stringstream << "]";
 
      } else if (m_left == nullptr and m_right == nullptr) {
        switch (m_operation) {
          case NONE:
            if (m_isNumeric) {
              stringstream << m_number;
            } else if (m_var != nullptr) {
              stringstream << m_var->name;
            } else {
              throw std::runtime_error("Cut string has an invalid format: Variable is empty!");
            }
            break;
          default: throw std::runtime_error("Cut string has an invalid format: Invalid operator without left and right!"); break;
        }
      } else {
        throw std::runtime_error("Cut string has an invalid format: invalid combination of left and right!");
      }
 
      return stringstream.str();
    }
 
 
  private:
    explicit GeneralCut(std::string str)
    {
      str = preprocess(str);
      if (str.empty()) {
        m_operation = EMPTY;
        return;
      }
 
      if (not processLogicConditions(str)) {
        if (not processTernaryNumericConditions(str)) {
          if (not processBinaryNumericConditions(str)) {
            m_operation = NONE;
            try {
              m_number = Belle2::convertString<double>(str);
              m_isNumeric = true;
            } catch (std::invalid_argument&) {
              m_isNumeric = false;
              processVariable(str);
            }
          }
        }
      }
    }
 
    GeneralCut(const GeneralCut&) = delete;
 
    GeneralCut& operator=(const GeneralCut&) = delete;
 
    std::string preprocess(std::string str) const
    {
      boost::algorithm::trim(str);
 
      while (str.size() > 1 and findMatchedParenthesis(str) == str.size() - 1) {
        str = str.substr(1, str.size() - 2);
        boost::algorithm::trim(str);
      }
 
      return str;
    }
 
    bool processLogicConditions(std::string str)
    {
      unsigned long int begin = findMatchedParenthesis(str);
      unsigned long int pos = 0;
 
      if ((pos =  findIgnoringParenthesis(str, " or ", begin)) != std::string::npos) {
        m_operation = OR;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 4)));
        return true;
      }
 
      if ((pos =  findIgnoringParenthesis(str, " and ", begin)) != std::string::npos) {
        m_operation = AND;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 5)));
        return true;
      }
 
      return false;
    }
 
    bool processBinaryNumericConditions(std::string str)
    {
      unsigned long int pos = 0;
      if ((pos =  findIgnoringParenthesis(str, "<=")) != std::string::npos) {
        m_operation = LE;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 2)));
        return true;
      }
      if ((pos =  findIgnoringParenthesis(str, "<")) != std::string::npos) {
        m_operation = LT;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 1)));
        return true;
      }
      if ((pos =  findIgnoringParenthesis(str, ">=")) != std::string::npos) {
        m_operation = GE;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 2)));
        return true;
      }
      if ((pos =  findIgnoringParenthesis(str, ">")) != std::string::npos) {
        m_operation = GT;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 1)));
        return true;
      }
      if ((pos =  findIgnoringParenthesis(str, "==")) != std::string::npos) {
        m_operation = EQ;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 2)));
        return true;
      }
      if ((pos =  findIgnoringParenthesis(str, "!=")) != std::string::npos) {
        m_operation = NE;
        m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos)));
        m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos + 2)));
        return true;
      }
 
      return false;
    }
 
    bool processTernaryNumericConditions(std::string str)
    {
      for (auto& c : {"<", ">", "!", "="}) {
 
        unsigned long int pos1 = 0;
        unsigned long int pos2 = 0;
 
        if (((pos1 =  findIgnoringParenthesis(str, c)) != std::string::npos) and
            ((pos2 =  findIgnoringParenthesis(str, "<", pos1 + 2)) != std::string::npos
             or (pos2 =  findIgnoringParenthesis(str, ">", pos1 + 2)) != std::string::npos
             or (pos2 =  findIgnoringParenthesis(str, "!", pos1 + 2)) != std::string::npos
             or (pos2 =  findIgnoringParenthesis(str, "=", pos1 + 2)) != std::string::npos)) {
          m_operation = AND;
          m_left = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(0, pos2)));
          if (str[pos1 + 1] == '=')
            pos1++;
          m_right = std::unique_ptr<GeneralCut>(new GeneralCut(str.substr(pos1 + 1)));
          return true;
        }
      }
 
      return false;
    }
 
    void processVariable(const std::string& str)
    {
      AVariableManager& manager = AVariableManager::Instance();
      m_var = manager.getVariable(str);
      if (m_var == nullptr) {
        throw std::runtime_error(
          "Cut string has an invalid format: Variable not found: " + str);
      }
    }
 
    double get(const Object* p) const
    {
      if (m_isNumeric) {
        return m_number;
      } else 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");
      }
    }
 
    enum Operation {
      EMPTY = 0,
      NONE,
      AND,
      OR,
      LT,
      LE,
      GT,
      GE,
      EQ,
      NE,
    } m_operation; 
    const Var* m_var; 
    double m_number; 
    bool m_isNumeric; 
    std::unique_ptr<GeneralCut> m_left; 
    std::unique_ptr<GeneralCut> m_right; 
  };
}