ExpressionContext.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/NetworkGraph/Unit.h"
#include <atomic>
#include <map>
#include <mutex>
#include <optional>
#include <tuple>
#include <variant>
#include <vector>
 
namespace enzo::expr {
 
class ExpressionContext
{
  public:
    explicit ExpressionContext(nt::NodeId currentNode) : currentNode_(currentNode) {}
 
    nt::NodeId currentNode() const { return currentNode_; }
 
    template <typename Value>
    std::optional<Value> readParameter(const String& path, unsigned int index) const;
 
    const std::vector<nt::Unit>& getExpressionDependencies() const
    {
        return expressionDependencies_;
    }
 
    void recordTimeDependency() const { readsTime_ = true; }
 
    bool dependsOnTime() const { return readsTime_; }
 
  private:
    using ParameterValue = std::variant<floatT, intT, String>;
 
    // A read's path, component index and value type.
    using ParameterRead = std::tuple<String, unsigned int, size_t>;
 
    nt::NodeId currentNode_;
 
    // Filled as prm() and friends resolve, so const reads can still accumulate.
    mutable std::mutex readMutex_;
    mutable std::map<ParameterRead, ParameterValue> parameterValues_;
    mutable std::vector<nt::Unit> expressionDependencies_;
    mutable std::atomic<bool> readsTime_ = false;
};
 
void submitExpressionDependencies(const ExpressionContext& context);
 
extern template std::optional<floatT>
ExpressionContext::readParameter<floatT>(const String&, unsigned int) const;
extern template std::optional<intT>
ExpressionContext::readParameter<intT>(const String&, unsigned int) const;
extern template std::optional<String>
ExpressionContext::readParameter<String>(const String&, unsigned int) const;
 
} // namespace enzo::expr