UN_NodeSignature.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_NodeSignature.h ( UN Library, C++)
 *
 * COMMENTS:
 *      
 */

#ifndef __UN_NodeSignature_h__
#define __UN_NodeSignature_h__

#include "UN_API.h"
#include "UN_Iterator.h"

#include <UT/UT_Pair.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_UniquePtr.h>



// ============================================================================
/// The node signature represents a set of available variations of the
/// functional part of the node type, ie, (mainly) the different set of 
/// inputs and outputs, and their types, as well as their corresponding
/// parameters.
/// 
class UN_API UN_NodeSignature 
{
public:
    /// Constructor.
    UN_NodeSignature( const UT_StringRef &signature_name = UT_StringRef(),
                      const UT_StringRef &signature_label = UT_StringRef() );

    /// Returns the name of the signature.
    const UT_StringHolder & name() const
                                { return myName; }

    /// Returns the label of the signature.
    const UT_StringHolder & label() const
                                { return myLabel; }

    /// Adds a new input to the signature, given the input's name and its type.
    /// Returns true on success, or false if a given input is badly named 
    /// or already exists.
    bool                    addInput( const UT_StringRef &name,
                                      const UT_StringRef &type_name);

    /// Returns the list of input names.
    const UT_StringArray &  inputNames() const
                                { return myInputNames; }

    /// Returns the list of input type names.
    const UT_StringArray &  inputTypeNames() const
                                { return myInputTypeNames; }

    /// Returns the input type name given its name.
    const UT_StringHolder & inputTypeName( const UT_StringRef &name ) const;

    /// Iterating over all inputs in the signature.
    using InputNameAndTypeRange = UT_IteratorRange< UN_NameAndTypeIterator >;
    InputNameAndTypeRange   inputNameAndTypeRange() const;


    /// Adds a new output to the signature, given the output's name and type.
    /// Returns true on success, or false if a given output is badly named 
    /// or already exists.
    bool                    addOutput( const UT_StringRef &name,
                                       const UT_StringRef &type_name);

    /// Returns the list of output names.
    const UT_StringArray &  outputNames() const
                                { return myOutputNames; }

    /// Returns the list of output type names.
    const UT_StringArray &  outputTypeNames() const
                                { return myOutputTypeNames; }

    /// Iterating over all outputs in the signature.
    using OutputNameAndTypeRange = UT_IteratorRange< UN_NameAndTypeIterator >;
    OutputNameAndTypeRange  outputNameAndTypeRange() const;


    /// Adds a new parameter to the signature, given the parm's name and type.
    /// Returns true on success, or false if a given parm is badly named 
    /// or already exists.
    bool                    addParm( const UT_StringRef &name,
                                     const UT_StringRef &type_name);

    /// Returns the list of parameter names.
    const UT_StringArray &  parmNames() const
                                { return myParmNames; }

    /// Returns the list of parameter type names.
    const UT_StringArray &  parmTypeNames() const
                                { return myParmTypeNames; }

    /// Iterating over all parms in the signature.
    using ParmNameAndTypeRange = UT_IteratorRange< UN_NameAndTypeIterator >;
    ParmNameAndTypeRange    parmNameAndTypeRange() const;

private:
    /// The name of the signature.
    UT_StringHolder         myName;

    /// The label of the signature.
    UT_StringHolder         myLabel;

    /// @{ The names of the inputs and their types in this signature.
    UT_StringArray          myInputNames;
    UT_StringArray          myInputTypeNames;
    /// @}

    /// @{ The names of the outputs and their types in this signature.
    UT_StringArray          myOutputNames;
    UT_StringArray          myOutputTypeNames;
    /// @}

    // TODO: FIXME: how about the parameter layout?
    /// @{ The names of the parameters and their types in this signature.
    UT_StringArray          myParmNames;
    UT_StringArray          myParmTypeNames;
    /// @}
};


/// A handle to the signature object, for expressing the ownership of signature.
using UN_NodeSignatureHandle = UT_UniquePtr< UN_NodeSignature >;


#endif