PDG_NodePorts.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.
 *
 * COMMENTS:
 */

#ifndef __PDG_NODE_PORTS_H__
#define __PDG_NODE_PORTS_H__

#include "PDG_API.h"
#include "PDG_Port.h"
#include "PDG_Types.h"

#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_UniquePtr.h>

/*
 * Helper class that contains a table of PDG_Ports for a node.
 */
class PDG_API PDG_NodePorts : UT_NonCopyable
{
public:
    /// Returns the total memory usage of this instance
    int64                   getMemoryUsage(bool inclusive) const;

    /// Sorts the ports stored in this instance by there isOrdered flag, for
    /// the specified type.
    void                    sort(PDG_PortType port_type);


    /// Returns the total number of ports of the specified type
    int                     count(PDG_PortType port_type) const
                                { return myPortArrays[(int)port_type].size(); }

    /// Returns the array of ports for the specified type
    const PDG_PortArray&    ports(PDG_PortType port_type) const
                                { return myPortArrays[(int)port_type]; }


    /// Returns the first port that matches the specified name, regardless of
    /// port type. Returns nullptr if no port is found.
    PDG_Port*               port(const UT_StringHolder& name) const;

    /// Returns the port at the specified index and type, or nullptr if no
    /// port is found at that index
    PDG_Port*               port(PDG_PortType port_type, int index) const;

    /// Returns the port with the specified name and type, or nullptr if no
    /// port exists with that name
    PDG_Port*               port(
                                PDG_PortType port_type,
                                const UT_StringHolder& name) const;

    /// Adds a new port to the table
    template <typename... Args>
    PDG_Port*               add(Args&&... args)
                                {
                                    PortPtr port_ptr = UTmakeUnique<PDG_Port>(
                                        std::forward<Args>(args)...);

                                    PDG_PortType type = port_ptr->portType();
                                    const UT_StringHolder& name =
                                        port_ptr->name();
                                    PDG_Port* port = port_ptr.get();

                                    myPortArrays[(int)type].append(port);
                                    myPortMaps[(int)type][name] =
                                        std::move(port_ptr);

                                    return port;
                                }

    /// Removes a port with the specified name and type
    bool                    remove(
                                PDG_PortType port_type,
                                const UT_StringHolder& name);

    /// Clears all ports of the specified type
    void                    clear(PDG_PortType port_type);

private:
    using PortPtr           = UT_UniquePtr<PDG_Port>;
    using PortMap           = UT_ArrayStringMap<PortPtr>;

private:
    PDG_PortArray           myPortArrays[(int)PDG_PortType::eCount];
    PortMap                 myPortMaps[(int)PDG_PortType::eCount];
};

#endif