COP_Signature.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.
 *
 */

#pragma once

#include "COP_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>

/// Types of basic data that are passed around a COP network.
typedef enum {
    COP_TYPE_UNDEF      = 0,
    COP_TYPE_METADATA,
    COP_TYPE_INT,
    COP_TYPE_FLOAT,
    COP_TYPE_VECTOR2,
    COP_TYPE_VECTOR,
    COP_TYPE_VECTOR4,
    COP_TYPE_GEO
} COP_Type;

/// Returns true if src is implicitly convertible to dst.
COP_API bool COPtypeIsConvertible(COP_Type src, COP_Type dst);

COP_API const char *COPtypeLabel(COP_Type t);
COP_API COP_Type COPtypeFromLabel(const char* label);

COP_API inline int COPtypeChannels(const COP_Type t)
{
    switch (t)
    {
        case COP_TYPE_VECTOR2: return 2;
        case COP_TYPE_VECTOR:  return 3;
        case COP_TYPE_VECTOR4: return 4;
        default:               return 1;
    }
}

class COP_PortData;
class IMX_Layer;

/// Type of data that was output by a COP_Verb
COP_API COP_Type COPtype(const COP_PortData&);
/// Type of data for the given layer
COP_API COP_Type COPtype(const IMX_Layer&);

/// Signature for a node.
/// Signature consists of a name (internal and label), and lists of types for
/// the inputs and outputs.
/// The *number* of inputs and outputs is independent of this and set by the
/// verb min/max Inputs/Outputs and the current state of the GUI. If not enough
/// types are specified the last one is repeated for any extra inputs and outputs.
/// This helps with making signatures reusable between different verbs.
class COP_API COP_Signature
{
public:
    /// same as COP_Signature("default", "Default")
    COP_Signature() : COP_Signature("default", "Default") {}
    /// Constructs a new signature with the given name and label.
    COP_Signature(const UT_StringHolder &name, const UT_StringHolder &label);
    /// Constructs a new signature with the given name, label, and number of
    /// inputs and outputs.
    COP_Signature(const UT_StringHolder &name, const UT_StringHolder &label,
                  int inputs, int outputs);
    /// Constructs a new signature with the given name, label, and lists of
    /// inputs and outputs. A character in a list corresponds to an input or
    /// output. Its type can be one of the following:
    ///     i:      COP_TYPE_INT
    ///     m:      COP_TYPE_METADATA
    ///     f/1:    COP_TYPE_FLOAT
    ///     u/2:    COP_TYPE_VECTOR2
    ///     v/3:    COP_TYPE_VECTOR
    ///     p/4:    COP_TYPE_VECTOR4
    ///     g:      COP_TYPE_GEO
    COP_Signature(const UT_StringHolder &name, const UT_StringHolder &label,
                  const UT_StringRef &input_list,
                  const UT_StringRef &output_list);

#if 0
    /// Call this function to set all inputs at once using the variadic
    /// arguments.
    template <typename... TYPE>
    void setInputs(TYPE... inputs);
    /// Call this function to set all outputs at once using the variadic
    /// arguments.
    template <typename... TYPE>
    void setOutputs(TYPE... outputs);
#endif

    /// Returns the cost of converting all inputs of this signature into types
    /// from the array.
    /// If abort_on_impossible is true, returns -1 if one of the inputs is not
    /// convertible.
    int getInputConversionCost(const UT_Array<COP_Type> &inputs,
                               bool abort_on_impossible = false) const;

    /// Sets the number of inputs for this signature. If the current size
    /// is not zero, the last entry is duplicated to fill array.
    void setNumberOfInputs(int inputs);
    /// Sets the number of outputs for this signature. If the current size
    /// is not zero, the last entry is duplicated to fill array.
    void setNumberOfOutputs(int outputs);
    /// Sets the type of an input.
    void setInput(int input, COP_Type type);
    /// Sets the type of an output;
    void setOutput(int output, COP_Type type);

    /// Returns the number of inputs.
    int getNumberOfInputs() const;
    /// Returns the number of outputs.
    int getNumberOfOutputs() const;
    /// Get type of the input at the specified index.
    COP_Type getInputType(int index) const;
    /// Get type of the output at the specified index.
    COP_Type getOutputType(int index) const;

    /// Returns true if inputs (starting at i_start) are convertible from the
    /// outputs (starting at o_start). That is, false is returned if
    ///     - (inputs - i_start) is larger (outputs - o_start), or
    ///     - inputType(k) is not convertible into outputType(k-i_start+o_start)
    ///       for some (inputs > k >= i_start).
    bool inputsMatchOutputs(int i_start = 0, int o_start = 0) const;

    /// Returns the internal name of this signature.
    const UT_StringHolder &getName() const { return myName; }
    /// Returns the English label for this signature.
    const UT_StringHolder &getLabel() const { return myLabel; }
    /// Changes name of this signature.
    void setName(const UT_StringHolder& name) { myName = name; }
    /// Changes label for this signature.
    void setLabel(const UT_StringHolder& label) { myLabel = label; }

    /// Removes the input at the given index.
    void removeInput(int index);
    /// Removes the output at the given index.
    void removeOutput(int index);

    UT_StringHolder format() const;

protected:
    /// List of input types for this signature.
    UT_Array<COP_Type>          myInputTypes;
    /// List of output types for this signature.
    UT_Array<COP_Type>          myOutputTypes;
    /// The signature's internal name.
    UT_StringHolder             myName;
    /// The signature's label.
    UT_StringHolder             myLabel;

    friend class                COP_OperatorInfo;
};