Expressions.h

#pragma once
 
#include "tinyexpr.h"
 
#include <span>
#include <string>
#include <string_view>
#include <vector>
#include <unordered_map>
 
namespace Cogs
{
  namespace Core
  {
    struct ExpressionVariable
    {
      double value = 0;
 
      double min = 0;
      double max = 0;
      double step = 1;
 
      std::string name;
      int sequenceNumber = 0;
    };
 
    struct Expression
    {
      std::string expressionString;
      mutable ExpressionVariable * resultVariable = nullptr;
      te_expr * expression = nullptr;
 
      size_t hash = 0;
    };
 
    struct COGSCORE_DLL_API ExpressionContext
    {
      const size_t kMaxVariables = 1024;
 
      ExpressionContext();
      ExpressionContext(const ExpressionContext & other) = delete;
      ExpressionContext & operator=(const ExpressionContext & other) = delete;
 
      void inherit(ExpressionContext * other);
 
      ExpressionVariable & add(std::string_view name, double value);
 
      double eval(std::string_view expression, double defaultValue);
 
      Expression * compile(std::string_view expression, std::string_view variable);
      void free(Expression * expression);
 
      double update(const Expression * expression, double defaultValue);
      float update(const Expression * expression, float defaultValue);
      int update(const Expression * expression, int defaultValue);
      size_t update(const Expression * expression, size_t defaultValue);
 
      std::span<const ExpressionVariable> getValues() const;
      std::span<ExpressionVariable> getValues();
 
      ExpressionContext * getParent() { return parent; }
 
      void link(ExpressionContext * source, std::string_view sourceName, std::string_view destName);
 
      void clear();
 
    private:
      void reserve();
 
      ExpressionContext * parent;
 
      std::unordered_map<size_t, Expression> expressions;
      std::vector<ExpressionVariable> values;
 
      te_scope scope;
      std::vector<te_variable> variables;
    };
 
    template<typename T>
    struct ExpressionValue
    {
      ExpressionValue() = default;
      ExpressionValue(T t) : value(t), hasValue(true) {}
      ExpressionValue(ExpressionContext * expressionContext, std::string_view name, std::string_view expression, T value) :
        expressionContext(expressionContext),
        value(value)
      {
        this->expression = expressionContext->compile(expression, name);
      }
 
      ~ExpressionValue()
      {
        if (expression && expressionContext) {
          expressionContext->free(expression);
        }
      }
 
      operator T() const { return getValue(); }
 
      T getValue() const
      {
        if (!hasValue) {
          value = expression ? get(T()) : T();
        }
 
        return value;
      }
 
      T get(T defaultValue) const
      {
        return expressionContext->update(expression, defaultValue);
      }
 
      ExpressionContext * expressionContext = nullptr;
      Expression * expression = nullptr;
      mutable T value;
      bool hasValue = false;
    };
 
    struct ParsedValue;
 
    void readSize_t(ExpressionValue<size_t> & value, ExpressionContext * ev, const std::string & prefix, const ParsedValue & parsedValue);
  }
}