connectorSpecs.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_VDF_CONNECTOR_SPECS_H
#define PXR_EXEC_VDF_CONNECTOR_SPECS_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/inputSpec.h"
#include "pxr/exec/vdf/outputSpec.h"
#include "pxr/exec/vdf/tokens.h"
 
#include "pxr/base/tf/type.h"
#include "pxr/base/tf/smallVector.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
 
 
template < typename T >
class VdfConnectorSpecs
{
    // We choose a small vector with default size 1 to optimize for common
    // cases, including nodes with a single output.
    using _VectorType = TfSmallVector<T*, 1>;
 
public:
    using const_iterator = typename _VectorType::const_iterator;
 
    VdfConnectorSpecs() {}
 
    VdfConnectorSpecs(const VdfConnectorSpecs<T> &rhs) {
        // Copy other vector into our new one.
        Append(rhs);
    }
 
    VdfConnectorSpecs(VdfConnectorSpecs<T> &&rhs)
        : _specs(std::move(rhs._specs)) {
    }
 
    VdfConnectorSpecs<T> &operator=(const VdfConnectorSpecs<T> &rhs) {
        // Clear our specs, and copy the others into them.
        _ClearSpecs();
        Append(rhs);
        return *this;
    }
 
    VdfConnectorSpecs<T> &operator=(VdfConnectorSpecs<T> &&rhs) {
        // Clear our specs, and move the others into them.
        _ClearSpecs();
        _specs = std::move(rhs._specs);
        return *this;
    }
 
    void Append(const VdfConnectorSpecs<T> &specs) {
        _specs.reserve(_specs.size() + specs._specs.size());
        for (const T *spec : specs._specs) {
            _specs.push_back( new T(*spec) );
        }
    }
 
    void Reserve(size_t numSpecs) {
        _specs.reserve(numSpecs);
    }
 
    size_t GetSize() const { return _specs.size(); }
 
    const_iterator begin() const { return _specs.begin(); }
 
    const_iterator end() const { return _specs.end(); }
 
protected:
 
    ~VdfConnectorSpecs() { 
        _ClearSpecs();
    }
 
    void _ClearSpecs() {
        const_iterator e = _specs.end();
        for (const_iterator i = _specs.begin(); i != e; ++i) {
            delete *i;
        }
        _specs.clear();
    }
 
    const T *_GetConnectorSpec(int idx) const 
    { 
        return _specs[idx]; 
    }
 
    void _AddConnector(T *cs) 
    {
        _specs.push_back(cs);
    }
 
private:
 
    // A list of specs held in this container class.
    _VectorType _specs;
};
 
 
class VdfInputSpecs : public VdfConnectorSpecs<VdfInputSpec>
{
public:
 
    template <typename T> VdfInputSpecs &
    ReadConnector(const TfToken &inName,
                  const TfToken &outName = VdfTokens->empty,
                  bool prerequisite = false)
    {
        _AddConnector(VdfInputSpec::New<T>(
            inName, outName, VdfInputSpec::READ,  prerequisite));
        return *this;
    }
 
    template <typename T> VdfInputSpecs &
    ReadWriteConnector(const TfToken &inName, const TfToken &outName) 
    {
        _AddConnector(VdfInputSpec::New<T>(
            inName, outName, VdfInputSpec::READWRITE, /* prerequisite */false));
        return *this;
    }
 
    const VdfInputSpec *GetInputSpec(int idx) const 
    { 
        return _GetConnectorSpec(idx);
    }
 
    VdfInputSpecs &
    ReadConnector(
        const TfType &type,
        const TfToken &inName,
        const TfToken &outName = VdfTokens->empty,
        bool prerequisite = false)
    {
        _AddConnector(
            VdfInputSpec::New(
                type, inName, outName, VdfInputSpec::READ, prerequisite));
        return *this;
    }
 
    VdfInputSpecs &
    ReadWriteConnector(
        const TfType &type,
        const TfToken &inName,
        const TfToken &outName)
    {
        _AddConnector(
            VdfInputSpec::New(
                type, inName, outName, VdfInputSpec::READWRITE,
                /*prerequisite*/ false));
        return *this;
    }
 
    VDF_API
    bool operator==(const VdfInputSpecs &rhs) const;
    bool operator!=(const VdfInputSpecs &rhs) const {
        return !(*this == rhs);
    }
};
 
 
class VdfOutputSpecs : public VdfConnectorSpecs<VdfOutputSpec>
{
public:
 
    template <typename T> VdfOutputSpecs &
    Connector(const TfToken &name) 
    {
        _AddConnector(VdfOutputSpec::New<T>(name));
        return *this;
    }
 
    const VdfOutputSpec *GetOutputSpec(int idx) const 
    { 
        return _GetConnectorSpec(idx);
    }
 
    VdfOutputSpecs &
    Connector(const TfType &type, const TfToken &name) 
    {
        _AddConnector(VdfOutputSpec::New(type, name));
        return *this;
    }
 
    VDF_API
    bool operator==(const VdfOutputSpecs &rhs) const;
    bool operator!=(const VdfOutputSpecs &rhs) const {
        return !(*this == rhs);
    }
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif