UN_GraphTopology.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UN_GraphTopology.h ( UN Library, C++)
 *
 * COMMENTS:
 *      
 */

#ifndef __UN_GraphTopology_h__
#define __UN_GraphTopology_h__

#include "UN_API.h"
#include "UN_Include.h"
#include <UT/UT_ArrayMap.h>
#include <UT/UT_Optional.h>

// ============================================================================
/// Container for the information about connections between various
/// graph elements:
/// - which node has which ports, and which ports are connected with which wires
/// - which node has which parent, and which node has which children

class UN_API UN_GraphTopology
{
public:
    /// Clear all the relationships between graph elements.
    void            clear();

    /// Merges in the graph element relationships from another topology.
    void            merge( const UN_GraphTopology &other,
                           const UN_IDRemapInfo &id_remap_info );

    // TODO: FIXME: unify method names to allow easier template programming
    /// Returns a parent node of the given child node.
    /// This may include an implicitly created graph's root node, 
    /// which is isn't really a real user-created node. 
    /// Use nonRootNodeParent() to get a parent that was explicitly created.
    UN_NodeID       nodeParent( UN_NodeID child_node ) const
                        { return findMapEntry( myNodeToParentMap, child_node );}

    /// Returns an explicitly created parent node of the given child node.
    /// Ie, for top-level graph nodes whose parent is the implicitly created
    /// graph's root, this method will return an invalid node ID.
    /// Use nodeParent() to include the root node too.
    UN_NodeID       nonRootNodeParent( UN_NodeID child_node ) const
                        { 
                            auto parent = findMapEntry( 
                                    myNodeToParentMap, child_node );
                            return UNisRoot(parent) ? UN_NodeID() : parent;
                        }


    /// @{ Returns child nodes of a given parent subnet node.
    const UN_NodeIDList &
                    nodeChildNodes( UN_NodeID parent_node ) const
                        { return subnetChildNodes( nodeSubnet( parent_node )); }

    const UN_NodeIDList &
                    subnetChildNodes( UN_SubnetID parent_subnet ) const
                        { 
                            return findMapEntry( mySubnetToChildNodesMap, 
                                    parent_subnet, myEmptyNodeList ); 
                        }
    /// @}
    
    /// @{ Returns child wires of a given parent subnet node.
    const UN_WireIDList &
                    nodeChildWires( UN_NodeID parent_node ) const
                        { return subnetChildWires( nodeSubnet( parent_node )); }

    const UN_WireIDList &
                    subnetChildWires( UN_SubnetID parent_subnet ) const
                        { 
                            return findMapEntry( mySubnetToChildWiresMap, 
                                    parent_subnet, myEmptyWireList ); 
                        }
    /// @}
   
    /// @{ Returns child sticky notes of a given parent subnet node.
    const UN_StickyNoteIDList &
                    nodeChildStickyNotes( UN_NodeID parent_node ) const
                        { 
                            return subnetChildStickyNotes( 
                                nodeSubnet( parent_node )); 
                        }

    const UN_StickyNoteIDList &
                    subnetChildStickyNotes( UN_SubnetID parent_subnet ) const
                        { 
                            return findMapEntry( mySubnetToChildStickyNotesMap, 
                                    parent_subnet, myEmptyStickyNoteList ); 
                        }
    /// @}


    /// Returns a subnet object of the given (owner parent) node.
    /// The subnet contains information about the given node's children, etc.
    UN_SubnetID     nodeSubnet( UN_NodeID owner_node ) const
                        { return findMapEntry( myNodeToSubnetMap, owner_node );}

    /// Returns an owner node of the given subnet.
    UN_NodeID       subnetNode( UN_SubnetID subnet ) const
                        { return findMapEntry( mySubnetToNodeMap, subnet ); }


    /// Returns a parent node of the given wire.
    UN_NodeID       wireParent( UN_WireID wire ) const
                        { 
                            return wireParent( 
                                    wireSrcPort( wire ), wireDstPort( wire ));
                        }

    /// Returns a parent node of the wire that connects the given ports.
    UN_NodeID       wireParent( UN_PortID src_port, UN_PortID dst_port ) const;

    /// Returns a source port of the given wire.
    /// Ie, a port from which this wire takes (receives) data.
    UN_PortID       wireSrcPort( UN_WireID wire ) const
                        { return findMapEntry( myWireToSrcPortMap, wire ); }

    /// Returns a destination port of the given wire.
    /// Ie, a port to which this wire provides (sends) data.
    UN_PortID       wireDstPort( UN_WireID wire ) const
                        { return findMapEntry( myWireToDstPortMap, wire ); }


