InlineInfixToPostfix.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "InlineInfixToPostfix.h"
 
// Qt library
#include <QString>
#include <QVector>
 
// other ISIS
#include "IException.h"
#include "IString.h"
 
namespace Isis {
  InlineInfixToPostfix::InlineInfixToPostfix() : InfixToPostfix() { 
    initialize();
  }
 
 
  InlineInfixToPostfix::~InlineInfixToPostfix() { 
  }
 
 
  bool InlineInfixToPostfix::isKnownSymbol(QString representation) {
 
    if ( representation.isEmpty() ) return (false);
 
    // not an empty string
    if ( InfixToPostfix::isKnownSymbol(representation) ) { 
      return (true); 
    }
 
    // not known symbol from parent class
    if ( isScalar(representation) ) { 
      return (false); 
    }
 
    // not scalar, the only thing left is a variable...
    return isVariable(representation);
  }
 
 
  InfixOperator *InlineInfixToPostfix::findOperator(QString token) {
    try {
      return InfixToPostfix::findOperator(token);
    }
    catch(IException &e) {
      if ( isVariable(token) ) { 
        // If the token is not a scalar, the isVariable() method will assume it's a variable.
        // Then the token is added it to the variables list and an InfixFunction from this token
        // is added to the operators.
        // Now that is has been added to the operators list, we can call findOperator() again and
        // should find this representation in the list.
        return (findOperator(token)); 
      }
      else {
        QString msg = "The token '" + token 
                      + "' is not recognized as an operator, function or variable.";
        throw IException(e, IException::User, msg, _FILEINFO_);
      }
    }
  
  }
 
 
  void InlineInfixToPostfix::initialize() {
    p_operators.push_back(new InfixOperator(1, "%")); 
    p_operators.push_back(new InfixFunction("mod", 2));
    p_operators.push_back(new InfixFunction("fmod", 2));
  
    p_operators.push_back(new InfixOperator(1, "&"));
    p_operators.push_back(new InfixOperator(1, "and"));
 
    p_operators.push_back(new InfixOperator(1, "&&"));
  
    p_operators.push_back(new InfixOperator(1, "|"));
    p_operators.push_back(new InfixOperator(1, "or"));
 
    p_operators.push_back(new InfixOperator(1, "||"));
    return; 
  }
 
 
  bool InlineInfixToPostfix::exists(const QString &token) {
    return (m_variables.contains(token, Qt::CaseInsensitive));
  }
 
 
  bool InlineInfixToPostfix::isScalar(const QString &token) {
 
    // NOTE: The following checks are commented out due to redundancy
    //       This is a private method only called from isKnownSymbol()
    //       and all of these conditions have already been checked.
    // if (token.isEmpty()) return (false); 
    // if (InfixToPostfix::isKnownSymbol(token)) return (false);
 
    try {
      Isis::toDouble(token);
      return (true);
    }
    catch (IException &) {
      return (false);
    }
  }
 
 
  bool InlineInfixToPostfix::isVariable(const QString &token) {
 
    // NOTE: The following checks are commented out due to redundancy
    //       This is a private method only called from isKnownSymbol()
    //       and findOperator().
    //       All of these conditions have already been checked for
    //       isKnownSymbol().
    // if (isScalar(token)) return (false);
    // if (InfixToPostfix::isKnownSymbol(token)) return (false);
 
    if (token.isEmpty()) return (false); 
 
    m_variables.push_back(token);
    p_operators.push_back(new InfixFunction(token,  0));
    return (true);
  }
 
} // Namespace Isis