Expression.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2009 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidAPI/DllConfig.h"
 
#ifndef Q_MOC_RUN
#include <memory>
#endif
 
#include <map>
#include <stdexcept>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace Mantid {
namespace API {
class MANTID_API_DLL Expression {
public:
  class ParsingError : public std::runtime_error {
  public:
    ParsingError(const std::string &msg, const std::string &expr, size_t i);
    ParsingError(const std::string &msg);
  };
 
  Expression();
  Expression(const std::vector<std::string> &ops);
  Expression(const std::vector<std::string> &binary, const std::unordered_set<std::string> &unary);
  Expression(const Expression &expr);
  Expression &operator=(const Expression &expr);
  void parse(const std::string &str);
  void logPrint(const std::string &pads = "") const;
  std::string str() const;
  bool isFunct() const { return !m_terms.empty(); }
  std::string name() const { return m_funct; }
  std::string operator_name() const { return m_op; }
  const std::vector<Expression> &terms() const { return m_terms; }
  size_t size() const { return m_terms.size(); }
  using iterator = std::vector<Expression>::const_iterator;
 
  iterator begin() const { return m_terms.begin(); }
  iterator end() const { return m_terms.end(); }
  const Expression &operator[](size_t i) const { return m_terms.at(i); }
  const Expression &bracketsRemoved() const;
  std::unordered_set<std::string> getVariables() const;
  void renameAll(const std::string &oldName, const std::string &newName);
  void rename(const std::string &newName);
 
  void toList(const std::string &sep = ",");
 
  static const std::vector<std::string> DEFAULT_OPS_STR;
 
private:
  Expression(const Expression *pexpr);
  struct Token {
    Token(size_t i, size_t j, size_t k, size_t p) : is(i), ie(j), is1(k), prec(p) {}
    size_t is;   
    size_t ie;   
    size_t is1;  
    size_t prec; 
  };
  using Tokens = std::vector<Token>;
  std::string GetToken(size_t i);
  std::string GetOp(size_t i);
  void tokenize();
  void setFunct(const std::string &name);
  static void trim(std::string &str);
 
  Tokens m_tokens;    
  std::string m_expr; 
 
  std::string m_funct;             
  std::string m_op;                
  std::vector<Expression> m_terms; 
 
  struct Operators {
    std::vector<std::string> binary;          
    std::unordered_set<std::string> unary;    
    std::map<std::string, size_t> precedence; 
    std::unordered_set<char> symbols;         
    std::map<std::string, char> op_number;    
  };
 
  size_t op_prec(const std::string &op) const;
  void add_operators(const std::vector<std::string> &ops);
  void add_unary(const std::unordered_set<std::string> &ops);
  bool is_unary(const std::string &op) const;
  bool is_op_symbol(const char c) const;
  std::shared_ptr<Operators> m_operators; 
};
 
} // namespace API
} // namespace Mantid