InfixToPostfix.h

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#ifndef INFIXTOPOSTFIX_H_
#define INFIXTOPOSTFIX_H_
 
#include <stack>
#include <iostream>
 
#include <QList>
#include <QString>
#include <QRegularExpression>
 
namespace Isis {
  class InfixOperator;
  class InfixFunction;

  class InfixToPostfix {
    public:
      InfixToPostfix();
      virtual ~InfixToPostfix();
 
      QString convert(const QString &infix);
      QString tokenizeEquation(const QString &equation);
 
    protected:
 
      virtual bool isKnownSymbol(QString representation);
      virtual InfixOperator *findOperator(QString representation);
 
      QList<InfixOperator *> p_operators;
 
    private:
      void initialize();
      void uninitialize();
 
      QString formatFunctionCalls(QString equation);
      QString cleanSpaces(QString equation);
 
      void closeParenthesis(QString &postfix, std::stack<InfixOperator> &theStack);
      void addOperator(QString &postfix, const InfixOperator &op, std::stack<InfixOperator> &theStack);
      bool isFunction(QString representation);
      void checkArgument(QString funcName, int argNum, QString argument);
  };

  class InfixOperator {
    public:
      InfixOperator(int prec, QString inString, bool isFunc = false) {
        m_precedence = prec;
        m_inputString = inString;
        m_outputString = inString;
        m_isFunction = isFunc;
      }
 
      InfixOperator(int prec, QString inString, QString outString,
                    bool isFunc = false) {
        m_precedence = prec;
        m_inputString = inString;
        m_outputString = outString;
        m_isFunction = isFunc;
      }
 
      const QString &inputString() const {
        return m_inputString;
      }
 
      const QString &outputString() const {
        return m_outputString;
      }
 
      int precedence() const {
        return m_precedence;
      }
 
      bool isFunction() const {
        return m_isFunction;
      }
 
 
    private:
      int m_precedence;
      QString m_inputString;
      QString m_outputString;
      bool m_isFunction;
  };
 

  class InfixFunction : public InfixOperator {
    public:
      InfixFunction(QString inString, int argCount) :
        InfixOperator(-1, inString, true) {
        m_numArguments = argCount;
      }
 
      InfixFunction(QString inString, QString outString, int argCount) :
        InfixOperator(-1, inString, outString, true) {
        m_numArguments = argCount;
      }
 
      int argumentCount() const {
        return m_numArguments;
      }
 
    private:
      int m_numArguments;
  };
};
 
#endif