computationBuilders.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_EXEC_COMPUTATION_BUILDERS_H
#define PXR_EXEC_EXEC_COMPUTATION_BUILDERS_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/exec/api.h"
#include "pxr/exec/exec/builtinComputations.h"
#include "pxr/exec/exec/providerResolution.h"
#include "pxr/exec/exec/typeRegistry.h"
#include "pxr/exec/exec/types.h"
 
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"
#include "pxr/base/vt/traits.h"
#include "pxr/base/vt/value.h"
#include "pxr/exec/vdf/context.h"
#include "pxr/exec/vdf/traits.h"
#include "pxr/usd/sdf/path.h"
 
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
 
PXR_NAMESPACE_OPEN_SCOPE
 
struct Exec_InputKey;
 
 
 
 
 
 
 
 
 
 
enum class Exec_ComputationBuilderProviderTypes: unsigned char
{
    Prim = 1 << 0,
    Attribute = 1 << 1,
    Any = 0xff
};
 
constexpr bool operator&(
    const Exec_ComputationBuilderProviderTypes a,
    const Exec_ComputationBuilderProviderTypes b)
{
    return static_cast<unsigned char>(a) & static_cast<unsigned char>(b);
}
 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderComputationValueSpecifier;
 
// Common base class for value specifiers and object accessors.
class Exec_ComputationBuilderCommonBase
{
protected:
    // Returns a value specifier for computing a metadata value.
    template <Exec_ComputationBuilderProviderTypes allowed>
    EXEC_API
    static Exec_ComputationBuilderComputationValueSpecifier<allowed>
    _GetMetadataValueSpecifier(
        const TfType resultType,
        const SdfPath &localTraversal,
        const TfToken &metadataKey);
};
 
// Untemplated value specifier base class.
//
// This class builds up an Exec_InputKey that specifies how to source an input
// value at exec compilation time.
//
class Exec_ComputationBuilderValueSpecifierBase
    : public Exec_ComputationBuilderCommonBase
{
public:
    EXEC_API
    Exec_ComputationBuilderValueSpecifierBase(
        const TfToken &computationName,
        TfType resultType,
        ExecProviderResolution &&providerResolution,
        const TfToken &inputName,
        const TfToken &disambiguatingId);
 
    EXEC_API
    Exec_ComputationBuilderValueSpecifierBase(
        const Exec_ComputationBuilderValueSpecifierBase&);
 
    EXEC_API
    ~Exec_ComputationBuilderValueSpecifierBase();
 
protected:
    EXEC_API
    void _SetInputName(const TfToken &inputName);
 
    EXEC_API
    void _SetOptional (const bool optional);
 
    EXEC_API
    void _SetFallsBackToDispatched(bool fallsBackToDispatched);
 
private:
    // Only computation builders can get the input key.
    friend class Exec_ComputationBuilderBase;
 
    EXEC_API
    void _GetInputKey(Exec_InputKey *inputKey) const;
 
private:
    // We PIMPL the data for this class to avoid exposing more private details
    // in this public header.
    struct _Data;
    const std::unique_ptr<_Data> _data;
};
 
// A value specifier that requests a constant value, valid on a prim or
// attribute computation
//
struct Exec_ComputationBuilderConstantValueSpecifier final
    : public Exec_ComputationBuilderValueSpecifierBase
{
    static constexpr Exec_ComputationBuilderProviderTypes allowedProviders =
        Exec_ComputationBuilderProviderTypes::Any;
 
    EXEC_API
    Exec_ComputationBuilderConstantValueSpecifier(
        const TfType resultType,
        const SdfPath &localTraversal,
        const TfToken &inputName,
        VtValue &&constantValue);
};
 
