inputSpec.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_INPUT_SPEC_H
#define PXR_EXEC_VDF_INPUT_SPEC_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
 
#include "pxr/base/tf/mallocTag.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfOutputSpec;
 
class VdfInputSpec
{
public:
    TF_MALLOC_TAG_NEW("Vdf", "new VdfInputSpec");
 
    enum Access {
        READ      = 0x1,
        READWRITE = 0x2
    };
 
    template <typename T>
    static VdfInputSpec *New(
        const TfToken &inName,
        const TfToken &outName,
        Access access,
        bool prerequisite)
    {
        return new VdfInputSpec(
            TfType::Find<T>(), inName, outName, access, prerequisite);
    }
 
    static VdfInputSpec *New(
        TfType type,
        const TfToken &inName,
        const TfToken &outName,
        Access access,
        bool prerequisite)
    {
        return new VdfInputSpec(type, inName, outName, access, prerequisite);
    }
 
    VDF_API
    ~VdfInputSpec();
 
    TfType GetType() const { return _type; }
 
    const TfToken &GetName() const { return _name; }
 
    VDF_API
    std::string GetTypeName() const;
 
    const Access &GetAccess() const { return _access; }
 
    VDF_API
    bool TypeMatches(const VdfOutputSpec &other) const;
 
    const TfToken &GetAssociatedOutputName() const {
        return _associatedOutputName;
    }
 
    bool IsPrerequisite() const { return _prerequisite; }
 
    VDF_API
    size_t GetHash() const;
 
    bool operator==(const VdfInputSpec &rhs) const {
        return _type                 == rhs._type                 &&
               _name                 == rhs._name                 &&
               _associatedOutputName == rhs._associatedOutputName &&
               _access               == rhs._access               &&
               _prerequisite         == rhs._prerequisite;
    }
    bool operator!=(const VdfInputSpec &rhs) const {
        return !(*this == rhs);
    }
 
private:
    VdfInputSpec(
        TfType type,
        const TfToken &inName, 
        const TfToken &outName,
        Access         access,
        bool           prerequisite)
    :   _type(type),
        _name(inName),
        _associatedOutputName(outName),
        _access(access),
        _prerequisite(prerequisite)
    {}
 
private:
    // The type accepted by the input.
    TfType _type;
 
    // The name of the connector
    TfToken _name;
 
    // Access to the connector is limited by this value.
    TfToken _associatedOutputName;
 
    // Access to the connector is limited by this value.
    Access _access;
 
    // Whether or not this connector is a prerequisite connector.
    bool _prerequisite;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif