booleanExpression.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_BOOLEAN_EXPRESSION_H
#define PXR_USD_SDF_BOOLEAN_EXPRESSION_H
 
#include "pxr/usd/sdf/api.h"
 
#include "pxr/base/tf/declarePtrs.h"
#include "pxr/base/tf/functionRef.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/vt/value.h"
 
#include <iosfwd>
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
 
class SdfBooleanExpression {
public:
    SdfBooleanExpression() = default;
 
    SDF_API explicit SdfBooleanExpression(std::string const& text);
 
    SDF_API bool IsEmpty() const;
 
    SDF_API std::string GetText() const;
 
    SDF_API std::string const& GetParseError() const;
 
    SDF_API std::set<TfToken> GetVariableNames() const;
 
    SDF_API static SdfBooleanExpression
    MakeVariable(TfToken const& variableName);
 
    SDF_API static SdfBooleanExpression
    MakeConstant(VtValue const& value);
 
    enum class BinaryOperator {
        EqualTo,
 
        NotEqualTo,
 
        LessThan,
 
        LessThanOrEqualTo,
 
        GreaterThan,
 
        GreaterThanOrEqualTo,
 
        And,
 
        Or,
    };
 
    SDF_API static SdfBooleanExpression
    MakeBinaryOp(SdfBooleanExpression lhs,
                 BinaryOperator op,
                 SdfBooleanExpression rhs);
 
    enum class UnaryOperator {
        Not,
    };
 
    SDF_API static SdfBooleanExpression
    MakeUnaryOp(SdfBooleanExpression expression, UnaryOperator op);
 
    using BinaryVisitor = TfFunctionRef<void(SdfBooleanExpression const&,
                                             BinaryOperator,
                                             SdfBooleanExpression const&)>;
 
    using UnaryVisitor = TfFunctionRef<void(SdfBooleanExpression const&,
                                            UnaryOperator)>;
 
    using VariableVisitor = TfFunctionRef<void(TfToken const&)>;
 
    using ConstantVisitor = TfFunctionRef<void(VtValue const&)>;
 
    SDF_API void Visit(VariableVisitor variable,
                       ConstantVisitor constant,
                       BinaryVisitor binary,
                       UnaryVisitor unary) const;
 
    using VariableCallback = TfFunctionRef<VtValue (TfToken const&)>;
 
    SDF_API bool Evaluate(VariableCallback const& variableCallback) const;
 
    using NameTransform = TfFunctionRef<TfToken(TfToken const&)>;
 
    SDF_API SdfBooleanExpression
    RenameVariables(NameTransform const& transform) const;
 
    SDF_API static bool
    Validate(std::string const& expression, std::string* errorMessage = nullptr);
 
    // Note that the internal _Node class is public to simplify details of the
    // implementation.
    class _Node;
    TF_DECLARE_REF_PTRS(_Node);
 
private:
    SdfBooleanExpression(_NodeRefPtr const& node);
 
    SDF_API friend std::ostream&
    operator<<(std::ostream&, SdfBooleanExpression const&);
 
    std::string _text;
    std::string _parseError;
    _NodeRefPtr _rootNode;
};
 
SDF_API std::ostream&
operator<<(std::ostream& os, SdfBooleanExpression::BinaryOperator const& rhs);
 
SDF_API std::ostream&
operator<<(std::ostream& os, SdfBooleanExpression::UnaryOperator const& rhs);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDF_BOOLEAN_EXPRESSION_H