// A value specifier that requests the value of a computation.
//
// The template parameter determines which types of providers the input
// registration is allowed to be used on.
// 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderComputationValueSpecifier
    : public Exec_ComputationBuilderValueSpecifierBase
{
    Exec_ComputationBuilderComputationValueSpecifier(
        const TfToken &computationName,
        const TfType resultType,
        ExecProviderResolution &&providerResolution,
        const TfToken &disambiguatingId = TfToken())
        : Exec_ComputationBuilderValueSpecifierBase(
            computationName, resultType,
            std::move(providerResolution),
            computationName /* inputName */,
            disambiguatingId)
    {
    }
    
    using This = Exec_ComputationBuilderComputationValueSpecifier<allowed>;
 
    static constexpr Exec_ComputationBuilderProviderTypes allowedProviders =
        allowed;
 
 
    This&
    InputName(const TfToken &inputName)
    { 
        _SetInputName(inputName);
        return *this;
    }
 
    This&
    Required()
    {
        _SetOptional(false);
        return *this;
    }
 
    This&
    FallsBackToDispatched()
    {
        _SetFallsBackToDispatched(true);
        return *this;
    }
 
};
 
 
// Untemplated object accessor base class.
struct Exec_ComputationBuilderAccessorBase
    : public Exec_ComputationBuilderCommonBase
{
 
    Exec_ComputationBuilderAccessorBase(const SdfPath &localTraversal)
        : _localTraversal(localTraversal)
    {
    }
 
protected:
    const SdfPath &_GetLocalTraversal() const {
        return _localTraversal;
    }
 
private:
    // The relative path used for the first phase of provider resolution.
    SdfPath _localTraversal;
};
 
// Untemplated base class for accessors used to provide constant values as
// computation inputs.
//
struct Exec_ComputationBuilderConstantAccessorBase
    : public Exec_ComputationBuilderAccessorBase
{
    // We specialize the InputName() accessor because it is required for
    // constant values. I.e., Constant() returns an accessor, and the
    // InputName() option must be used to generate a value specifier.
    //
    Exec_ComputationBuilderConstantValueSpecifier
    InputName(const TfToken &inputName) &&
    { 
        return Exec_ComputationBuilderConstantValueSpecifier(
            _valueType,
            _GetLocalTraversal(),
            inputName,
            std::move(_constantValue));
    }
 
protected:
    EXEC_API
    Exec_ComputationBuilderConstantAccessorBase(
        VtValue &&constantValue,
        TfType valueType);
 
private:
    VtValue _constantValue;
    const TfType _valueType;
};
 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderAccessor
    : public Exec_ComputationBuilderAccessorBase
{
    Exec_ComputationBuilderAccessor(const SdfPath &localTraversal)
        : Exec_ComputationBuilderAccessorBase(localTraversal)
    {
    }
 
    using ValueSpecifier =
        Exec_ComputationBuilderComputationValueSpecifier<allowed>;
 
 
    template <typename ResultType>
    ValueSpecifier
    Computation(const TfToken &computationName)
    {
        static_assert(!VtIsArray<ResultType>::value,
                      "VtArray is not a supported result type.");
 
        return ValueSpecifier(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {_GetLocalTraversal(),
             ExecProviderResolution::DynamicTraversal::Local});
    }
 
    template <typename ResultType>
    ValueSpecifier
    IncomingConnections(const TfToken &computationName)
    {
        return ValueSpecifier(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {Exec_ComputationBuilderAccessorBase::_GetLocalTraversal(),
             ExecProviderResolution::DynamicTraversal::
                 IncomingConnectionOwningAttributes});
    }
 
    template <typename ResultType>
    ValueSpecifier
    Metadata(const TfToken &metadataKey)
    {
        static_assert(!VtIsArray<ResultType>::value,
                      "VtArray is not a supported result type.");
 
        return _GetMetadataValueSpecifier<allowed>(
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            _GetLocalTraversal(),
            metadataKey);
    }
 
};
 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderPropertyAccessor
    : public Exec_ComputationBuilderAccessor<allowed>
{
    Exec_ComputationBuilderPropertyAccessor(const SdfPath &localTraversal)
        : Exec_ComputationBuilderAccessor<allowed>(localTraversal)
    {
    }
};
 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderAttributeAccessor
    : public Exec_ComputationBuilderPropertyAccessor<allowed>
{
    Exec_ComputationBuilderAttributeAccessor(const SdfPath &localTraversal)
    : Exec_ComputationBuilderPropertyAccessor<allowed>(localTraversal)
    {
    }
 
    using ValueSpecifier =
        Exec_ComputationBuilderComputationValueSpecifier<allowed>;
 
 
    template <typename ResultType>
    ValueSpecifier
    Connections(const TfToken &computationName)
    {
        return ValueSpecifier(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {Exec_ComputationBuilderAccessorBase::_GetLocalTraversal(),
             ExecProviderResolution::DynamicTraversal::
                 ConnectionTargetedObjects});
    }
 
 
    // XXX:TODO
    // Accessors for AnimSpline, etc.
};
 
