ExpressionParsing::BoundaryConditionFunctor Struct Reference

#include <nimble_expression_parser.h>

Public Member Functions
	BoundaryConditionFunctor ()
	BoundaryConditionFunctor (const std::string &equation)
	BoundaryConditionFunctor (const BoundaryConditionFunctor &other)
BoundaryConditionFunctor &	operator= (const BoundaryConditionFunctor &other)
BoundaryConditionFunctor &	operator= (const std::string &equation)
double	eval ()
double	eval (double x, double y, double z, double t)
double	operator() (double x, double y, double z, double t)
	~BoundaryConditionFunctor ()

Public Attributes
double	x = 0
double	y = 0
double	z = 0
double	t = 0
EquationContext *	context
RealValuedExpression *	expression = nullptr
std::string	equation

Constructor & Destructor Documentation

BoundaryConditionFunctor() [1/3]

ExpressionParsing::BoundaryConditionFunctor::BoundaryConditionFunctor ( )

inline

: context(0) {}  // Sets context to nil

BoundaryConditionFunctor() [2/3]

ExpressionParsing::BoundaryConditionFunctor::BoundaryConditionFunctor ( const std::string & equation )

inline

  {
    if (equation == "") {
      // Acts as default constructor if given an empty string
      context = 0;
      return;
    }
    try {
      context = new EquationContext();
      // Usage: context->AddVarible(name, reference);
      context->AddVarible("x", x);  // Passes a reference to x
      context->AddVarible("y", y);  // Passes a reference to y
      context->AddVarible("z", z);  // Passes a reference to z
      context->AddVarible("t", t);  // Passes a reference to t
      // Creates the Computable Expression Object
      expression = context->ParseEquation(equation);
      // Optimizes the Computable Expression Object
      expression     = expression->optimize(context->mem);
      this->equation = equation;  // Stores a copy of the equation
    } catch (std::invalid_argument arg) {
      if (context) delete context;
      context = 0;
      throw arg;
    }
  }

BoundaryConditionFunctor() [3/3]

ExpressionParsing::BoundaryConditionFunctor::BoundaryConditionFunctor ( const BoundaryConditionFunctor & other )

inline

: BoundaryConditionFunctor(other.equation) {}

~BoundaryConditionFunctor()

ExpressionParsing::BoundaryConditionFunctor::~BoundaryConditionFunctor ( )

inline

  {
    if (context) delete context;
    // RealValuedExpression* expression is managed by the EquationContext,
    // And will be destroyed when "context" is deleted.
  }

Member Function Documentation

eval() [1/2]

double ExpressionParsing::BoundaryConditionFunctor::eval ( )

inline

  {
    if (!expression) {
      throw std::invalid_argument(
          "Error in BoundaryConditionFunctor::eva(), expression pointer is "
          "null.");
    }
    return *expression;
  }

eval() [2/2]

double ExpressionParsing::BoundaryConditionFunctor::eval ( double x, double y, double z, double t )

inline

  {
    this->x = x;
    this->y = y;
    this->z = z;
    this->t = t;
    if (!expression) {
      throw std::invalid_argument(
          "Error in BoundaryConditionFunctor::eva(), expression pointer is "
          "null.");
    }
    return *expression;
  }

operator()()

double ExpressionParsing::BoundaryConditionFunctor::operator() ( double x, double y, double z, double t )

inline

  {
    this->x = x;
    this->y = y;
    this->z = z;
    this->t = t;
    if (!expression) {
      throw std::invalid_argument(
          "Error in BoundaryConditionFunctor::eva(), expression pointer is "
          "null.");
    }
    return *expression;  // Evaluates the Computable Expression Object
  }

operator=() [1/2]

BoundaryConditionFunctor & ExpressionParsing::BoundaryConditionFunctor::operator= ( const BoundaryConditionFunctor & other )

inline

  {
    return *this = other.equation;
  }

operator=() [2/2]

BoundaryConditionFunctor & ExpressionParsing::BoundaryConditionFunctor::operator= ( const std::string & equation )

inline

  {
    EquationContext* old_context = context;
    try {
      context = new EquationContext();
      context->AddVarible("x", x);
      context->AddVarible("y", y);
      context->AddVarible("z", z);
      context->AddVarible("t", t);
      expression     = context->ParseEquation(equation);
      expression     = expression->optimize(context->mem);
      this->equation = equation;
      if (old_context) delete old_context;
      return *this;
    } catch (std::invalid_argument arg) {
      if (context) delete context;
      context = old_context;
      throw arg;
    }
  }

Member Data Documentation

context

EquationContext* ExpressionParsing::BoundaryConditionFunctor::context

equation

std::string ExpressionParsing::BoundaryConditionFunctor::equation

expression

RealValuedExpression* ExpressionParsing::BoundaryConditionFunctor::expression = nullptr

t

double ExpressionParsing::BoundaryConditionFunctor::t = 0

x

double ExpressionParsing::BoundaryConditionFunctor::x = 0

y

double ExpressionParsing::BoundaryConditionFunctor::y = 0

z

double ExpressionParsing::BoundaryConditionFunctor::z = 0

---

The documentation for this struct was generated from the following file:

• src/nimble_expression_parser.h