variableExpressionAST.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_SDF_VARIABLE_EXPRESSION_AST_H
#define PXR_USD_SDF_VARIABLE_EXPRESSION_AST_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/usd/sdf/variableExpression.h"
 
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
namespace SdfVariableExpressionASTNodes
{
 
class Node
{
public:
    SDF_API virtual ~Node();
    SDF_API std::unique_ptr<Node> Clone() const;
 
    SDF_API SdfVariableExpression GetExpression() const;
 
    SDF_API SdfVariableExpression::Builder GetExpressionBuilder() const;
 
    template <class T>
    T* As()
    {
        static_assert(std::is_base_of_v<Node, T>);
        return dynamic_cast<T*>(this);
    }
 
    template <class T>
    const T* As() const
    {
        static_assert(std::is_base_of_v<Node, T>);
        return dynamic_cast<const T*>(this);
    }
 
protected:
    Node() = default;
 
    virtual Node* _Clone() const = 0;
    virtual SdfVariableExpression::Builder _GetExpressionBuilder() const = 0;
};
 
class NodeList
{
public:
    NodeList() = default;
    NodeList(std::vector<std::unique_ptr<Node>>&& nodes);
 
    SDF_API std::vector<Node*> GetNodes();
 
    SDF_API std::vector<const Node*> GetNodes() const;
 
    SDF_API void Append(const Node& node);
 
    SDF_API void Set(size_t i, const Node& node);
 
    SDF_API void Insert(size_t i, const Node& node);
 
    SDF_API void Remove(size_t i);
 
    SDF_API void Clear();
    
    SDF_API NodeList Clone() const;
 
private:
    std::vector<std::unique_ptr<Node>> _nodes;
};
 
class LiteralNode
    : public Node
{
public:
 
    using LiteralValue = std::variant<
        std::monostate,
        bool, int64_t, std::string
    >;
 
    const LiteralValue& GetValue() const { return _value; }
    void SetValue(const LiteralValue& value) { _value = value; }
 
 
private:
    friend class _NodeCreator;
 
    LiteralNode() = default;
 
    template <class T>
    LiteralNode(T&& value)
        : _value(std::forward<T>(value))
    { }
 
    Node* _Clone() const final;
    SdfVariableExpression::Builder _GetExpressionBuilder() const final;
 
    LiteralValue _value;
};
 
class VariableNode
    : public Node
{
public:
    const std::string& GetName() const { return _name; }
    void SetName(const std::string& name) { _name = name; }
 
 
    Node* GetFallbackValue() { return _fallbackValue.get(); }
 
    const Node* GetFallbackValue() const { return _fallbackValue.get(); }
 
    SDF_API void SetFallbackValue(const Node& node);
 
    void ClearFallbackValue() { _fallbackValue = nullptr; }
 
private:
    friend class _NodeCreator;
 
    VariableNode(std::string&& varName, 
                 std::unique_ptr<Node>&& fallbackValue) 
        : _name(std::move(varName)),
          _fallbackValue(std::move(fallbackValue))
    { }
 
    Node* _Clone() const final;
    SdfVariableExpression::Builder _GetExpressionBuilder() const final;
 
    std::string _name;
    std::unique_ptr<Node> _fallbackValue;
};
 
class ListNode
    : public Node
{
public:
    SDF_API SdfVariableExpression::ListBuilder GetExpressionBuilder() const;
 
    NodeList& GetElements() { return _elems; }
    const NodeList& GetElements() const { return _elems; }
 
private:
    friend class _NodeCreator;
 
    ListNode(NodeList&& elems)
        : _elems(std::move(elems))
    { }
 
    Node* _Clone() const final;
    SdfVariableExpression::Builder _GetExpressionBuilder() const final;
 
    NodeList _elems;
};
 
class FunctionNode
    : public Node
{
public:
    SDF_API SdfVariableExpression::FunctionBuilder GetExpressionBuilder() const;
 
    const std::string& GetName() const { return _functionName; }
    void SetName(const std::string& name) { _functionName = name; }
 
    const NodeList& GetArguments() const { return _functionArgs; }
    NodeList& GetArguments() { return _functionArgs; }
 
private:
    friend class _NodeCreator;
 
    FunctionNode(std::string&& functionName, NodeList&& functionArgs)
        : _functionName(std::move(functionName))
        , _functionArgs(std::move(functionArgs))
    { }
 
    Node* _Clone() const final;
    SdfVariableExpression::Builder _GetExpressionBuilder() const final;
 
    std::string _functionName;
    NodeList _functionArgs;
};
 
} // end namespace SdfVariableExpressionASTNodes
 
class SdfVariableExpressionAST
{
public:
    SDF_API SdfVariableExpressionAST();
 
    SDF_API explicit SdfVariableExpressionAST(const std::string& expr);
 
    SDF_API
    explicit SdfVariableExpressionAST(const SdfVariableExpression& expr);
 
    SDF_API SdfVariableExpressionAST(const SdfVariableExpressionAST& rhs);
 
    SDF_API
    SdfVariableExpressionAST& operator=(const SdfVariableExpressionAST& rhs);
 
    SdfVariableExpressionAST(SdfVariableExpressionAST&& rhs) = default;
    SdfVariableExpressionAST&
    operator=(SdfVariableExpressionAST&& rhs) = default;
 
    SDF_API explicit operator bool() const;
 
    SDF_API const std::vector<std::string>& GetErrors() const;
 
    SDF_API SdfVariableExpressionASTNodes::Node* GetRoot();
 
    SDF_API const SdfVariableExpressionASTNodes::Node* GetRoot() const;
 
    SDF_API SdfVariableExpression GetExpression() const;
 
private:
    std::unique_ptr<SdfVariableExpressionASTNodes::Node> _node;
    std::vector<std::string> _errors;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif