InlineCalculator.h

#ifndef InlineCalculator_h
#define InlineCalculator_h
 
/* SPDX-License-Identifier: CC0-1.0 */
 
// parent class
#include "Calculator.h"
 
#include <QList>
#include <QMap>
#include <QString>
#include <QVector>
 
class QVariant;
 
namespace Isis {
 
  class CalculatorVariablePool;
  class FxBinder;
  class ParamaterFx;
  class VoidFx;
 
  #define CALL_MEMBER_FN(object, ptrToMember)   ((object).*(ptrToMember))
 
  class InlineCalculator : public Calculator {
 
    public:
 
      InlineCalculator();
      InlineCalculator(const QString &equation);
      virtual ~InlineCalculator();
 
      int size() const;
 
      QString equation() const;
      bool compile(const QString &equation);
 
      QVector<double> evaluate(CalculatorVariablePool *variablePool);
      QVector<double> evaluate();
 
    protected:
      typedef FxBinder *FxTypePtr;
 
      // Implementations of local/new functions
      void scalar(const QVariant &scalar);
      void variable(const QVariant &variable);
 
      void floatModulus();
      void radians();
      void degrees();
      void logicalOr();
      void logicalAnd();
      void pi();
      void eConstant();
 
      virtual QString toPostfix(const QString &equation) const;
      bool isScalar(const QString &scalar);
      bool isVariable(const QString &str);
 
      // Derived classes can be added with these methods for customization.
      // See FxBinder().
      bool fxExists(const QString &fxname) const;
      FxTypePtr addFunction(FxTypePtr function);
 
      virtual bool orphanTokenHandler(const QString &token);
 
    private:
      typedef QVector<FxTypePtr>       FxEqList;
      typedef QMap<QString, FxTypePtr> FxPoolType;
 
      void pushVariables(CalculatorVariablePool *variablePool);
      CalculatorVariablePool *variables();
      void popVariables();
 
      FxTypePtr find(const QString &fxname);
      void initialize();
      void destruct();
 
      FxEqList    m_functions; 
      FxPoolType  m_fxPool;    
      QString     m_equation;  
      QList<CalculatorVariablePool *> m_variablePoolList; 
 
  };
 
 
  class CalculatorVariablePool {
    public:
    CalculatorVariablePool();
    ~CalculatorVariablePool();
   
    virtual bool exists(const QString &variable) const;
    virtual QVector<double> value(const QString &variable,
                                  const int &index = 0) const;
    virtual void add(const QString &key, QVector<double> &values);
  };
 
 
  class FxBinder {
    public:
      FxBinder(const QString &name);
      virtual ~FxBinder();
 
      QString name() const;
      void execute();
      void operator()();
 
      virtual void dispatch() = 0;
      virtual QVariant args();
 
    private:
      QString m_name; 
  };
 
 
  class InlineVoidFx : public FxBinder {
    public:
      typedef void (InlineCalculator::*calcOp)();
       
      InlineVoidFx(const QString &name, calcOp function,
                   InlineCalculator *calculator);
      virtual ~InlineVoidFx();
      void dispatch();
 
    private:
      calcOp  m_func;           
      InlineCalculator *m_calc; 
  };
 
 
  class ParameterFx : public FxBinder {
    public:
      typedef void (InlineCalculator::*calcOp)(const QVariant &arg);
       
      ParameterFx(const QString &name, calcOp function,
                  InlineCalculator *calculator);
      virtual ~ParameterFx();
      void dispatch();
 
    private:
      calcOp  m_func;           
      InlineCalculator *m_calc; 
  };
 
 
  class VoidFx : public FxBinder {
    public:
      typedef void (Calculator::*calcOp)();
       
      VoidFx(const QString &name, calcOp function,
             InlineCalculator *calculator);
      virtual ~VoidFx();
      void dispatch();
 
    private:
      calcOp  m_func;           
      InlineCalculator *m_calc; 
  };
 
  // this is a global method, outside of all classes.
  double floatModulusOperator(double a, double b);
 
} // Namespace Isis
 
#endif