vtkExprTkFunctionParser.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkExprTkFunctionParser_h
#define vtkExprTkFunctionParser_h

#include "vtkCommonMiscModule.h" // For export macro
#include "vtkObject.h"

#include <string> // needed for string.
#include <vector> // needed for vector

// forward declarations for ExprTk tools
VTK_ABI_NAMESPACE_BEGIN
struct vtkExprTkTools;

class VTKCOMMONMISC_EXPORT vtkExprTkFunctionParser : public vtkObject
{
public:
  vtkTypeMacro(vtkExprTkFunctionParser, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkExprTkFunctionParser* New();

  vtkMTimeType GetMTime() override;

  vtkGetMacro(ResultSize, int);


  void SetFunction(const char* function);
  const char* GetFunction() { return this->Function.c_str(); }

  int IsScalarResult();

  int IsVectorResult();

  double GetScalarResult();


  double* GetVectorResult() VTK_SIZEHINT(this->GetResultSize());
  void GetVectorResult(double* result)
  {
    double* r = this->GetVectorResult();
    for (int i = 0; i < this->ResultSize; ++i)
    {
      result[i] = r[i];
    }
  }


  void SetScalarVariableValue(const std::string& variableName, double value);
  void SetScalarVariableValue(int i, double value);


  double GetScalarVariableValue(const std::string& variableName);
  double GetScalarVariableValue(int i);


  void SetVectorVariableValue(
    const std::string& variableName, double xValue, double yValue, double zValue)
  {
    double values[3] = { xValue, yValue, zValue };
    this->SetVectorVariableValue(variableName, values, 3);
  }
  void SetVectorVariableValue(const std::string& variableName, double* values, int size = 3);
  void SetVectorVariableValue(int i, double xValue, double yValue, double zValue)
  {
    double values[3] = { xValue, yValue, zValue };
    this->SetVectorVariableValue(i, values, 3);
  }
  void SetVectorVariableValue(int i, double values[3], int size = 3);


  double* GetVectorVariableValue(const std::string& variableName) VTK_SIZEHINT(3);
  void GetVectorVariableValue(const std::string& variableName, double value[3])
  {
    double* r = this->GetVectorVariableValue(variableName);
    value[0] = r[0];
    value[1] = r[1];
    value[2] = r[2];
  }
  double* GetVectorVariableValue(int i) VTK_SIZEHINT(3);
  void GetVectorVariableValue(int i, double value[3])
  {
    double* r = this->GetVectorVariableValue(i);
    value[0] = r[0];
    value[1] = r[1];
    value[2] = r[2];
  }

  int GetNumberOfScalarVariables()
  {
    return static_cast<int>(this->UsedScalarVariableNames.size());
  }

  int GetScalarVariableIndex(const std::string& name);

  int GetNumberOfVectorVariables()
  {
    return static_cast<int>(this->UsedVectorVariableNames.size());
  }

  int GetVectorVariableIndex(const std::string& name);

  std::string GetScalarVariableName(int i);

  std::string GetVectorVariableName(int i);


  bool GetScalarVariableNeeded(int i);
  bool GetScalarVariableNeeded(const std::string& variableName);


  bool GetVectorVariableNeeded(int i);
  bool GetVectorVariableNeeded(const std::string& variableName);

  void RemoveAllVariables();

  void RemoveScalarVariables();

  void RemoveVectorVariables();


  vtkSetMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkGetMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkBooleanMacro(ReplaceInvalidValues, vtkTypeBool);
  vtkSetMacro(ReplacementValue, double);
  vtkGetMacro(ReplacementValue, double);

  void InvalidateFunction();

  static std::string SanitizeName(const char* name);

protected:
  vtkExprTkFunctionParser();
  ~vtkExprTkFunctionParser() override;

  enum ParseMode
  {
    DetectReturnType,
    SaveResultInVariable
  };

  int Parse(ParseMode mode);

  enum VectorReturningFunction
  {
    Cross,
    Norm
  };

  std::string FixVectorReturningFunctionOccurrences(
    VectorReturningFunction vectorReturningFunction);

  bool CheckOldFormatOfDotProductUsage();

  bool Evaluate();

  void UpdateNeededVariables();

  std::string Function;
  std::string FunctionWithUsedVariableNames;
  std::string ExpressionString;

  // original and used variables names are the same, except if the original
  // ones are not valid.
  std::vector<std::string> OriginalScalarVariableNames;
  std::vector<std::string> UsedScalarVariableNames;
  std::vector<std::string> OriginalVectorVariableNames;
  std::vector<std::string> UsedVectorVariableNames;
  // pointers for scalar and vector variables are used to enforce
  // that their memory address will not change due to a possible
  // resizing of their container (std::vector), ExprTk requires the
  // memory address of the given variable to remain the same.
  std::vector<double*> ScalarVariableValues;
  std::vector<std::vector<double>*> VectorVariableValues;
  std::vector<bool> ScalarVariableNeeded;
  std::vector<bool> VectorVariableNeeded;

  vtkTimeStamp FunctionMTime;
  vtkTimeStamp ParseMTime;

  vtkTypeBool ReplaceInvalidValues;
  double ReplacementValue;

  vtkExprTkTools* ExprTkTools;

  int ResultType;
  std::vector<double> Result;
  std::vector<double> ParserErrorResult;

private:
  vtkExprTkFunctionParser(const vtkExprTkFunctionParser&) = delete;
  void operator=(const vtkExprTkFunctionParser&) = delete;

  enum SizeModes
  {
    AutoDetected = 0,
    VectorDefined = 1
  };

  int SizeMode;
  int ResultSize;

  static SizeModes DetermineSizeMode(const std::string& function);

  vtkGetMacro(SizeMode, int);
};

VTK_ABI_NAMESPACE_END
#endif