object.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_OBJECT_H
#define PXR_EXEC_VDF_OBJECT_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
 
#include "pxr/base/tf/token.h"
 
#include <set>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfConnection;
class VdfInput;
class VdfNode;
class VdfOutput;
 
class VdfObjectPtr
{
public:
 
    enum Type
    {
        Undefined = -1, // Marks the undefined type.
 
        Node,           // The object is a VdfNode.
        Connection,     // The object is a VdfConnection.
        Input,          // The object is a VdfInput.
        Output          // The object is a VdfOutput.
    };
 
    VdfObjectPtr()
    :   _node(NULL),
        _type(Undefined),
        _isConst(false) {}
 
    VdfObjectPtr(VdfNode *node)
    :   _node(node),
        _type(Node),
        _isConst(false) {}
 
    VdfObjectPtr(const VdfNode *node)
    :   _constNode(node),
        _type(Node),
        _isConst(true) {}
 
    VdfObjectPtr(VdfConnection *connection)
    :   _connection(connection),
        _type(Connection),
        _isConst(false) {}
 
    VdfObjectPtr(const VdfConnection *connection)
    :   _constConnection(connection),
        _type(Connection),
        _isConst(true) {}
 
    VdfObjectPtr(VdfInput *input)
    :   _input(input),
        _type(Input),
        _isConst(false) {}
 
    VdfObjectPtr(const VdfInput *input)
    :   _constInput(input),
        _type(Input),
        _isConst(true) {}
 
    VdfObjectPtr(VdfOutput *output)
    :   _output(output),
        _type(Output),
        _isConst(false) {}
 
    VdfObjectPtr(const VdfOutput *output)
    :   _constOutput(output),
        _type(Output),
        _isConst(true) {}
 
    VdfObjectPtr &operator=(const VdfObjectPtr &rhs)
    {
        _node    = rhs._node;
        _type    = rhs._type;
        _isConst = rhs._isConst;
 
        return *this;
    }
 
    bool operator<(const VdfObjectPtr &rhs) const
    {
        return _node < rhs._node;
    }
 
    bool operator<=(const VdfObjectPtr &rhs) const
    {
        return !(rhs < *this);
    }
 
    bool operator>(const VdfObjectPtr &rhs) const
    {
        return rhs < *this;
    }
 
    bool operator>=(const VdfObjectPtr &rhs) const
    {
        return !(*this < rhs);
    }
 
    bool operator==(const VdfObjectPtr &rhs) const
    {
        return _type == rhs._type &&
               _node == rhs._node;
    }
 
    bool operator!=(const VdfObjectPtr &rhs) const
    {
        return !(*this == rhs);
    }
 
    struct HashFunctor
    {
        size_t operator()(const VdfObjectPtr &obj) const
        {
            return (size_t)obj._node;
        }
    };
 
    operator bool() const
    {
        return _node;
    }
 
    Type GetType() const
    {
        return _type;
    }
 
    bool IsConst() const
    {
        return _isConst;
    }
 
    bool IsNode() const
    {
        return _type == Node;
    }
 
    bool IsConnection() const
    {
        return _type == Connection;
    }
 
    bool IsInput() const
    {
        return _type == Input;
    }
 
    bool IsOutput() const
    {
        return _type == Output;
    }
 
    VdfNode *GetNonConstNode() const
    {   
        TF_AXIOM(IsNode());
        TF_AXIOM(!IsConst());
        return _node;
    }
 
    VdfConnection *GetNonConstConnection() const
    {   
        TF_AXIOM(IsConnection());
        TF_AXIOM(!IsConst());
        return _connection;
    }
 
    VdfInput *GetNonConstInput() const
    {   
        TF_AXIOM(IsInput());
        TF_AXIOM(!IsConst());
        return _input;
    }
 
    VdfOutput *GetNonConstOutput() const
    {   
        TF_AXIOM(IsOutput());
        TF_AXIOM(!IsConst());
        return _output;
    }
 
    const VdfNode &GetNode() const
    {   
        TF_AXIOM(IsNode());
        return *_constNode;
    }
 
    const VdfConnection &GetConnection() const
    {   
        TF_AXIOM(IsConnection());
        return *_constConnection;
    }
 
    const VdfInput &GetInput() const
    {   
        TF_AXIOM(IsInput());
        return *_constInput;
    }
 
    const VdfOutput &GetOutput() const
    {   
        TF_AXIOM(IsOutput());
        return *_constOutput;
    }
 
    const VdfNode *GetIfNode() const
    {   
        return IsNode() ? _constNode : NULL;
    }
 
    const VdfConnection *GetIfConnection() const
    {   
        return IsConnection() ? _constConnection : NULL;
    }
 
    const VdfInput *GetIfInput() const
    {   
        return IsInput() ? _constInput : NULL;
    }
 
    const VdfOutput *GetIfOutput() const
    {   
        return IsOutput() ? _constOutput : NULL;
    }
 
    VdfNode *GetIfNonConstNode() const
    {   
        return (!IsConst() && IsNode()) ? _node : NULL;
    }
 
    VdfConnection *GetIfNonConstConnection() const
    {   
        return (!IsConst() && IsConnection()) ? _connection : NULL;
    }
 
    VdfInput *GetIfNonConstInput() const
    {   
        return (!IsConst() && IsInput()) ? _input : NULL;
    }
 
    VdfOutput *GetIfNonConstOutput() const
    {   
        return (!IsConst() && IsOutput()) ? _output : NULL;
    }
 
    VDF_API
    const VdfNode *GetOwningNode() const;
 
    VDF_API
    std::string GetDebugName() const;
 
    const void *GetIdentity() const
    {
        // Note: Since all different types are stored in an union, we just
        //       pick the first const type to return.
        return _constNode;
    }
 
// -----------------------------------------------------------------------------
 
private:
 
    // Stores pointers as needed for the different object types.
    union
    {
        VdfNode             *_node;
        VdfConnection       *_connection;
        VdfInput            *_input;
        VdfOutput           *_output;
 
        const VdfNode       *_constNode;
        const VdfConnection *_constConnection;
        const VdfInput      *_constInput;
        const VdfOutput     *_constOutput;
    };
 
    // Holds the type of the object.
    Type    _type;
 
    // If set, the object being held is const.
    bool    _isConst;
};
 
typedef std::vector<VdfObjectPtr> VdfObjectPtrVector;
 
typedef std::set<VdfObjectPtr> VdfObjectPtrSet;
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif