FormulaParser.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 <framework/utilities/Utils.h>
#include <sstream>
#include <variant>
#include <stack>
#include <string>
 
 
namespace Belle2 {
  class FormulaParserBase {
  public:
    enum class EOperator : unsigned char {
      c_noop               = 0x00, 
      c_roundBracketOpen   = 0x01, 
      c_roundBracketClose  = 0x02, 
      c_squareBracketOpen  = 0x03, 
      c_squareBracketClose = 0x04, 
      c_plus               = 0x11, 
      c_minus              = 0x12, 
      c_multiply           = 0x21, 
      c_divide             = 0x22, 
      c_power              = 0x31  
    };
 
    enum class ENumberStatus {
      c_Invalid,      
      c_Empty,        
      c_Sign,         
      c_Int,          
      c_Dot,          
      c_LeadingDot,   
      c_Float,        
      c_Exponent,     
      c_ExponentSign, 
      c_Scientific    
    };
 
    typedef std::variant<std::string, double> InputToken;
 
    static char operatorToChar(EOperator op) noexcept;
 
    static double applyOperator(EOperator op, double a, double b);
 
    static ENumberStatus checkNumber(ENumberStatus current, char next);
 
    FormulaParserBase() = default;
 
    virtual ~FormulaParserBase() = default;
  protected:
    static void assertOperatorUsable(size_t stacksize);
    virtual void executeOperator(EOperator op) = 0;
    virtual void addVariable(const InputToken& token) = 0;
    void processString(const std::string& formula);
    [[noreturn]] void raiseError(const std::runtime_error& e);
  private:
    void addOperator(EOperator op);
    void flushCurrentVariable();
    void flushPendingOperators();
    EOperator checkForOperator(char next);
    bool m_lastTokenWasOperator;
    std::istringstream m_buffer;
    std::string m_currentVariableName;
    ENumberStatus m_currentVariableNameNumberStatus;
    std::stack<EOperator> m_operatorStack;
  };
 
 
  template<class VariableConstructor> class FormulaParser: public FormulaParserBase {
  public:
    typedef typename VariableConstructor::type VariableType;
    typedef std::variant<VariableType, double> OutputToken;
 
    VariableType parse(const std::string& formula)
    {
      try {
        // clear stacks
        std::stack<OutputToken>().swap(m_outputStack);
        // process
        processString(formula);
        // sanity checks
        if (m_outputStack.empty())
          throw std::runtime_error("empty string");
        if (m_outputStack.size() != 1)
          throw std::runtime_error("could not parse, stack size not 1, probably a bug, please report");
        // so return the object
        return std::visit(Utils::VisitOverload{
          [](const VariableType & v) -> VariableType {return v;},
          [](double d) -> VariableType { return VariableConstructor()(d); }
        }, m_outputStack.top());
      } catch (std::runtime_error& e) {
        // add context to error
        raiseError(e);
      }
    }
  protected:
    void executeOperator(EOperator op) override
    {
      assertOperatorUsable(m_outputStack.size());
      // so far all a binary operators
      // cppcheck-suppress unreadVariable; used in lambda below
      OutputToken op2 = m_outputStack.top(); m_outputStack.pop();
      // cppcheck-suppress unreadVariable; used in lambda below
      OutputToken op1 = m_outputStack.top(); m_outputStack.pop();
      // and apply ...
      m_outputStack.push(std::visit(Utils::VisitOverload {
        // eagerly apply operations if both operands are numbers
        [op](double a, double b) -> OutputToken { return OutputToken(applyOperator(op, a, b)); },
        // otherwise defer to variable constructor
        [op](auto a, auto b) -> OutputToken { return VariableConstructor()(op, a, b); },
      }, op1, op2));
    }
 
    void addVariable(const InputToken& var) override
    {
      m_outputStack.push(std::visit(Utils::VisitOverload {
        // if the variable is a string its an identifier and we have to construct a variable from it
        [](const std::string & s) -> OutputToken { return VariableConstructor()(s); },
        // otherwise keep as is
        [](auto s) -> OutputToken { return s; }
      }, var));
    }
 
    std::stack<OutputToken> m_outputStack;
  };
 
  struct StringFormulaConstructor {
    typedef std::string type;
    typedef FormulaParserBase::EOperator Op;
 
    type operator()(const std::string& name) { return "'" + name + "'"; }
    type operator()(double value) { return std::to_string(value); }
    type operator()(Op op, const type& a, const type& b)
    {
      return "(" + a + FormulaParserBase::operatorToChar(op) + b + ")";
    }
    type operator()(Op op, double a, const type& b) { return (*this)(op, std::to_string(a), b); }
    type operator()(Op op, const type& a, double b) { return (*this)(op, a, std::to_string(b)); }
  };
 
}