template <Exec_ComputationBuilderProviderTypes allowed>
struct Exec_ComputationBuilderRelationshipAccessor
    : public Exec_ComputationBuilderPropertyAccessor<allowed>
{
    Exec_ComputationBuilderRelationshipAccessor(const SdfPath &localTraversal)
    : Exec_ComputationBuilderPropertyAccessor<allowed>(localTraversal)
    {
    }
 
    using ValueSpecifier =
        Exec_ComputationBuilderComputationValueSpecifier<allowed>;
 
 
    template <typename ResultType>
    ValueSpecifier
    TargetedObjects(const TfToken &computationName)
    {
        return ValueSpecifier(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {Exec_ComputationBuilderAccessorBase::_GetLocalTraversal(),
             ExecProviderResolution::DynamicTraversal::
                 RelationshipTargetedObjects});
    }
 
};
 
 
// The following registrations are in the exec_registration namespace so that
// the registration macro can make them available (without the namespace) as
// arguments to registrations methods (i.e., Inputs()).
namespace exec_registration {
 
 
struct Attribute final
    : public Exec_ComputationBuilderAttributeAccessor<
        Exec_ComputationBuilderProviderTypes::Prim>
{
 
    Attribute(const TfToken &attributeName)
        : Exec_ComputationBuilderAttributeAccessor<
            Exec_ComputationBuilderProviderTypes::Prim>(
                SdfPath::ReflexiveRelativePath().AppendProperty(attributeName))
    {
    }
 
};
 
 
struct Relationship final
    : public Exec_ComputationBuilderRelationshipAccessor<
        Exec_ComputationBuilderProviderTypes::Prim>
{
 
    Relationship(const TfToken &relationshipName)
        : Exec_ComputationBuilderRelationshipAccessor<
            Exec_ComputationBuilderProviderTypes::Prim>(
                SdfPath::ReflexiveRelativePath().AppendProperty(
                    relationshipName))
    {
    }
 
};
 
 
struct Prim final
    : public Exec_ComputationBuilderAccessor<
        Exec_ComputationBuilderProviderTypes::Attribute>
{
 
    Prim()
        : Exec_ComputationBuilderAccessor<
            Exec_ComputationBuilderProviderTypes::Attribute>(
                SdfPath(".."))
    {
    }
 
    Exec_ComputationBuilderAttributeAccessor<
        Exec_ComputationBuilderProviderTypes::Attribute>
    Attribute(const TfToken &attributeName)
    {
        return Exec_ComputationBuilderAttributeAccessor<
            Exec_ComputationBuilderProviderTypes::Attribute>(
                SdfPath("..").AppendProperty(attributeName));
    }
 
    Exec_ComputationBuilderRelationshipAccessor<
        Exec_ComputationBuilderProviderTypes::Attribute>
    Relationship(const TfToken &relationshipName)
    {
        return Exec_ComputationBuilderRelationshipAccessor<
            Exec_ComputationBuilderProviderTypes::Attribute>(
                SdfPath("..").AppendProperty(relationshipName));
    }
 
 
 
    template <typename ValueType>
    auto
    AttributeValue(const TfToken &attributeName)
    {
        return Attribute(attributeName)
            .Computation<ValueType>(ExecBuiltinComputations->computeValue)
            .InputName(attributeName);
    }
 
};
 
 
struct Stage final
    : public Exec_ComputationBuilderAccessor<
        Exec_ComputationBuilderProviderTypes::Any>
{
 
    Stage()
        : Exec_ComputationBuilderAccessor<
            Exec_ComputationBuilderProviderTypes::Any>(
                SdfPath::AbsoluteRootPath())
    {
    }
 
};
 
// XXX:TODO
// Property, NamespaceParent, NamespaceChildren, etc.
 
 
template <typename ResultType>
struct Computation final
    : public Exec_ComputationBuilderComputationValueSpecifier<
        Exec_ComputationBuilderProviderTypes::Any>
{
 
    Computation(const TfToken &computationName)
        : Exec_ComputationBuilderComputationValueSpecifier<
            Exec_ComputationBuilderProviderTypes::Any>(
                computationName, 
                ExecTypeRegistry::GetInstance().
                    CheckForRegistration<ResultType>(),
                {SdfPath::ReflexiveRelativePath(),
                 ExecProviderResolution::DynamicTraversal::Local})
    {
    }
 
};
 
template <typename ValueType>
struct Metadata final
    : public Exec_ComputationBuilderComputationValueSpecifier<
        Exec_ComputationBuilderProviderTypes::Any>
{
 
    Metadata(const TfToken &metadataKey)
        : Exec_ComputationBuilderComputationValueSpecifier<
            Exec_ComputationBuilderProviderTypes::Any>(
                _GetMetadataValueSpecifier<allowedProviders>(
                    ExecTypeRegistry::GetInstance()
                        .CheckForRegistration<ValueType>(),
                    SdfPath::ReflexiveRelativePath(),
                    metadataKey))
    {
        static_assert(!VtIsArray<ValueType>::value,
                      "VtArray is not a supported result type.");
 
        InputName(metadataKey);
    }
 
};
 
// Constant accessor
template <typename ValueType>
struct Constant final
    : public Exec_ComputationBuilderConstantAccessorBase
{
 
    Constant(
        ValueType &&constantValue)
        : Exec_ComputationBuilderConstantAccessorBase(
            VtValue(std::move(constantValue)),
            ExecTypeRegistry::GetInstance().
                CheckForRegistration<ValueType>())
    {
        static_assert(
            !std::is_same_v<std::decay_t<ValueType>, char*> &&
            !std::is_same_v<std::decay_t<ValueType>, const char*>,
            "Must use std::string to represent string literal types.");
        static_assert(
            VtIsHashable<ValueType>(),
            "Types used to provide constant input values must be hashable.");
    }
 
    Constant(
        const ValueType &constantValue)
        : Exec_ComputationBuilderConstantAccessorBase(
            VtValue(constantValue),
            ExecTypeRegistry::GetInstance().
                CheckForRegistration<ValueType>())
    {
        static_assert(
            !std::is_same_v<std::decay_t<ValueType>, char*> &&
            !std::is_same_v<std::decay_t<ValueType>, const char*>,
            "Must use std::string to represent string literal types.");
        static_assert(
            VtIsHashable<ValueType>(),
            "Types used to provide constant input values must be hashable.");
    }
 
};
 
// Deduction guides that ensure std::string is the value type used to store
// character string literals.
Constant(const char *) -> Constant<std::string>;
Constant(char *) -> Constant<std::string>;
 
 
// XXX:TODO
// This should be implemented as an alias for an accessor that takes a predicate
// plus .Compute(), but that requires implementing predicates plus having a way
// to express the computation name and result type as computation parameters.
// Therefore, for now, this is implemented as a value specifier.
template <typename ResultType>
struct NamespaceAncestor final
    : public Exec_ComputationBuilderComputationValueSpecifier<
        Exec_ComputationBuilderProviderTypes::Prim>
{
 
    NamespaceAncestor(const TfToken &computationName)
        : Exec_ComputationBuilderComputationValueSpecifier<
            Exec_ComputationBuilderProviderTypes::Prim>(
                computationName,
                ExecTypeRegistry::GetInstance().
                    CheckForRegistration<ResultType>(),
                {SdfPath::ReflexiveRelativePath(),
                 ExecProviderResolution::DynamicTraversal::NamespaceAncestor})
    {
    }
 
};
 
// XXX:TODO
// AnimSpline
 
 
 
// Note:
// Aliases are implemented as generator functions, rather than as structs,
// because that way they can simply be expressed as registrations.
 
template <typename ValueType>
auto
AttributeValue(const TfToken &attributeName)
{
    return Attribute(attributeName)
        .Computation<ValueType>(ExecBuiltinComputations->computeValue)
        .InputName(attributeName);
}
 
 
 
template <typename ResultType>
auto
Connections(const TfToken &computationName)
{
    return Exec_ComputationBuilderComputationValueSpecifier<
        Exec_ComputationBuilderProviderTypes::Attribute>(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {SdfPath::ReflexiveRelativePath(),
             ExecProviderResolution::DynamicTraversal::
                 ConnectionTargetedObjects});
}
 
template <typename ResultType>
auto
IncomingConnections(const TfToken &computationName)
{
    return Exec_ComputationBuilderComputationValueSpecifier<
        Exec_ComputationBuilderProviderTypes::Any>(
            computationName,
            ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>(),
            {SdfPath::ReflexiveRelativePath(),
             ExecProviderResolution::DynamicTraversal::
                 IncomingConnectionOwningAttributes});
}
 
 
} // namespace exec_registration
 
 
// We forward declare these classes so the generated documentation for
// PrimComputation(), AttributeComputation(), and AttributeExpression() comes
// before the Callback() and Inputs() docs.
// 
class ExecPrimComputationBuilder;
class ExecAttributeComputationBuilder;
class ExecAttributeExpressionBuilder;
 