    /// Returns parameters of a given node.
    const UN_ParmIDList &
                    nodeParms( UN_NodeID node ) const
                        { 
                            return findMapEntry( myNodeToParmsMap, node, 
                                    myEmptyParmList ); 
                        }

    /// Returns an owner node of the given parameter.
    UN_NodeID       parmNode( UN_ParmID parm ) const
                        { return findMapEntry( myParmToNodeMap, parm ); }


    /// Returns input ports of the given node.
    const UN_PortIDList &
                    nodeInputPorts( UN_NodeID node ) const
                        { 
                            return findMapEntry( myNodeToInputPortsMap, 
                                    node, myEmptyPortList );
                        }

    /// Returns output ports of a given node.
    const UN_PortIDList &
                    nodeOutputPorts( UN_NodeID node ) const
                        { 
                            return findMapEntry( myNodeToOutputPortsMap, 
                                    node, myEmptyPortList );
                        }



    /// Returns an owner node of the given port.
    UN_NodeID       portNode( UN_PortID port ) const
                        { return findMapEntry( myPortToNodeMap, port ); }

    /// Returns the port kind (input or output) of the given port.
    UN_PortKind     portKind( UN_PortID port ) const
                        { 
                            if( !port )
                                return UN_PortKind::Invalid;

                            auto it = myPortToKindFlagMap.find( port );
                            if( it == myPortToKindFlagMap.end() )
                                return UN_PortKind::Invalid;
                            else if( it->second )
                                return UN_PortKind::Output;
                            else
                                return UN_PortKind::Input;
                        }
                        
    /// Returns source wires connected to the given port.
    /// Ie, connection wires from which this port takes (receives) data.
    const UN_WireIDList &
                    portSrcWires( UN_PortID port ) const
                        { 
                            return findMapEntry( myPortToSrcWiresMap, port,
                                    myEmptyWireList );
                        }

    /// Returns destination wires connected to the given port.
    /// Ie, connection wires to which this port provides (sends) data.
    const UN_WireIDList &
                    portDstWires( UN_PortID port ) const
                        { 
                            return findMapEntry( myPortToDstWiresMap, port,
                                    myEmptyWireList );
                        }

    /// Returns a parent node of the given child sticky note.
    UN_NodeID       stickyNoteParent( UN_StickyNoteID child_sticky_note ) const
                        { return findMapEntry( myStickyNoteToParentMap, 
                                               child_sticky_note );}


    /// Adds a new subnet to the topology, and links it with the given node,
    /// making that node a subnet (a parent) that can contain children.
    void            addSubnet( UN_SubnetID new_subnet, UN_NodeID owner_node );

    /// Removes the subnet from the topology data structures.
    void            deleteSubnet( UN_SubnetID subnet );



    /// Adds a new node to the topology, and links it as a child 
    /// of the given parent node, which already exists in the topology
    /// along with a subnet object associated with it.
    void            addNode( UN_NodeID new_node, UN_NodeID parent_node );

    /// Removes the node from the topology data structures.
    void            deleteNode( UN_NodeID node );

    /// Moves a node from one parent to another.
    void            moveNode( UN_NodeID node, UN_NodeID new_parent );

    /// Moves all children of the given parent node to another one.
    void            moveAllChildNodes( UN_NodeID old_parent, 
                            UN_NodeID new_parent );

    /// Sets the new order for the children of the given parent subnet.
    /// The new order must contain exactly the same child node IDs as 
    /// the current child list of the subnet, just in a different order.
    void            reorderChildren( UN_SubnetID subnet, 
                            const UT_Array<UN_NodeID> &child_order );

    /// Sets the new order for input ports on the given node.
    /// The new order must contain exactly the same port IDs as the current
    /// input port list for the node, just in a different order.
    void            reorderInputPorts( UN_NodeID node,
                            const UN_PortIDList &port_order );

    /// Sets the new order for output ports on the given node.
    /// The new order must contain exactly the same port IDs as the current
    /// output port list for the node, just in a different order.
    void            reorderOutputPorts( UN_NodeID node,
                            const UN_PortIDList &port_order );


    /// Sets the new order for parameters on the given node.
    /// The new order must contain exactly the same parm IDs as the current
    /// parm list for the node, just in a different order.
    void            reorderParms( UN_NodeID node,
                            const UN_ParmIDList &parm_order );

    /// Adds a new parameter to the topology, and
    /// links (adds) it as a parameter of the given node.
    void            addParm( UN_ParmID new_parm, UN_NodeID node );

    /// Removes the parameter from the topology data structures.
    void            deleteParm( UN_ParmID parm );



    /// Adds a new input port to the topology, and
    /// links it as an input of the given node.
    /// @param index If given, this is the index position at which
    ///         to insert the new port.  Negative numbers are wrapped around, 
    ///         and counted backwards (ie, -1 corresponds to the *current* 
    ///         last port). If not given, the new port is appended to the node.
    void            addInputPort( UN_PortID new_input_port, UN_NodeID node,
                                const UT_Optional<exint> &index = std::nullopt);

    /// Adds a new output port to the topology, and
    /// links it as an output of the given node.
    /// @param index If given, this is the index position at which
    ///         to insert the new port.  Negative numbers are wrapped around, 
    ///         and counted backwards (ie, -1 corresponds to the *current* 
    ///         last port). If not given, the new port is appended to the node.
    void            addOutputPort( UN_PortID new_output_port, UN_NodeID node,
                                const UT_Optional<exint> &index = std::nullopt);

    /// Removes the port from the topology data structures.
    /// Returns the list of wires that also got removed (deleted), 
    /// because they were connected to the port being deleted.
    UN_WireIDList   deletePort( UN_PortID port );



    /// Adds a new wire to the topology, and links it with the two ports. Ie,
    /// creates a connection between the two given ports, 
    /// from the source port to the destination port.
    void            addWire( UN_WireID new_wire,
                             UN_PortID src_port, 
                             UN_PortID dst_port );

    /// Removes the wire from the topology data structures.
    void            deleteWire( UN_WireID wire );

    /// Updates the internal dictionaries after nodes have been moved to a
    /// new subnet.
    void            updateSubnetWires( UN_SubnetID old_subnet );


    /// Adds a new sticky note to the topology, and links it as a child 
    /// of the given parent node, which already exists in the topology
    /// along with a subnet object associated with it.
    void            addStickyNote( UN_StickyNoteID new_sticky_note, 
                            UN_NodeID parent_node );

    /// Removes the sticky note from the topology data structures.
    void            deleteStickyNote( UN_StickyNoteID sticky_note );


private:

    /// Links the given parent node to a subnet, allowing it to have children.
    void            setNodeSubnet( UN_NodeID node, UN_SubnetID subnet )
                        { addMapEntry( myNodeToSubnetMap, node, subnet );}

    /// Deletes the node entry that links it to its subnet.
    void            eraseNodeSubnet( UN_NodeID node )
                        { removeMapEntry( myNodeToSubnetMap, node ); }



    /// Links the given subnet to a node (a parent).
    void            setSubnetNode( UN_SubnetID subnet, UN_NodeID node )
                        { addMapEntry( mySubnetToNodeMap, subnet, node );}

    /// Deletes the subnet entry that links it to its node.
    void            eraseSubnetNode( UN_SubnetID subnet )
                        { removeMapEntry( mySubnetToNodeMap, subnet ); }



    /// Adds a node to a given subnet.
    void addSubnetChildNode( UN_SubnetID subnet, UN_NodeID child_node )
    { 
        addElementToMapEntry( mySubnetToChildNodesMap, subnet, child_node );
    }

    /// Removes a node from a given subnet.
    void removeSubnetChildNode( UN_SubnetID subnet, UN_NodeID child_node )
    { 
        findAndRemoveElementFromMapEntry( mySubnetToChildNodesMap, 
                subnet, child_node );
    }

    /// Deletes the subnet entry that links it to its children.
    void eraseSubnetChildNodes( UN_SubnetID subnet )
    {
        removeMapEntry( mySubnetToChildNodesMap, subnet );
    }


    /// Adds a wire to a given subnet.
    void addSubnetChildWire( UN_SubnetID subnet, UN_WireID child_wire )
    { 
        addElementToMapEntry( mySubnetToChildWiresMap, subnet, child_wire );
    }

    /// Removes a wire from a given subnet.
    void removeSubnetChildWire( UN_SubnetID subnet, UN_WireID child_wire )
    { 
        findAndRemoveElementFromMapEntry( mySubnetToChildWiresMap, 
                subnet, child_wire );
    }

    /// Deletes the subnet entry that links it to its wires.
    void eraseSubnetChildWires( UN_SubnetID subnet )
    {
        removeMapEntry( mySubnetToChildWiresMap, subnet );
    }

  
    /// Adds a sticky note to a given subnet.
    void addSubnetChildStickyNote( UN_SubnetID subnet, 
            UN_StickyNoteID child_sticky_note )
    { 
        addElementToMapEntry( mySubnetToChildStickyNotesMap, 
                subnet, child_sticky_note );
    }

    /// Removes a node from a given subnet.
    void removeSubnetChildStickyNote( UN_SubnetID subnet, 
            UN_StickyNoteID child_sticky_note )
    { 
        findAndRemoveElementFromMapEntry( mySubnetToChildStickyNotesMap, 
                subnet, child_sticky_note );
    }

    /// Deletes the subnet entry that links it to its children.
    void eraseSubnetChildStickyNotes( UN_SubnetID subnet )
    { 
        removeMapEntry( mySubnetToChildStickyNotesMap, subnet );
    }


    /// Links the given child node to a parent node.
    void            setNodeParent( UN_NodeID child, UN_NodeID parent )
                        { addMapEntry( myNodeToParentMap, child, parent);}

    /// Deletes the node entry that links it to its parent.
    void            eraseNodeParent( UN_NodeID child )
                        { removeMapEntry( myNodeToParentMap, child ); }



    /// Adds a parameter to a given node.
    // Note, all nodes can have parameters, so we automatically create 
    // a parm list entry in the map just-in-time, if it does not exist yet.
    void            addNodeParm( UN_NodeID node, UN_ParmID parm )
                        { 
                            addElementToMapEntry( myNodeToParmsMap, 
                                    node, parm );
                        }

    /// Removes a parameter from a given node.
    void            removeNodeParm( UN_NodeID node, UN_ParmID parm )
                        { 
                            findAndRemoveElementFromMapEntry( 
                                    myNodeToParmsMap, node, parm );
                        }

    /// Deletes the node entry that links it to its parameters.
    void            eraseNodeParms( UN_NodeID node )
                        { removeMapEntry( myNodeToParmsMap, node ); }



    /// Links a given parameter to a node it belongs to.
    void            setParmNode( UN_ParmID parm, UN_NodeID node )
                        { addMapEntry( myParmToNodeMap, parm, node ); }

    /// Deletes the parameter entry that links it to its owner node.
    void            eraseParmNode( UN_ParmID parm )
                        { removeMapEntry( myParmToNodeMap, parm ); }


    
    /// Adds an input port to a given node.
    void            addNodeInputPort( UN_NodeID node, UN_PortID port,
                                const UT_Optional<exint> &index = std::nullopt )
                        { 
                            addElementToMapEntry( myNodeToInputPortsMap, 
                                    node, port, index );
                        }

    /// Removes an input port from a given node.
    void            removeNodeInputPort( UN_NodeID node, UN_PortID port )
                        { 
                            findAndRemoveElementFromMapEntry( 
                                    myNodeToInputPortsMap, node, port );
                        }

    /// Deletes the node entry that links it to its input ports.
    void            eraseNodeInputPorts( UN_NodeID node )
                        { removeMapEntry( myNodeToInputPortsMap, node ); }



    /// Adds an output port to a given node.
    void            addNodeOutputPort( UN_NodeID node, UN_PortID port,
                                const UT_Optional<exint> &index = std::nullopt )
                        { 
                            addElementToMapEntry( myNodeToOutputPortsMap, 
                                    node, port, index );
                        }

    /// Removes an output port from a given node.
    void            removeNodeOutputPort( UN_NodeID node, UN_PortID port )
                        { 
                            findAndRemoveElementFromMapEntry( 
                                    myNodeToOutputPortsMap, node, port );
                        }

    /// Deletes the node entry that links it to its output ports.
    void            eraseNodeOutputPorts( UN_NodeID node )
                        { removeMapEntry( myNodeToOutputPortsMap, node ); }



    /// Links a given port to a node it belongs to.
    void            setPortNode( UN_PortID port, UN_NodeID node )
                        { addMapEntry( myPortToNodeMap, port, node ); }

    /// Deletes the port entry that links it to its owner node.
    void            erasePortNode( UN_PortID port )
                        { removeMapEntry( myPortToNodeMap, port ); }



    /// Marks port as an output.
    void            setPortKind( UN_PortID port, UN_PortKind port_kind )
                        {
                            UT_ASSERT( port_kind == UN_PortKind::Input ||
                                       port_kind == UN_PortKind::Output );
                            addMapEntry( myPortToKindFlagMap, port,
                                port_kind == UN_PortKind::Output );
                        }

    /// Deletes the port entry that indicates its kind.
    void            erasePortKind( UN_PortID port )
                        { removeMapEntry( myPortToKindFlagMap, port ); }



    /// Adds a wire as a data source of the given port.
    /// Ie, connection wire from which this port takes (receives) data.
    void            addPortSrcWire( UN_PortID port, UN_WireID wire )
                        { 
                            // In virtually all contexts, an input port will 
                            // have at most one source. Set size to reduce mem.
                            static constexpr exint capacity = 1;
                            UT_ASSERT( wire );
                            addElementToMapEntry( myPortToSrcWiresMap, 
                                    port, wire, std::nullopt, capacity );
                        }

    /// Removes a source wire from the given port.
    void            removePortSrcWire( UN_PortID port, UN_WireID wire )
                        { 
                            findAndRemoveElementFromMapEntry( 
                                    myPortToSrcWiresMap, port, wire );
                        }

    /// Deletes the port entry that links it to its source wire.
    void            erasePortSrcWires( UN_PortID port )
                        { removeMapEntry( myPortToSrcWiresMap, port ); }



    /// Adds a wire as a data destination for the given port.
    /// Ie, connection wire to which this port provides (sends) data.
    void            addPortDstWire( UN_PortID port, UN_WireID wire )
                        { 
                            // In most contexts, the guess is that output port 
                            // will have about two destination wires. 
                            // So pre-emptively set capacity before adding one.
                            static constexpr exint capacity = 2;
                            UT_ASSERT( wire );
                            addElementToMapEntry( myPortToDstWiresMap, 
                                    port, wire, std::nullopt, capacity );
                        }

    /// Removes a destination wire from the given port.
    void            removePortDstWire( UN_PortID port, UN_WireID wire )
                        { 
                            findAndRemoveElementFromMapEntry( 
                                    myPortToDstWiresMap, port, wire );
                        }

    /// Deletes the port entry that links it to its destination wire.
    void            erasePortDstWires( UN_PortID port )
                        { removeMapEntry( myPortToDstWiresMap, port ); }



    /// Links a given wire to a source port it connects.
    void            setWireSrcPort( UN_WireID wire, UN_PortID port )
                        { addMapEntry( myWireToSrcPortMap, wire, port ); }

    /// Deletes the wire entry that links it to its source port.
    void            eraseWireSrcPort( UN_WireID wire )
                        { removeMapEntry( myWireToSrcPortMap, wire ); }


    /// Links a given wire to a source port it connects.
    void            setWireDstPort( UN_WireID wire, UN_PortID port )
                        { addMapEntry( myWireToDstPortMap, wire, port ); }

    /// Deletes the wire entry that links it to its destination port.
    void            eraseWireDstPort( UN_WireID wire )
                        { removeMapEntry( myWireToDstPortMap, wire ); }


    /// Links the given child sticky note to a parent node.
    void            setStickyNoteParent(UN_StickyNoteID child, UN_NodeID parent)
                        { addMapEntry( myStickyNoteToParentMap, child, parent);}

    /// Deletes the node entry that links it to its parent.
    void            eraseStickyNoteParent( UN_StickyNoteID child )
                        { removeMapEntry( myStickyNoteToParentMap, child ); }



private:
    /// Helper function to add an entry for the value given its key in the map.
    template <typename K, typename V>
    static inline void addMapEntry( UT_ArrayMap<K, V> &map, K key, V value ) 
    {
        if( key )
            map[ key ] = value; 
    }

    /// Helper function to remove an entry given the key in the map.
    template <typename K, typename V>
    static inline void removeMapEntry( UT_ArrayMap<K, V> &map, K key ) 
    {
        if( key )
            map.erase( key );
    }

    /// Helper function to look up a value given the key in to the given map.
    template <typename K, typename V>
    static inline V findMapEntry( const UT_ArrayMap<K, V> &map, K key ) 
    {
        if( !key )
            return V();
        auto it = map.find( key );
        if( it == map.end() )
            return V();
        return it->second;
    }

    /// Helper function to look up a value given the key in to the given map.
    template <typename K, typename V>
    static inline const V &
    findMapEntry( const UT_ArrayMap<K, V> &map, K key, const V &default_value ) 
    {
        if( !key )
            return default_value;
        auto it = map.find( key );
        if( it == map.end() )
            return default_value;
        return it->second;
    }

    /// Helper function to append an element to the array entry in the map.
    template <typename K, typename V>
    static inline void addElementToMapEntry( 
            UT_ArrayMap<K, UT_Array<V>> &map, K key, const V& element,
            const UT_Optional<exint> &index = std::nullopt,
            exint capacity = -1 ) 
    { 
        if( !key )
            return;
        auto &array = map[ key ];
        UT_ASSERT_SLOW( array.find(element) < 0 );
        if( capacity > 0 )
            array.setCapacityIfNeeded( capacity );

        exint size = array.size();
        if( !index || *index == size )
            array.append( element );
        else
            array.insert( element, SYSwrapmod( *index, size ));
    }

    /// Helper function to remove an element from the array entry in the map.
    template <typename K, typename V>
    static inline void findAndRemoveElementFromMapEntry( 
            UT_ArrayMap<K, UT_Array<V>> &map, K key, const V& element ) 
    {
        if( !key )
            return;
        auto it = map.find( key );
        if( it == map.end() )
            return;
        it->second.findAndRemove( element );
        UT_ASSERT( it->second.find(element) < 0 );
    }

    /// Empty lists used for returning empty const references from methods.
    static inline const auto    myEmptyNodeList = UN_NodeIDList();
    static inline const auto    myEmptyStickyNoteList = UN_StickyNoteIDList();
    static inline const auto    myEmptyParmList = UN_ParmIDList();
    static inline const auto    myEmptyPortList = UN_PortIDList();
    static inline const auto    myEmptyWireList = UN_WireIDList();


private: 
    /// A map from a node (ie, a parent) to its subnet data (ie, children info).
    UT_ArrayMap< UN_NodeID, UN_SubnetID >       myNodeToSubnetMap;

    // A map from a subnet data to the (subnet) node it belongs to.
    UT_ArrayMap< UN_SubnetID, UN_NodeID >       mySubnetToNodeMap;

    /// A map from a subnet to a list of its child nodes.
    UT_ArrayMap< UN_SubnetID, UN_NodeIDList >   mySubnetToChildNodesMap;

    /// A map from a subnet to a list of the wires it contains (directly).
    /// The wires belong to (are immediatly inside) the subnet, and 
    /// they connect children, but also connect subnet input and output ports.
    UT_ArrayMap< UN_SubnetID, UN_WireIDList >   mySubnetToChildWiresMap;

    /// A map from a subnet to a list of its child sticky notes.
    UT_ArrayMap< UN_SubnetID, UN_StickyNoteIDList >
                                                mySubnetToChildStickyNotesMap;

    /// A map from a child node to its parent.
    UT_ArrayMap< UN_NodeID, UN_NodeID >         myNodeToParentMap;

    /// A map from a node to its parameters.
    UT_ArrayMap< UN_NodeID, UN_ParmIDList >     myNodeToParmsMap;

    /// A map from a parameter to the node it belongs to.
    UT_ArrayMap< UN_ParmID, UN_NodeID >         myParmToNodeMap;

    /// A map from a node to its input ports.
    UT_ArrayMap< UN_NodeID, UN_PortIDList >     myNodeToInputPortsMap;

    /// A map from a node to its output ports.
    UT_ArrayMap< UN_NodeID, UN_PortIDList >     myNodeToOutputPortsMap;

    /// A map from a port to the node it belongs to.
    UT_ArrayMap< UN_PortID, UN_NodeID >         myPortToNodeMap;

    // TODO: FIXME: UT_ArraySet myOutputPortSet approach was very slow. 
    //              Optimized it with UT_ArrayMap, but still 50% slower.
    //              Can we remove this relationship from the topology,
    //              and rely on graph data flag instead? Would it be faster?
    /// A set of output ports. Any port not in this set is an input.
    /// Used to determine the port kind based on the port ID.
    UT_ArrayMap< UN_PortID, bool >              myPortToKindFlagMap;

    /// A map from a port to the list of its source wires.
    UT_ArrayMap< UN_PortID, UN_WireIDList >     myPortToSrcWiresMap;

    /// A map from a port to the list of its destination wires.
    UT_ArrayMap< UN_PortID, UN_WireIDList >     myPortToDstWiresMap;

    /// A map from a wire to its source port that it connects.
    UT_ArrayMap< UN_WireID, UN_PortID >         myWireToSrcPortMap;

    /// A map from a wire to its destination port that it connects.
    UT_ArrayMap< UN_WireID, UN_PortID >         myWireToDstPortMap;

    /// A map from a child sticky note to its parent subnet node.
    UT_ArrayMap< UN_StickyNoteID, UN_NodeID >   myStickyNoteToParentMap;
};


#endif