class ExecComputationBuilder
{
    EXEC_API
    ExecComputationBuilder(TfType schemaType);
 
public:
    EXEC_API
    ~ExecComputationBuilder();
 
    // Allows access to the constructor.
    //
    // Only schema computation registration functions should create computation
    // builders.
    struct ConstructionAccess {
        EXEC_API
        static ExecComputationBuilder
        Construct(const std::string &schemaTypeName);
    };
 
 
    EXEC_API
    ExecPrimComputationBuilder 
    PrimComputation(const TfToken &computationName);
 
    EXEC_API
    ExecAttributeComputationBuilder 
    AttributeComputation(
        const TfToken &attributeName,
        const TfToken &computationName);
 
    EXEC_API
    ExecAttributeExpressionBuilder
    AttributeExpression(const TfToken &attributeName);
 
    template <class... DispatchedOntoSchemaTypes>
    ExecPrimComputationBuilder
    DispatchedPrimComputation(
        const TfToken &computationName,
        DispatchedOntoSchemaTypes &&...schemaTypes);
 
    // overload that takes a vector of TfTypes
    EXEC_API
    ExecPrimComputationBuilder 
    DispatchedPrimComputation(
        const TfToken &computationName,
        ExecDispatchesOntoSchemas &&ontoSchemas);
 
    template <class... DispatchedOntoSchemaTypes>
    ExecAttributeComputationBuilder
    DispatchedAttributeComputation(
        const TfToken &computationName,
        DispatchedOntoSchemaTypes &&...schemaTypes);
 
    // overload that takes a vector of TfTypes
    EXEC_API
    ExecAttributeComputationBuilder 
    DispatchedAttributeComputation(
        const TfToken &computationName,
        ExecDispatchesOntoSchemas &&ontoSchemas);
 
 
private:
    // The type of the schema for which this builder defines computations.
    TfType _schemaType;
};
 
 
// Untemplated base class for classes used to build computation definitions.
class Exec_ComputationBuilderBase
{
protected:
    EXEC_API
    Exec_ComputationBuilderBase(
        const TfToken &attributeName,
        TfType schemaType,
        const TfToken &computationName,
        bool dispatched,
        ExecDispatchesOntoSchemas &&dispatchesOntoSchemas);
 
    ~Exec_ComputationBuilderBase();
 
    // Adds the callback with result type.
    EXEC_API
    void _AddCallback(ExecCallbackFn &&calback, TfType resultType);
 
    // Validates that all inputs are allowed to be registered on computations of
    // the \p allowed provider types.
    // 
    template <Exec_ComputationBuilderProviderTypes allowed, typename T>
    static void _ValidateInputs();
 
    // Adds an input key from the given value specifier.
    //
    // This extra level of indirection helps keep Exec_InputKey out of the
    // header so that type can remain private.
    // 
    EXEC_API
    void _AddInputKey(
        const Exec_ComputationBuilderValueSpecifierBase *valueSpecifier);
 
    // Returns a pointer to the dispatches-onto schemas if the computation is
    // dispatched, or a null pointer, otherwise.
    //
    std::unique_ptr<ExecDispatchesOntoSchemas>
    _GetDispatchesOntoSchemas();
 
    // We PIMPL the data for this class to avoid exposing more private details
    // in this public header.
    //
    struct _Data;
    _Data &_GetData();
 
private:
    const std::unique_ptr<_Data> _data;
};
 
 
// CRTP base class for classes used to build computation definitions.
template <typename Derived>
class Exec_ComputationBuilderCRTPBase : public Exec_ComputationBuilderBase
{
    // Type used as a default template parameter type for metaprogramming.
    struct _UnspecifiedType {};
 
protected:
    EXEC_API
    Exec_ComputationBuilderCRTPBase(
        const TfToken &attributeName,
        TfType schemaType,
        const TfToken &computationName,
        bool dispatched,
        ExecDispatchesOntoSchemas &&dispatchesOntoSchemas);
 
    EXEC_API
    ~Exec_ComputationBuilderCRTPBase();
 
public:
    template<
        typename ResultType = _UnspecifiedType,
        typename ReturnType = _UnspecifiedType>
    Derived&
    Callback(ReturnType (*callback)(const VdfContext &));
 
    template<typename ResultType, typename FuncType>
    Derived&
    Callback(FuncType &&callback);
};
 
 
class ExecPrimComputationBuilder final
    : public Exec_ComputationBuilderCRTPBase<ExecPrimComputationBuilder>
{
    // Only ExecComputationBuilder can create instances.
    friend class ExecComputationBuilder;
 
    EXEC_API
    ExecPrimComputationBuilder(
        TfType schemaType,
        const TfToken &computationName,
        bool dispatched = false,
        ExecDispatchesOntoSchemas &&dispatchesOntoSchemas = {});
 
public:
    EXEC_API
    ~ExecPrimComputationBuilder();
 
    template <typename... Args>
    ExecPrimComputationBuilder&
    Inputs(Args && ... args);
};
 
 
class ExecAttributeComputationBuilder final
    : public Exec_ComputationBuilderCRTPBase<ExecAttributeComputationBuilder>
{
    // Only ExecComputationBuilder can create instances.
    friend class ExecComputationBuilder;
 
    EXEC_API
    ExecAttributeComputationBuilder(
        const TfToken &attributeName,
        TfType schemaType,
        const TfToken &computationName,
        bool dispatched = false,
        ExecDispatchesOntoSchemas &&dispatchesOntoSchemas = {});
 
public:
    EXEC_API
    ~ExecAttributeComputationBuilder();
 
    template <typename... Args>
    ExecAttributeComputationBuilder&
    Inputs(Args && ... args);
};
 
class ExecAttributeExpressionBuilder final
    : public Exec_ComputationBuilderCRTPBase<ExecAttributeExpressionBuilder>
{
    // Only ExecComputationBuilder can create instances.
    friend class ExecComputationBuilder;
 
    EXEC_API
    ExecAttributeExpressionBuilder(
        const TfToken &attributeName,
        TfType schemaType);
 
public:
    EXEC_API
    ~ExecAttributeExpressionBuilder();
 
    template <typename... Args>
    ExecAttributeExpressionBuilder&
    Inputs(Args && ... args);
};
 
 
//
// Exec_ComputationBuilderBase
//
 
template <Exec_ComputationBuilderProviderTypes allowed, typename T>
void
Exec_ComputationBuilderBase::_ValidateInputs() {
    using regType = std::decay_t<T>;
    static_assert(
        !std::is_base_of_v<Exec_ComputationBuilderAccessorBase, regType>,
        "Accessor can't provide an input value.");
    static_assert(
        !std::is_same_v<Exec_ComputationBuilderConstantAccessorBase, regType>,
        "Constant(value) must be followed by .InputName(inputNameToken)");
    static_assert(
        std::is_base_of_v<Exec_ComputationBuilderValueSpecifierBase, regType>,
        "Invalid type used as an input registration.");
    static_assert(
        regType::allowedProviders & allowed,
        "This input registration is not allowed on a provider of this type.");
    static_assert(
        (regType::allowedProviders & allowed) ||
        (allowed ==
         Exec_ComputationBuilderProviderTypes::Attribute),
        "This input registration is only allowed on a provider attribute; "
        "there may be a missing Attribute(attributeName) registration.");
    static_assert(
        (regType::allowedProviders & allowed) ||
        (allowed ==
         Exec_ComputationBuilderProviderTypes::Prim),
        "This input registration is only allowed on a provider prim; "
        "there may be a missing Prim() registration.");
}
 
//
// Exec_ComputationBuilderCRTPBase
//
 
template <typename Derived>
template <typename InputResultType, typename ReturnType>
Derived&
Exec_ComputationBuilderCRTPBase<Derived>::Callback(
    ReturnType (*callback)(const VdfContext &))
{
    // In order to allow the return type of the callback to be different from
    // the computation result type in some cases AND be able to deduce the
    // result type from the return type in others, we have to default both
    // template parameters to _UnspecifiedType and use metaprogramming to get
    // the actual result type.
    using ResultType =
        std::conditional_t<
            std::is_same_v<InputResultType, _UnspecifiedType>,
            ReturnType,
            InputResultType>;
 
    static_assert(
        !std::is_void_v<ResultType> ||
        std::is_convertible_v<ReturnType, ResultType>,
        "Callback return type must be convertible to the computation result "
        "type.");
    static_assert(
        !std::is_reference_v<ResultType>,
        "Callback functions must return by value.");
    static_assert(
        !VtIsArray<ResultType>::value,
        "VtArray is not a supported result type.");
 
    const TfType resultType =
        ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>();
 
    // If the return type is void, the callback is on the hook to call
    // VdfContext::SetOutput; otherwise, we wrap it in a lambda that passes
    // the callback return value to SetOutput.
    if constexpr (std::is_void_v<ReturnType>) {
        _AddCallback(callback, resultType);
    } else {
        _AddCallback(
            [callback](const VdfContext& ctx) {
                ctx.SetOutput<ResultType>(callback(ctx));
            },
            resultType);
    }
 
    return *static_cast<Derived*>(this);
}
 
template <typename Derived>
template<typename ResultType, typename FuncType>
Derived&
Exec_ComputationBuilderCRTPBase<Derived>::Callback(
    FuncType &&callback)
{
    // This condition will also be caught by the check for void return below,
    // but this produces a much clearer compile error, and therefore we do this
    // check first.
    static_assert(
        std::is_invocable_v<
            const std::remove_reference_t<FuncType>, const VdfContext&>,
        "Callback function object must have const function call operator.");
 
    static_assert(
        !std::is_void_v<ResultType>,
        "The ResultType template parameter cannot be void, as this indicates "
        "the value type of the result produced by the computation.");
 
    // The callback's return type must be void because any returned value
    // will be ignored.
    static_assert(
        std::is_void_v<std::invoke_result_t<const FuncType, const VdfContext&>>,
        "Callback return type must be void. Use VdfContext::SetOutput to "
        "set a result value.");
 
    static_assert(
        !std::is_reference_v<ResultType>,
        "Callback function must return by value.");
    static_assert(
        !VtIsArray<ResultType>::value,
        "VtArray is not a supported result type.");
 
    const TfType resultType =
        ExecTypeRegistry::GetInstance().CheckForRegistration<ResultType>();
 
    _AddCallback(callback, resultType);
 
    return *static_cast<Derived*>(this);
}
 
//
// ExecPrimComputationBuilder
//
 
template <typename... Args>
ExecPrimComputationBuilder&
ExecPrimComputationBuilder::Inputs(
    Args && ... args)
{
    // Validate inputs
    (_ValidateInputs<
         Exec_ComputationBuilderProviderTypes::Prim, Args>(), ...);
 
    // Add inputs
    (_AddInputKey(&args), ...);
 
    return *this;
}
 
//
// ExecAttributeComputationBuilder
//
 
template <typename... Args>
ExecAttributeComputationBuilder&
ExecAttributeComputationBuilder::Inputs(
    Args && ... args)
{
    // Validate inputs
    (_ValidateInputs<
         Exec_ComputationBuilderProviderTypes::Attribute, Args>(), ...);
 
    // Add inputs
    (_AddInputKey(&args), ...);
 
    return *this;
}
 
//
// ExecAttributeExpressionBuilder
//
 
template <typename... Args>
ExecAttributeExpressionBuilder&
ExecAttributeExpressionBuilder::Inputs(
    Args && ... args)
{
    // Validate inputs
    (_ValidateInputs<
         Exec_ComputationBuilderProviderTypes::Attribute, Args>(), ...);
 
    // Add inputs
    (_AddInputKey(&args), ...);
 
    return *this;
}
 
//
// ExecComputationBuilder
//
 
template <class... DispatchedOntoSchemaTypes>
ExecPrimComputationBuilder
ExecComputationBuilder::DispatchedPrimComputation(
    const TfToken &computationName,
    DispatchedOntoSchemaTypes &&...schemaTypes)
{
    static_assert(
        (std::is_same_v<
             std::decay_t<DispatchedOntoSchemaTypes>, TfType> && ...));
 
    return DispatchedPrimComputation(
        computationName,
        {std::forward<DispatchedOntoSchemaTypes>(schemaTypes)...});
}
 
template <class... DispatchedOntoSchemaTypes>
ExecAttributeComputationBuilder
ExecComputationBuilder::DispatchedAttributeComputation(
    const TfToken &computationName,
    DispatchedOntoSchemaTypes &&...schemaTypes)
{
    static_assert(
        (std::is_same_v<
             std::decay_t<DispatchedOntoSchemaTypes>, TfType> && ...));
 
    return DispatchedAttributeComputation(
        computationName,
        {std::forward<DispatchedOntoSchemaTypes>(schemaTypes)...});
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif