OP_Node.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:        OP Library (C++)
 *
 * COMMENTS:    The base class for all OP operators
 *
 */

#ifndef __OP_Node_h__
#define __OP_Node_h__

#include "OP_API.h"
#include "OP_BundleReferences.h"
#include "OP_Cache.h"
#include "OP_ConnectorId.h"
#include "OP_Context.h"
#include "OP_DataMicroNode.h"
#include "OP_DataTypes.h"
#include "OP_Dependency.h"
#include "OP_Error.h"
#include "OP_EventMicroNode.h"
#include "OP_InterestRef.h"
#include "OP_ItemId.h"
#include "OP_Lock.h"
#include "OP_NetworkBoxItem.h"
#include "OP_NodeFlags.h"
#include "OP_OpTypeId.h"
#include "OP_OTLLicenseType.h"
#include "OP_Parameters.h"
#include "OP_Value.h"
#include "OP_Version.h"

#include <CH/CH_EventManager.h>
#include <CH/CH_Types.h>
#include <DEP/DEP_MicroNode.h>
#include <UT/UT_Algorithm.h>
#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_Assert.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Color.h>
#include <UT/UT_Error.h>
#include <UT/UT_KnownPath.h>
#include <UT/UT_LockedRawPtr.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Optional.h>
#include <UT/UT_Options.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_SmallArray.h>
#include <UT/UT_String.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_StringView.h>
#include <UT/UT_TokenString.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_XformOrder.h>
#include <SYS/SYS_AtomicInt.h>
#include <SYS/SYS_Deprecated.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_Types.h>

#include <iosfwd>
#include <utility>
#include <limits.h>
#include <string.h>

class UT_CameraParms;
class UT_InfoTree;
class UT_IStream;
class UT_Ramp;
class UT_StringArray;
class UT_Undo;
class UT_WorkArgs;
class UT_WorkBuffer;
class UT_AttributeEvaluator;
class IMG_Raster;
class PY_OpaqueObject;
class PY_Result;
class DD_Source;
class DD_ChoiceList;
class CL_Clip;
class CL_Track;
class CMD_Args;
class CH_Channel;
class CH_ChannelRef;
class CH_LocalVariable;
class PRM_BatchList;
class PRM_Name;
class PRM_Parm;
class PRM_ParmList;
class PRM_ParmMicroNode;
class PRM_RefId;
class PRM_Template;
class OP_Bundle;
class OP_DopParent;
class OP_Dot;
class OP_EditorContext;
class OP_GalleryEntry;
class OP_GlobContext;
class OP_Group;
class OP_IndirectInput;
class OP_Input;
class OP_Network;
class OP_NetworkBox;
class OP_Node;
class OP_NodeInfoParms;
class OP_NodeInfoTreeParms;
class OP_Operator;
class OP_Output;
class OP_OutputCodeParms;
class OP_PostIt;
class OP_PreDefRules;
class OP_PropagateData;
class OP_SaveFlags;
class OP_SubnetIndirectInput;
class OP_UniGraphProvider;
class DOP_Parent;
class VOP_CodeGenerator;
class VOP_ExportedParmsManager;
class VOP_ScriptMaterialCodeMapper;

// avoid lengthy compilation dependency
typedef UT_ValArray<const CL_Track *>   CL_TrackListC;  

typedef int  (*OP_EditCallback)(void *data, OP_Node *src,
                CL_Track *track, fpreal t, fpreal value);

typedef UT_ArrayMap<OP_ConnectorId, OP_Input*>  OP_ConnectorInputMap;
typedef UT_ArrayMap<OP_ConnectorId, OP_Output*> OP_ConnectorOutputMap;
typedef OP_ConnectorInputMap::iterator          OP_ConnectorInputIter;

struct OP_InputPair
{
    OP_InputPair( OP_Input *p, OP_ConnectorId n )
    : myInput(p), myName(n) {}
    OP_Input *myInput;
    OP_ConnectorId myName;
};

struct OP_OutputPair
{
    OP_OutputPair( OP_Output *p, OP_ConnectorId n )
    : myOutput(p), myName(n) {}
    OP_Output *myOutput;
    OP_ConnectorId myName;
};

struct OP_NodeParmRef
{
    OP_NodeParmRef(const OP_Node *eval_node = nullptr,
                   const PRM_Parm *parm_ref = nullptr,
                   int vi = -1)
        : myEvalNode(eval_node)
        , myParmRef(parm_ref)
        , myVectorIndex(vi)
    {
    }

    bool operator==(const OP_NodeParmRef &other)
    {
        return (myEvalNode == other.myEvalNode
                && myParmRef == other.myParmRef
                && myVectorIndex == other.myVectorIndex);
    }

    const OP_Node *     myEvalNode;     // node evaluating the given parameter
    const PRM_Parm *    myParmRef;      // pointer to evaluated parameter
    int                 myVectorIndex;  // parameter component index
};

struct OP_UnresolvedConnection
{
    UT_String myInputName;
    OP_Input* mySavedInput;
};

// Implement this class to change the behavior of OP_Node::notifyVarChange().
// It was too late in the dev cycle of 22.0 to add a virtual method to OP_Node.
class OP_API OP_NotifyVarChange
{
public:
    virtual ~OP_NotifyVarChange(){}
    virtual bool opNotifyVarChange(const char *varname, OP_NodeList *changed_nodes = nullptr) = 0;
};

// Callback to delay the evaluation of a transform
class OP_API OP_TransformCallback
{
public:
    virtual ~OP_TransformCallback(){}
    virtual const UT_Matrix4D& eval(bool &ret) = 0;
};

class OP_API OP_EvaluateTransformTracksArgs
{
public:
    OP_EvaluateTransformTracksArgs(
            const UT_StringHolder& name,
            UT_Matrix4D *w,
            UT_Matrix4D *l = nullptr,
            OP_TransformCallback *parent_cb = nullptr,
            int *timedep = nullptr)
    : myTrackIndex(-1)
    , myTrackCount(1)
    , myTrackName(name)
    , myWorldXfo(w)
    , myLocalXfo(l)
    , myParentXfo(parent_cb)
    , myTimeDep(timedep)
    {}

    OP_EvaluateTransformTracksArgs(
            int index, UT_Matrix4D *w,
            UT_Matrix4D *l = nullptr,
            OP_TransformCallback *parent_cb = nullptr,
            int *timedep = nullptr)
    : myTrackIndex(index)
    , myTrackCount(1)
    , myWorldXfo(w)
    , myLocalXfo(l)
    , myParentXfo(parent_cb)
    , myTimeDep(timedep)
    {}

    // Callback to delay the evaluation of a transform
    UT_StringHolder myTrackName;
    int myTrackIndex;
    int myTrackCount;

    UT_Matrix4D *myWorldXfo;
    UT_Matrix4D *myLocalXfo;
    OP_TransformCallback *myParentXfo;
    int *myTimeDep;
};

// Utility for detecting cycles when traversing graphs
typedef UT_CycleDetect<OP_Node *>       OP_NodeCycleDetect;
typedef UT_CycleDetect<OP_NodeParmRef>  OP_NodeParmRefCycle;

typedef UT_LockedRawPtr<OP_NodeList, OP_Lock> OP_LockedNodeList;
typedef UT_LockedRawPtr<const OP_NodeList, OP_Lock> OP_LockedConstNodeList;
typedef UT_StringMap<UT_UniquePtr<PY_OpaqueObject>> OP_PythonObjectCache;
typedef std::pair<const OP_Node *, OP_OutputIdx> opNodeOutput;

// The prefix used to specify an operator where a path would normally be used.
#define OPREF_PREFIX            "op:"
#define OPREF_PREFIX_LEN        3

// This character is used to separate a node path from a string that
// represents some piece of data within the node's cook result.
#define OP_NODE_DATA_SEPARATOR  ':'

// Default value of hash for compiled code associated with this node that
// shouldn't conflict with the hash of any actual cached code.
#define DEFAULT_COMP_HASH_VALUE (17*19)

// Please, no spaces in these table names!
#define INVALID_TABLE_NAME      "Node"
#define OBJ_TABLE_NAME          "Object"
#define SOP_TABLE_NAME          "Sop"
#define CHOPNET_TABLE_NAME      "ChopNet"
#define CHOP_TABLE_NAME         "Chop"
#define ROP_TABLE_NAME          "Driver"
#define SHOP_TABLE_NAME         "Shop"
#define COP_TABLE_NAME          "Cop"
#define COP2_TABLE_NAME         "Cop2"
#define COP2NET_TABLE_NAME      "CopNet"
#define VOP_TABLE_NAME          "Vop"
#define VOPNET_TABLE_NAME       "VopNet"
#define DOP_TABLE_NAME          "Dop"
#define TOP_TABLE_NAME          "Top"
#define TOPNET_TABLE_NAME       "TopNet"
#define LOP_TABLE_NAME          "Lop"

// Manager and Director table names:
#define MGR_TABLE_NAME          "Manager"
#define DIR_TABLE_NAME          "Director"
#define DATA_TABLE_NAME         "Data"

// These are the "script" directories where help and initialization scripts
// are found.
#define INVALID_SCRIPT_NAME     "node"
#define OBJ_SCRIPT_NAME         "obj"
#define SOP_SCRIPT_NAME         "sop"
#define CHOPNET_SCRIPT_NAME     "ch"
#define CHOP_SCRIPT_NAME        "chop"
#define ROP_SCRIPT_NAME         "out"
#define SHOP_SCRIPT_NAME        "shop"
#define COP_SCRIPT_NAME         "cop"
#define COP2_SCRIPT_NAME        "cop2"
#define COP2NET_SCRIPT_NAME     "img"
#define VOP_SCRIPT_NAME         "vop"
#define VOPNET_SCRIPT_NAME      "vex"
#define DOP_SCRIPT_NAME         "dop"
#define TOP_SCRIPT_NAME         "top"
#define TOPNET_SCRIPT_NAME      "tasks"
#define LOP_SCRIPT_NAME         "lop"

// Manager and Director scripts...  I doubt these will be used.
#define MGR_SCRIPT_NAME         "mgr"
#define DIR_SCRIPT_NAME         "dir"
#define MAT_SCRIPT_NAME         "mat"
#define DATA_SCRIPT_NAME        "data"

// These are the op type names.  These are used by icons among others.
#define INVALID_OPTYPE_NAME     "NODE"
#define OBJ_OPTYPE_NAME         "OBJ"
#define SOP_OPTYPE_NAME         "SOP"
#define CHOPNET_OPTYPE_NAME     "CHOPNET"
#define CHOP_OPTYPE_NAME        "CHOP"
#define ROP_OPTYPE_NAME         "ROP"
#define SHOP_OPTYPE_NAME        "SHOP"
#define COP_OPTYPE_NAME         "COP"
#define COP2_OPTYPE_NAME        "COP2"
#define COP2NET_OPTYPE_NAME     "IMG"
#define VOP_OPTYPE_NAME         "VOP"
#define VOPNET_OPTYPE_NAME      "VOPNET"
#define DOP_OPTYPE_NAME         "DOP"
#define TOP_OPTYPE_NAME         "TOP"
#define TOPNET_OPTYPE_NAME      "TOPNET"
#define LOP_OPTYPE_NAME         "LOP"

// These are the types of the manager nodes & director nodes.
// Manager nodes are things like /shop which don't have a specific
// type 
// The director node is the root node which has everything inside it.
#define MGR_OPTYPE_NAME         "MGR"
#define DIR_OPTYPE_NAME         "DIR"
#define DATA_OPTYPE_NAME        "DATA"

/// Nice label names used by network view, corresponding to OP_OpTypeId
OP_API extern const char *OPtypeIdLabels[NUM_MANAGERS];

// Stores the status of the node - undefined for currently
// uncached state,
enum OP_CompileStatusType
{
    OP_COMPILE_STATUS_UNDEFINED = 0,
    OP_COMPILE_STATUS_COMPILED,
    OP_COMPILE_STATUS_UNCOMPILED
};

// These are some special defines used by VOPs. They need to be here
// because the OP_ConnectionMemory has to handle these operators in a
// special way,
#define OP_NAME_INPUT                   "input"
#define OP_NAME_OUTPUT                  "output"
#define OP_NAME_SUBOUTPUT               "suboutput"
#define OP_NAME_SUBINPUT                "subinput"
#define OP_NAME_COLLECT                 "collect"

// These defines provide a common place where the names of the management
// operator types are defined.
#define SHOP_MANAGEMENT_OPTYPE          "shopnet"
#define COP_MANAGEMENT_OPTYPE           "copnet"
#define COP_FILTERLIST_OPTYPE           "copnet_filterlist"
#define COP2_MANAGEMENT_OPTYPE          "cop2net"
#define ROP_MANAGEMENT_OPTYPE           "ropnet"
#define CHOP_MANAGEMENT_OPTYPE          "chopnet"
#define SOP_MANAGEMENT_OPTYPE           "sopnet"
#define OBJ_MANAGEMENT_OPTYPE           "objnet"
#define VOP_MANAGEMENT_OPTYPE           "vopnet"
#define DOP_MANAGEMENT_OPTYPE           "dopnet"
#define TOP_MANAGEMENT_OPTYPE           "topnet"
#define LOP_MANAGEMENT_OPTYPE           "lopnet"

// This class has each of the above entities filled out.
// You can thus convert between different types by looking up
// with the known key and extracting what you want from this class.
// Looking up by id is fast, the rest requires a scan.
class OP_API OP_TypeInfo
{
public:
    OP_OpTypeId                  myOptypeId;
    const UT_StringHolder        myOptypeName;
    const UT_StringHolder        myTableName;
    const UT_StringHolder        myScriptDir;
};

/// Options class for use with OP_Node::saveCommand()
struct OP_API OP_SaveCommandOptions
{
    // Initialize the options to match the opscript defaults
    OP_SaveCommandOptions
            ( bool values_only_ = false
            , bool defaultstoo_ = true
            , bool docreate_ = true
            , bool doparms_ = true
            , bool doflags_ = true
            , bool dowires_ = true
            , bool dowiresout_ = true
            , bool frames_ = false
            , bool dogeneral_ = false
            , bool dochblock_ = true
            , bool dospareparms_ = true
            , bool omit_version_info_ = false
            )
        : values_only(values_only_)
        , defaultstoo(defaultstoo_)
        , docreate(docreate_)
        , doparms(doparms_)
        , doflags(doflags_)
        , dowires(dowires_)
        , dowiresout(dowiresout_)
        , frames(frames_)
        , dogeneral(dogeneral_)
        , dochblock(dochblock_)
        , dospareparms(dospareparms_)
        , omit_version_info(omit_version_info_)
    {
    }

    bool values_only;
    bool defaultstoo;
    bool docreate;
    bool doparms;
    bool doflags;
    bool dowires;
    bool dowiresout;
    bool frames;
    bool dogeneral;
    bool dochblock;
    bool dospareparms;
    bool omit_version_info;
};

//___________________________________________________________________________


//
// a container class to describe the instantaneous state of a parameter
//
class OP_API opParmData
{
public:
    fpreal       myValue;
    UT_String    myLabel;
    OP_Node     *myNode;
    int          myIndex;
    int          mySubIndex;

    int          operator==(const opParmData &v) const
                 {
                     return (myValue == v.myValue && 
                             myLabel == v.myLabel &&
                             myNode == v.myNode &&
                             myIndex == v.myIndex &&
                             mySubIndex == v.mySubIndex
                             );
                 }
};


// Blank class definitions for all our node types...
class OBJ_Node;
class SOP_Node;
class CHOPNET_Node;
class CHOP_Node;
class COP_Node;
class COP2_Node;
class COP2NET_Node;
class ROP_Node;
class TOP_Node;
class TOPNET_Node;
class LOP_Node;
class SHOP_Node;
class VOP_Node;
class VOPNET_Node;
class DOP_Node;

#define INSTANTIATE_FINDNODE_FUNCTIONS(PREFIX)                  \
    PREFIX##_Node *find##PREFIX##Node(const char *path) const   \
    {                                                           \
        OP_Node         *node;                                  \
                                                                \
        node = findNode(path);                                  \
        if (node) return node->castTo##PREFIX##Node();          \
        return 0;                                               \
    }
#define INSTANTIATE_CASTNODE_FUNCTIONS(PREFIX)                  \
    PREFIX##_Node *castTo##PREFIX##Node() const                 \
    {                                                           \
        /* If this is triggered, use CAST_FOONODE instead */    \
        /* This is because foo->bar() should not be done with */ \
        /* NULL foo for aesthetic reasons. */                   \
        { const void *this_local = this;                        \
          UT_ASSERT(this_local);                                \
          if (!this_local) return 0; }                          \
        if (getOpTypeID() == PREFIX##_OPTYPE_ID)                \
        {                                                       \
            return (PREFIX##_Node *) this;                      \
        }                                                       \
        return 0;                                               \
    }

/// This macro allows us to run another macro for all node types
#define INSTANTIATE_FOR_ALL_NODE_TYPES(MACRO_FUNC)              \
    MACRO_FUNC(OBJ)                                             \
    MACRO_FUNC(SOP)                                             \
    MACRO_FUNC(CHOPNET)                                         \
    MACRO_FUNC(CHOP)                                            \
    MACRO_FUNC(ROP)                                             \
    MACRO_FUNC(SHOP)                                            \
    MACRO_FUNC(COP)                                             \
    MACRO_FUNC(COP2)                                            \
    MACRO_FUNC(COP2NET)                                         \
    MACRO_FUNC(VOP)                                             \
    MACRO_FUNC(VOPNET)                                          \
    MACRO_FUNC(DOP)                                             \
    MACRO_FUNC(TOP)                                             \
    MACRO_FUNC(TOPNET)                                          \
    MACRO_FUNC(LOP)

OP_API extern const UT_StringHolder OP_USERDATA_NODESHAPE;
OP_API extern const UT_StringHolder OP_USERDATA_BGIMAGES;
OP_API extern const UT_StringHolder OP_USERDATA_WIRESTYLE;
OP_API extern const UT_StringHolder OP_USERDATA_DESCRIPTIVE_PARM;
OP_API extern const UT_StringHolder OP_USERDATA_OPMENUFILE;
OP_API extern const UT_StringHolder OP_USERDATA_CHILDOPMENUFILE;

class OP_API OP_Node : public OP_Parameters, public OP_NetworkBoxItem
{
public:
    // Methods to convert our enums and strings:
    static const OP_TypeInfo    *getOpInfoFromOpTypeID(OP_OpTypeId opid);
    static const OP_TypeInfo    *getOpInfoFromOpTypeName(const char *name);
    static const OP_TypeInfo    *getOpInfoFromTableName(const char *name);
    static const OP_TypeInfo    *getOpInfoFromScriptDir(const char *dir);

    OP_Network          *getParent()  const
                         { return myParent; }
    OP_Network          *getRootCompiledParent() const
                         { return myRootCompiledParent; }
    
    //Return the network this item resides in (i.e. getParent()). This method
    //was introduced to provide a standardized way of accessing the parent
    //network of all different network box item types.
    OP_Network          *getParentNetwork() const override;

    // This function looks up our parent tree to determine if the given node
    // is our parent, grandparent, great-grandparent...
    bool                 getIsContainedBy(const OP_Node *testparent) const;

    /// Return the name of this node's parent
    const UT_StringHolder       &getNetName() const;

    /// This returns the OP_OpTypeId which corresponds to this node type.
    /// Management nodes will return the type they really are, which
    /// is likely different than the network they currently reside in.
    virtual OP_OpTypeId  getOpTypeID() const
                         { return INVALID_OPTYPE_ID; }

    // This is the proper way to determine the optype.
    // Do not assume your parents child type is your type!  This will only
    // become less true as time goes on :>
    // The strings returned are the *_OPTYPE_NAME defined above
    virtual const char  *getOpType() const;

    OP_ItemType          getItemType() const override;
    
    /// @anchor OP_Node_findFOONode
    ///
    /// FOO_Node *findFOONode(const char *path) const; @n
    ///     This function searches for the node at path relative
    ///     to this node.  If not found, or if the found node is
    ///     not of type FOO_Node, it returns NULL.  The result
    ///     is already cast to FOO_Node.
    ///     findOBJNode(const char *path)
    ///     findSOPNode(const char *path)
    ///     findCHOPNETNode(const char *path)
    ///     findCHOPNode(const char *path)
    ///     findROPNode(const char *path)
    ///     findSHOPNode(const char *path)
    ///     findCOPNode(const char *path)
    ///     findCOP2Node(const char *path)
    ///     findCOP2NETNode(const char *path)
    ///     findCOPNode(const char *path)
    ///     findVOPNode(const char *path)
    ///     findVOPNETNode(const char *path)
    ///     findDOPNode(const char *path)
    ///     findTOPNode(const char *path)
    ///     findTOPNETNode(const char *path)
    ///     findLOPNode(const char *path)
    // @{
    INSTANTIATE_FOR_ALL_NODE_TYPES(INSTANTIATE_FINDNODE_FUNCTIONS)
    // @}

    /// @anchor OP_Node_castToFOONode
    ///
    /// FOO_Node *castToFOONode() const; @n
    ///     This type checks the current node against FOO_Node.
    ///     If the cast is legal, this is returned.  Otherwise, NULL.
    ///     While it likely will do the "right" thing with this == NULL,
    ///     that case is UT_ASSERTed as it is just asking for trouble.
    ///     castToOBJNode()
    ///     castToSOPNode()
    ///     castToCHOPNETNode()
    ///     castToCHOPNode()
    ///     castToROPNode()
    ///     castToSHOPNode()
    ///     castToCOPNode()
    ///     castToCOP2Node()
    ///     castToCOP2NETNode()
    ///     castToCOPNode()
    ///     castToVOPNode()
    ///     castToVOPNETNode()
    ///     castToDOPNode()
    ///     castToTOPNode()
    ///     castToTOPNETNode()
    ///     castToLOPNode()
    // @{
    INSTANTIATE_FOR_ALL_NODE_TYPES(INSTANTIATE_CASTNODE_FUNCTIONS)
    // @}

    /// Obtain the node's script which is called when it is being deleted.
    const UT_String     &getDelScript() const   { return myDelScript; }

    /// Set the node's deletion script. Returns true if the delete script was
    /// set successfully.
    bool                 setDelScript(const char *str);

    /// Accessors for this node's comment string.
    // @{
    const UT_String     &getComment() const     { return myComment; }
    bool                 setComment(const char *str);
    // @}
    
    /// Overrides the NetworkBoxItem implementations of getColor and setColor
    /// to provide support Node-specific features like using the default color.
    // @{
    UT_Color             getColor() const override;
    bool                 setColor(const UT_Color &col) override;
    // @}

    /// Accessors for this node's flag indicating if it should use its
    /// operator's default color instead of its local color.
    // @{
    bool                 getColorDefault() const;
    bool                 setColorDefault(bool usedefault);
    // @}

    /// Accessors for this node's shape
    // @{
    const UT_StringHolder &getNodeShape() const;
    void                 setNodeShape(const UT_StringHolder &shape);
    // @}
    
    /// Node position/scale is used by the UI.
    // @{
    // These are in absolute coordinates, not the UI coordinates found in
    // OPUI_Worksheet, though.
    void                 setXY(fpreal x, fpreal y) override;
    fpreal               getX() const override { return myPosX; }
    fpreal               getY() const override { return myPosY; }
    fpreal               getW() const override;
    fpreal               getH() const override;
    // @}

    void                 pickRequest(int shift);
    
    /// Set allow_rel_paths to true to accept "." or ".." as valid paths.
    static bool          isValidOpName(const UT_StringView &s,
                                       bool allow_rel_paths = false,
                                       bool ignore_node_names_env_var = false);
    static bool          isValidOpName(const char *s,
                                       bool allow_rel_paths = false,
                                       bool ignore_node_names_env_var = false)
                         {
                             return isValidOpName(UT_StringView(s),
                                                  allow_rel_paths,
                                                  ignore_node_names_env_var);
                         }
    static bool          isValidOpName(const UT_StringHolder &str,
                                       bool allow_rel_paths = false,
                                       bool ignore_node_names_env_var = false)
                         {
                             return isValidOpName(str.c_str(),
                                                  allow_rel_paths,
                                                  ignore_node_names_env_var);
                         }
    static bool          isValidOpName(const UT_String &str,
                                       bool allow_rel_paths = false,
                                       bool ignore_node_names_env_var = false)
                         {
                            return isValidOpName(str.c_str(),
                                                  allow_rel_paths,
                                                  ignore_node_names_env_var);
                         }
    static bool          isValidOpPath(const UT_StringRef &s);
    static bool          forceValidOpName(UT_String &name);

    /// Override these methods so that search-and-replace operations
    /// affect our delete script as well as our parameters.
    // @{
    int                  findString(const char *str, bool fullword,
                                    bool usewildcards) const override;
    int                  changeString(const char *from, const char *to,
                                      bool fullword) override;
    // @}

    /// Mark this node, its descendants, and all data dependents containing
    /// varname as being dirty. If changed_nodes is non-NULL, then it is
    /// updated with the list of dirtied nodes which contains varname.
    /// Returns true if at least one node was dirtied.
    bool         notifyVarChange(
                                const char *varname,
                                OP_NodeList *changed_nodes = nullptr);
    
    //  These are no-ops for nodes but will be implemented for networks:
    virtual int          getNchildren() const;
    virtual OP_Node     *getChild(const char *name, int *hint=nullptr) const;
    virtual OP_Node     *getChild(int index) const;
    void                 getPickedChildren(OP_NodeList &picked,
                                           bool include_hidden=false) const;
    void                 getAllChildren(OP_NodeList &children) const;
    virtual OP_Node     *matchChild(
                                const char *pattern,
                                OP_Node *prevmatch = nullptr,
                                const char *optype = nullptr,
                                int casesensitive = 0) const;
    virtual OP_Node     *matchChildBackwards(
                                const char *pattern,
                                OP_Node *prevmatch = nullptr,
                                const char *optype = nullptr,
                                int casesensitive = 0) const;
    virtual OP_Network  *createProxyRefNode( const char *path );

    // Returns the maximum error severity of ourself and all of our
    // children.  For efficiency, early-exits at ABORT (so embedded
    // FATAL might be shadowed by an ABORT) but in practice FATAL is
    // unused.
    OP_ERROR             getChildErrorSeverity();

    // Returns the list of nodes eligible to be considered for child
    // errors.
    virtual void         getPotentialChildErrorNodes(OP_NodeList &nodes) const;

    /// Returns a provider object that creates and loads a uni-graph from this
    /// op node. Returns null if this op node does not provide any uni-graph.
    virtual OP_UniGraphProvider *getUniGraphProvider();

    /// Returns the node from which the UniGraphProvider loads its graph.
    /// The default implementation checks for a dive target with a string of the
    /// form "graph:graphtype:nodepath". If a dive target is not found, it is
    /// assumed that this node should be the provider node. 
    virtual OP_Node *getUniGraphProviderNode();

    /// Without going to the expense of actually creating the UniGraphProvider
    /// object, return a string indicating the type of provider that will be
    /// returned if you were to call getUniGraphProvider. There is no rule
    /// here, but by convention the returned value should be the name of the
    /// C++ class that will be returned by getUniGraphProvider.
    virtual UT_StringHolder getUniGraphProviderType(bool allow_cook);

    // Returns the node with the requested unique integer identifier.
    static OP_Node      *lookupNode(int unique_id, bool include_proxy=false)
                         {
                             if( unique_id >= 0 && unique_id <= theUniqueId
                                     && theUniqueNodes[unique_id] )
                             {
                                 if( include_proxy || !theUniqueNodes[unique_id]
                                                           ->isProxyRefNode() ) 
                                     return theUniqueNodes[unique_id];
                             }
                             return nullptr;
                         }
    static int           getNumUniqueIds()
                         { return theUniqueId + 1; }
    // Fills the provided array with every node that currently exists.
    static void          getAllNodes(OP_NodeList &nodes);

    int                  getUniqueId() const
                         { return myUniqueId; }
    int64                getItemUniqueId() const override
                         { return myUniqueId; } 

    // The following function will take a standard pattern and expand
    // all the groups out of the pattern, leaving a simple pattern
    // in the result.
    bool                 expandGroupPattern(const char *pattern,
                                            UT_String &result,
                                            bool expand_to_full_paths = false);

    // The following methods take a standard pattern and return whether
    // the pattern contains the specified bundle or group.
    bool                 patternContainsBundle(const char *pattern,
                                               const OP_Bundle *bundle) const;
    bool                 patternContainsGroup(const char *pattern,
                                              const OP_Group *group) const;

    virtual int          isManager() const;
    // This differs from isManager.  Managers are the old school static
    // things which are always present in fixed directories.  Management
    // nodes are managers that are in the wrong directory.
    virtual int          isManagementNode() const;
    // This is a bit broader than management nodes.  These nodes may
    // be in the right directory, but represent an unexpected change
    // of directory type, so need to be tracked so our tree filter
    // will know about them.
    bool                 isEffectivelyAManagementNode() const;

    // Returns ture if this node contains material nodes.
    virtual bool         isMaterialManager() const;

    // This function checks if the node is a subnet. Now that we can have
    // NWN subnets (object subnets, vopnet subnets), we need to explicitly
    // specify if these types of subnets count. In some cases we want them
    // to count (such as checking for VOPNET subnets to see if we can
    // generate code, or SHOP subnets to see if we can save to a palette).
    // In other cases we want to exclude these management ops (such as
    // when deciding to show the "Create Type From" menu item or checking
    // if we can do an opwire -i command).
    virtual int          isSubNetwork(bool includemanagementops) const;
    virtual int          isNetwork() const;
    virtual int          isInSubNetwork() const;

    bool                 isProxyRefNode() const
                            { return myIsProxyRefNode; }
    void                 setProxyRefNode(bool f)
                            { myIsProxyRefNode = f; }

    // Used by SOPs to determine which node is the output of a subnetwork.
    virtual bool         isOutputNode() const;
    // Returns which output this node represents.
    virtual OP_OutputIdx  whichOutputNode() const;

    // isNetworkWithKids() will return 1 if the node is a network and the
    // operator table for the node contains children which can be added to the
    // node.
    int                  isNetworkWithKids() const;

    virtual int          isVex() const;

    // methods for managing the bundles we depend on in so that any change to
    // the bundle in which we are interested triggers bundleChange call.
    // NB: getParmBundle methods find or create a bundle ad it to the
    //     internal list of referenced bundles
    OP_Bundle *          getParmBundle(const char* parm_name, int vector_index,
                                UT_String &pattern, OP_Network *creator,
                                const char *filter);
    void                 markBundleRefsAsUnused();
    void                 cleanUnusedBundleRefs();
    void                 cleanAllBundleRefs();

    static void          getValueAsBundlePaths(fpreal t, 
                                       UT_WorkBuffer &resultbuf,
                                       PRM_Parm *parm, int index,
                                       OP_Node *srcnode
                                       );
    static void          getValueAsBundlePaths(fpreal t, 
                                       OP_NodeList &resultnodes,
                                       PRM_Parm *parm, int index,
                                       OP_Node *srcnode
                                       );

    // The bundleChanged() method is called whenever a bundle referenced by the
    // OP is changed.  The bundle is passed to the OP to let the OP know that
    // it's out of date.  The function should return 1 if the event was handled
    // properly or 0 if it failed.  The return codes are used for debugging
    // only.
    virtual bool         bundleChanged(const OP_Bundle *bundle);
    // If a bundle changes, you should call this method to touch the parameter
    // which the bundle affects.  The name is the token of the parm.
    void                 touchBundleParm(const char *name);
    void                 touchBundleParm(int parm_index);

    // Function to determine if Display and Render node ptrs are the same
    virtual int          getDandROpsEqual() { return 1; }
    // Function to update info about whether Render and Display node ptrs
    // are the same. Recurses tree and updates all kids values.
    virtual int          updateDandROpsEqual(int = 1) { return 1; }

    /// Check to see whether @c node is an ancestor of @c this node in the
    /// input hierarchy.  Optionally check extra inputs.  This method will
    /// recurse using @c getInputs() (and optional getExtraInputNodes()
    /// @note This node is considered to be an ancestor of itself
    bool                isInputAncestor(const OP_Node *parent,
                                bool check_extra=true) const;
    /// Check to see whether the @c parent node is an ancestor of @c this node
    /// in the parent/child hierarchy.  That is, this method will call
    /// getParent()/getChild() to traverse the hierarchy.
    /// @note This node is considered to be an ancestor of itself
    bool                isParentAncestor(const OP_Node *parent) const;

    /// Get the info text for this op. This non-virtual function does
    /// all the stuff common to all operator types.
    /// @warning The return value is the value of the work buffer in the
    /// OP_NodeInfoParms.  Thus, you should never do @code
    ///     str = node->getInfoText(context, OP_NodeInfoParms());
    /// @endcode
    /// Since the lifetime of the temporary may not be long enough to extract
    /// the string properly.
    const char          *getInfoText(OP_Context &context,
                                OP_NodeInfoParms &parms);
    // Get Info Text that is specific to this node type.
    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                OP_NodeInfoParms &parms);

    /// Returns node-specific data about this node.  This is a generic
    /// way to pass typed data that may be unique to node type.  It is
    /// not meant for common data.
    /// This is with respect to the last-cooked, or cached, nature of
    /// of the node so does not take a context - the caller will be expected
    /// to have pre-cooked the node, as it's state should not change as
    /// a result.
    virtual UT_OptionsHolder getNodeSpecificInfoData() const;

    enum OTLSyncMode
    {
        OTLSYNC_DELAY = 0,
        OTLSYNC_DOSYNC = 1,
    };

    /// Uses the path (eg. "/obj/geo1") to find a node in our hierarchy
    OP_Node             *findNode(const char *path, OTLSyncMode syncmode = OTLSYNC_DOSYNC) const;

    /// Same as findNode() except it will return NULL if the path is to a node
    /// that is either not a descendant of this node, or if it isn't the same
    /// type as our children.
    OP_Node             *findSubNode(const char *path) const;
    
    // These are all Implemented in OP_Network, but put here as a virtual to
    // make working / with hscript easier so that it can be called directly on
    // an op node
    virtual OP_NetworkBox *findNetworkBox(const char *name)
                               { return nullptr; }
    virtual OP_PostIt   *findPostItNote(const char *const_path)
                                { return nullptr; }
    virtual OP_Dot      *findDot(const char *const_path)
                                { return nullptr; }
    virtual OP_SubnetIndirectInput *findParentInput(const char *const_path)
                                { return nullptr; }
    virtual OP_NetworkBoxItem *findItem(const char *const_path, 
                                        OP_ItemTypeMask item_type = 
                                        OP_ITEMTYPE_ALL)
                                { return nullptr; }

    // These functions will adhere to certain conventions, such as a reference
    // to an object actually means a reference to the display or render
    // guy in that object.  This will also check this->isCookingRender
    // to determine if it should auto-use the Render or Display.
    // These will not fail if the returned node is the node itself.
    SOP_Node            *getSOPNode(const char *path, int addextra = 0,
                                    bool *got_by_flag=nullptr) const;
    // This method will use the render node of the composite network if
    // it is a comp rather than a cop2 that is pointed to...
    COP_Node            *getCOPNode(const char *path, int addextra = 0) const;
    COP2_Node           *getCOP2Node(const char *path, int addextra = 0) const;

    // And this one will use the display node, which corresponds to the
    // cook node in DOPs land.
    DOP_Node            *getDOPNode(const char *path, int addextra = 0) const;
    ROP_Node            *getROPNode(const char *path, int addextra = 0) const;
    // This method will use the audio node of the chop network
    CHOP_Node           *getCHOPNode(const char *path, int addextra = 0,
                                    bool *got_by_flag=nullptr) const;
    // This method will use the display node of the top network
    TOP_Node            *getTOPNode(const char *path, int addextra = 0) const;
    // This method will use the display node of the lop network
    LOP_Node            *getLOPNode(const char *path, int addextra = 0) const;
    OBJ_Node            *getOBJNode(const char *path, int addextra = 0) const;
    
    OP_Node             *castToOPNode() override        { return this; }
    const OP_Node       *castToOPNode() const override  { return this; }

    /// Returns the path of this node relative to its getCreator()
    virtual void         getPathWithSubnet(UT_String &str) const;
    void                 getPathWithSubnet(UT_StringHolder &str) const
    { UT_String tmp; getPathWithSubnet(tmp); str.adoptFromString(tmp); }

    /// This will try to complete the path by finding the longest suffix
    /// that will work with the given prefix.  It will only complete up
    /// to the next child.  If it finds a valid child, it will append
    /// a slash (/).
    void                 completePath(const char *prefixpath, 
                                      UT_String &completepath) const;

    virtual CH_Channel  *getTrackChannel(const char *name);

    virtual bool         findParmFromTrack(const OP_FollowChanRefsOptions& opt,
                                           const char *trackname,
                                           OP_NodeParmRefCycle &cycle,
                                           OP_Node *&node,
                                           PRM_Parm *&parm, int &vecidx);

    // Batch evaluation of named parameters.  This method requires extra lookup
    // since parameters are specified by names, but it can handle generic
    // parameter layout.
    virtual void         evaluateBatchParms(PRM_BatchList &list, fpreal now); 

    // Do global expansion on a pattern - get lists of channels or nodes
    // If expand is given, concatenated with full list of names
    // If list is given, appended with list of nodes.
    // If dependent given, addExtraInputs.
    void                 globNodes(const char *pat, UT_String *expand,
                                        UT_Array<OP_Node *> *list=nullptr,
                                        OP_GlobContext *context = nullptr,
                                        const char *prefix = " ");

    CH_Channel          *findChannel(const char *path);
    void                 globChannels(const char *, UT_String &expand,
                                        OP_GlobContext *context = nullptr,
                                        const char *prefix = " ") const;

    void                 globChannels(const char *pattern,
                                      CH_ChannelList &clist,
                                      OP_GlobContext *context = nullptr,
                                      OP_Node *dependent = nullptr);
    // If use_multi_match is false, the pattern is
    // treated as a single pattern instead of a space
    // separated list of patterns. (Only applies
    // to direct parameter names, i.e. the pattern must not be
    // a path and must not contain a slash)
    void                 globChanRefs(const char *pattern,
                                      CH_ChannelRefList &list,
                                      OP_GlobContext *context = nullptr,
                                      OP_Node *dependent = nullptr,
                                      bool use_multi_match = true);

    int                  globParms(const char *pattern, fpreal t,
                                   UT_Array<opParmData> &list,
                                   OP_GlobContext *context = nullptr,
                                   OP_Node *dependent = nullptr,
                                   int calc_value = 1);

    // this version only globs the current node
    void                 globNodeParms(const char *pattern, fpreal t,
                                       UT_Array<opParmData> &list,
                                       OP_GlobContext *context,
                                       OP_Node *dependent,
                                       int calc_value,
                                       bool animated_only);

    // this version only globs the current node
    void                 globNodeChannels(const char *pattern,
                                          CH_ChannelList &list,
                                          OP_GlobContext *context,
                                          int *parm_start = nullptr,
                                          UT_IntArray *parm_indices = nullptr,
                                          UT_IntArray *parm_sub_indices = nullptr
                                          ) const;

    // this version only globs the current node
    // If use_multi_match is false, the pattern is 
    // treated as a single pattern instead of a space
    // separated list of patterns
    void                 globNodeChanRefs(const char *pattern,
                                          CH_ChannelRefList &list,
                                          OP_GlobContext *context,
                                          int *parm_start = nullptr,
                                          UT_IntArray *parm_indices = nullptr,
                                          UT_IntArray *parm_sub_indices=nullptr,
                                          bool use_multi_match = true
                                          ) const;

    ///Same as 'globNodes', except for network boxes. This is to be implemented
    ///by OP_Network, but has been put here so it can be called directly on 
    ///OP_Node like all the other "glob" methods without a cast
    virtual void         globNetworkBoxes(const char *pat, UT_String *expand,
                                    UT_ValArray<OP_NetworkBox *> *list=nullptr,
                                    OP_GlobContext *glob_context = nullptr,
                                    const char *prefix = " ");

    virtual void         globPostIts(const char *pat, UT_String *expand,
                                    UT_ValArray<OP_PostIt *> *list=nullptr,
                                    OP_GlobContext *glob_context = nullptr,
                                    const char *prefix = " ");

    // Fetch all channels from this node on down.
    int                  getAllChannels(CH_ChannelList &list, int scoped=0);

    // If you override opChanged() in a sub-class, you must call
    // the OP_Node base method from the sub-class method
    void                 opChanged(OP_EventType reason,
                                   void *data = nullptr) override;
    
    // If you override opChanged() in a subclass, you should first call
    // opShouldHandleChange() before taking any custom action.
    virtual bool         opShouldHandleChange(OP_EventType reason);

    // This function is called whenever we have a parameter that references
    // another parameter, and that referenced parameter changes. The pi
    // value is the index of the parameter containing the reference.
    virtual void         referencedParmChanged(int pi);

    /// Mark this node as needing a full recook.
    /// If 'evensmartcache' is true, a recook will occur even if all the
    /// parameters match in this node and all its inputs (only valid for
    /// COP2_Node). 
    virtual void         forceRecook(bool evensmartcache = true);

    /// This method causes any operators that load files to recook.
    /// By default, this searches for 'file' operators by iterating through
    /// inputs. Parms of type PRM_FILE are also marked dirty. Other nodes that
    /// load files differently may wish to override this method.
    virtual void         reloadExternalFiles();

    /// Determines if this node needs to cook.
    ///
    /// The queryonly flag will not flag this as a read attempt to the
    /// caching mechanisms, and thus not update the touch time.
    virtual unsigned     needToCook(OP_Context &context, bool queryonly=false);

    /// Cook this node's data. Returns true upon success, false otherwise.
    ///
    /// Upon failure, use OP_Parameters::error() and
    /// OP_Parameters::getErrorMessages() to determine reason.
    virtual bool         cook(OP_Context &context);

    /// The cook lock is used to protect per node data structures during
    /// cooking. Subclasses should use this when calling cook(). Example:
    /// @code
    /// cookLockedExecute([&]() {
    ///     // run code
    /// });
    /// @endcode
    /// @note Include OP_NodeCookLockedExecute.h to call this.
    template <typename F>
    void                 cookLockedExecute(const F &functor);

    /// The cook lock is used to protect per node data structures during
    /// cooking. Subclasses should use lock this to protect private data.
    OP_CookLock &        getCookLock()      { return myCookLock; }

    // This normally chains to cookInputGroups.
    // Some networks, such as SOPs, use it to be able to
    // properly lock their gdp pointer around the cook.
    virtual OP_ERROR     pubCookInputGroups(OP_Context &context, int alone = 0);

    void                 bumpVersionParm()
                            {
                                dataMicroNode().bumpModVersion();
                                if (hasIndepParmListMicroNode())
                                    parmListMicroNode().bumpModVersion();
                            }
    int                  cookParmsModified() const
                            { return parmListMicroNodeConst()
                                .isModVersionOutdated(); }

    // The data class of an OP is currently used solely for networks which
    // contain heterogeneous node types (i.e. used in SHOP networks to
    // distinguish different shader types).  A data class of 0 is returned by
    // default.
    // A value of 0 is returned by default.
    virtual int          getDataClass() const;

    // The xform order for how to interpret the given channel.  Default
    // is XYZ.
    virtual void         getXformOrder(UT_XformOrder &xord,
                                       const CH_Channel *chp) const;

    // "getCookedData" should return a void * version of the results of
    // the cook. NULL if it fails with appropriate stuff in our error manager.
    virtual OP_DataType  getCookedDataType() const = 0;
    virtual void        *getCookedData(const OP_Context &);
    virtual void         deleteCookedData() = 0;
    
    virtual int          saveCookedData(std::ostream &os, OP_Context &,
                                        int binary = 0) = 0;
    virtual bool         loadCookedData(UT_IStream &is,
                                        const char *path = nullptr);
    virtual int          saveCookedData(const char *filename, OP_Context &) = 0;

    /// Get the transform from this node's space to the 'to' node's space.
    /// Returns 1 if this was possible, 0 otherwise (e.g. failure to cook).
    virtual int          getRelativeTransform(OP_Node &to, UT_Matrix4 &xform,
                                              OP_Context &context);
    virtual int          getRelativeTransform(OP_Node &to, UT_DMatrix4 &xform,
                                              OP_Context &context);
    /// overrides for OPs that can capture (right now only OBJ_Bone)
    virtual int          getRelativeCaptureTransform(OP_Node &to, 
                                              UT_Matrix4 &xform,
                                              OP_Context &context);
    virtual int          getRelativeCaptureTransform(OP_Node &to, 
                                              UT_DMatrix4 &xform,
                                              OP_Context &context);
    /// Based on a path, get the UT_CameraParms data and transform of the
    /// camera relative to some other node.
    static bool          getCameraInfoAndRelativeTransform(
                                const UT_StringRef &campath,
                                const UT_StringRef &xform_relative_to_path,
                                const OP_Node *paths_relative_to_node,
                                bool get_inverse_xform,
                                const OP_Context &context,
                                DEP_MicroNode *depnode,
                                UT_CameraParms &camparms,
                                UT_DMatrix4 &xform,
                                UT_StringHolder &error);
    virtual bool         getCameraInfo(const UT_StringRef &camid,
                                const OP_Context &context,
                                DEP_MicroNode *depnode,
                                UT_StringHolder &foundcamid,
                                UT_CameraParms &camparms);
    virtual bool         getWorldTransformFromData(const UT_StringRef &id,
                                const OP_Context &context,
                                bool get_inverse_xform,
                                DEP_MicroNode *depnode,
                                UT_DMatrix4 &xform);

    enum TransformMode
    {
        TRANSFORM_WORLD,
        TRANSFORM_IWORLD,
        TRANSFORM_PRE,
        TRANSFORM_PARENT,
        TRANSFORM_PARM,
        TRANSFORM_PRECONSTRAINT,
        TRANSFORM_PARENTBONE,
        TRANSFORM_RAWPARM,
        TRANSFORM_PREPARM,
        TRANSFORM_PRERAWPARM,
    };

    // these next 3 are the minimal overrides for subclasses that have
    // transforms (see OBJ_Node)
    virtual bool         getWorldTransform(UT_Matrix4D &xform, OP_Context &);
    virtual bool         getIWorldTransform(UT_Matrix4D &xform, OP_Context &);
    virtual bool         getTransform( TransformMode mode, UT_Matrix4D &xform, OP_Context &);

    // single precision versions of the above
    bool                 getWorldTransform(UT_Matrix4F &xform, OP_Context &ctx)
                         {
                             UT_Matrix4D m;
                             bool ok = getWorldTransform(m, ctx);
                             xform = m;
                             return ok;
                         }
    bool                 getIWorldTransform(UT_Matrix4F &xform, OP_Context &ctx)
                         {
                             UT_Matrix4D m;
                             bool ok = getIWorldTransform(m, ctx);
                             xform = m;
                             return ok;
                         }
    bool                 getTransform( TransformMode mode, UT_Matrix4F &xform, OP_Context &ctx)
                         {
                             UT_Matrix4D m;
                             bool ok = getTransform(mode, m, ctx);
                             xform = m;
                             return ok;
                         }

    /// Registers an error for cooking the given node's transform. If label is
    /// supplied, then it will be used as a label of the transform error.
    void                 addTransformError(const OP_Node &node,
                                           const char *label = nullptr) const;

    // Compute the bounding box for the operator (if applicable).  If the box
    // could be computed, return true, else return false.
    virtual bool        getBoundingBox(UT_BoundingBox &box, OP_Context &);

    // This is used by VOPNETs to determine which table needs to be
    // refreshed when they change.
    virtual const char  *getInternalOpTable() const 
                         { return INVALID_TABLE_NAME; }
    virtual OP_Operator *getInternalOperator() const
                         { return nullptr; }

    virtual const char  *inputLabel(OP_InputIdx idx) const;
    virtual const char  *outputLabel(OP_OutputIdx idx) const;
    UT_StringHolder      spareOutputLabel(OP_OutputIdx idx) const;
    
    // Here's a useful method which will return the string "Source %d", where
    // %d is the idx passed. Lets us check if the input label is using the
    // default or not.
    const char          *inputLabelNum(OP_InputIdx idx) const;
    const char          *outputLabelNum(OP_OutputIdx idx) const;

    // returns a label that is applied to the drawn connector. NULL may be
    // returned as 'no label'.
    virtual const char  *inputConnectorLabel(OP_InputIdx idx);
    
    // if true, the connector to the input will be dashed rather than solid.
    virtual int          isRefInput(OP_InputIdx idx) const;

    // returns the index of the auxilary input, if any (currently only used
    // for the mask inputs in COPs).
    virtual int          getAuxInput() const;
    virtual void         getAuxInputName(OP_ConnectorId& name_out);
    
    //  The lock method is used to lock the OP.
    //  Returns the previous state of the lock flag.
    //
    // Note that to mimic the behaviour of the lock button, you MUST
    // call setModelLock, not setLockState()/setHardLock()/setSoftLock(), or
    // your next unlock won't have a cached data.
    using OP_LockTypes = OP_NodeFlags::OP_LockTypes;
    OP_LockTypes         setLockState(OP_LockTypes state, bool saveundo = true);
    OP_LockTypes         getLockState() const { return flags().getLockState(); }

    // Returns true if either hard or soft locked
    bool                 getLock() const { return flags().isLocked(); }

    bool                 getSoftLock() const {return flags().getSoftLocked();}
    void                 setSoftLock(bool on_off)
                         {
                             setLockState(on_off ? OP_NodeFlags::OP_SOFT_LOCKED
                                                 : OP_NodeFlags::OP_UNLOCKED);
                         }

    bool                 getHardLock() const {return flags().getHardLocked();}
    void                 setHardLock(bool on_off)
                         {
                             setLockState(on_off ? OP_NodeFlags::OP_HARD_LOCKED
                                                 : OP_NodeFlags::OP_UNLOCKED);
                         }

    //  The Model lock is similar to the normal lock but will also cause
    //  the node data to be saved.
    virtual OP_LockTypes setModelLock(OP_LockTypes state, 
                                      void *modeler = nullptr,
                                      bool allow_softlock_promotion = false,
                                      UT_Undo *undo = nullptr);

    // getNetworkLock() checks to see if the OP is effectively locked by
    // the network, i.e., each of the OPs output branches connect to a locked
    // OP down the network. Returns > 0 if locked, <= 0 if unlocked.
    // When relaxedlockcheck is set, subnet branches that are not displayed
    // are ignored.
    int                  getNetworkLock(
                                bool relaxedlockcheck = false,
                                const OP_Node *input_node = nullptr) const;

    // The unload flag triggers whether we keep the ops data around
    // after a cook or discard it as soon as its not needed.  Its currently
    // only implemented in CHOPs.
    bool                 setUnload(bool on_off);
    bool                 getUnload() const;

    // Returns whether this node has data loaded into it.
    virtual bool         isLoaded() const { return true; }

    // This will explicitly delete all data associated with the OP
    // false is returned if no data was deleted (ie, OP is in use, etc)
    // Only works with SOPs now.
    virtual bool         unloadData();

    // Take control for flags
    void                 takeActivateFlag(uchar flag, bool enable=true,
                                          bool send_flag_event=true);
    void                 takeDeactivateFlag(uchar flag)
                         { takeActivateFlag(flag, false); }
    bool                 takeIsActiveFlag(uchar flag) const;
    void                 setHasTakeData(bool onoff);

    bool                 canAccessFlag(unsigned mask, uchar flag) const;

    // The template flag indicates that the node date should be displayed
    // The display & render flags indicate that the node is turned on
    // for display purposes or for rendering purposes, which may take
    // on different meanings per node type.
    // Setting save data only has meaning for some node types.
    bool                 setPicked(bool on_off, 
                                   bool propagate_parent_event = true) override;

    /// The edit flag is used whenever something is picked
    /// from the viewport. This causes the pane paths to
    /// be changed to the first writable parent of the
    /// node being picked.
    bool                 setEditPicked(bool on_off, 
                                   bool propagate_parent_event = true);

    // The Autoscope flag on OP_Node is used to temporary turn-off the Auto-Add to Channel List
    // behavior when selecting nodes.
    // This is used when setting selected nodes from selected channels in the channel list
    void                 setAutoscope(bool on_off) { myAutoscope = on_off; }
    bool                 isAutoscope() { return myAutoscope; }

    bool                 setCurrent(bool on_off);
    bool                 setExpose(bool on_off);
    bool                 setBypass(bool on_off);
    bool                 setTemplate(bool on_off);
    bool                 setFootprint(bool on_off);
    bool                 setXray(bool on_off);
    bool                 setDisplay(bool on_off);
    bool                 setRender(bool on_off);
    bool                 setHighlight(bool on_off);
    bool                 setModified(bool on_off);
    bool                 setSaveBypass(bool on_off);
    bool                 setSaveData(bool on_off);
    // these are for subclasses to implement, they do nothing by default
    virtual bool         setPickable(bool on_off)
                         { return false; }
    virtual bool         setAudio(bool on_off)
                         { return false; }
    virtual bool         setExport(bool on_off)
                         { return false; }
    virtual bool         setDebug(bool on_off)
                         { return false; }
    virtual bool         setDisplayOrigin(bool on_off_unchanged)
                         { return false; }

    /// The user has set the template flag. If we are turning on the template
    /// flag, we do the same as setTemplate(). If we are turning it *off*,
    /// we also turn off the selectable template (footprint) flag.
    void userSetTemplate(bool onoff);

    /// The user has set the selectable template flag. If we are making a node
    /// into a selectable template, we turn on the template flag as well.
    /// If we are turning off selectable template, we leave template alone.
    void userSetSelectableTemplate(bool onoff);

    // Here are the generalised versions, they add a bit of overhead to
    // the code because of the big switch statement.
    virtual void         setFlag(char tag, int8 val);
    virtual int8         getFlag(char tag) const;

    bool                 getPicked() const override
                         { return flags().getPicked(); }
    virtual bool         getEditPicked() const
                         { return flags().getEditPicked(); }
    bool                 getCurrent() const;
    bool                 getDisplay() const   {return flags().getDisplay(); }
    /// Checks the parent's export node ptr, controlled by display & export
    bool                 getDisplay3D();
    bool                 getRender() const    {return flags().getRender(); }
    bool                 getHighlight() const {return flags().getHighlight();}
    bool                 getBypass() const    {return flags().getBypass(); }
    bool                 getTemplate() const  {return flags().getTemplate(); }
    bool                 getFootprint() const {return flags().getFootprint(); }
    bool                 getXray() const      {return flags().getXray(); }
    bool                 getExpose() const    {return flags().getExpose(); }
    bool                 getModified() const  {return flags().getModified(); }
    bool                 getSaveBypass() const{return flags().getSaveBypass(); }
    bool                 getSaveData() const  {return flags().getSaveData(); }
    bool                 getHasTakeData() const override
                         { return flags().getHasTakeData(); }
    virtual bool         getPickable()
                         { return false; }
    virtual bool         getAudio() const
                         { return false; }
    virtual bool         getExport() const
                         { return false; }
    virtual bool         getDebug() const
                         { return false; }
    virtual bool         getDisplayOrigin() const
                         { return false; }
    bool                 getItemExpose() const override
                         { return getExpose(); }
    void                 setItemExpose(bool expose) override
                         { setExpose(expose); }
    virtual bool         getUseBypassLook(const OP_EditorContext &ctx) const;

    bool                 getDisplayDescriptiveName() const
                         {return flags().getDisplayDescriptiveName();}
    bool                 setDisplayDescriptiveName(bool state);
    bool                 getDisplayComment() const
                         {return flags().getDisplayComment();}
    bool                 setDisplayComment(bool state);
    int8                 getOutputForView() const
                         { return flags().getOutputForView(); }
    int8                 setOutputForView(int8 output);

    OP_Node             *getPickableSelfOrParent();

    // The compress flag indicates that the OP connector should be displayed
    // in a compressed UI. In ICE this means don't display the mini raster
    // image.
    bool                 setCompress(bool on_off);
    bool                 getCompress() const;

    // This method sets this node as the current and picked node and correctly
    // adjusts the picked states of the other sibling nodes.
    void                 setCurrentAndPicked();          

    // setVisible() simply calls setDisplay() at this level but subclasses
    // override this to perform smarter behaviour. Objects for example will
    // try to set the display flag on parent subnets and change visible object
    // parameters as necessary.
    // Returns true if it was successful, false if there were not sufficient
    // permissions.
    virtual bool         setVisible(bool onoff);
    virtual bool         getVisible() const;

    const OP_NodeFlags  &flags() const
                         { return myFlags; }
    OP_NodeFlags        &flags()
                         { return myFlags; }

    virtual void         getSaveFlagsString(UT_String &cmd,
                                            const char *flags,
                                            bool save_to_hip) const;
    virtual void         getPreParmSaveFlagsString( UT_String &cmd ) const;
    virtual void         getPostParmSaveFlagsString( UT_String &cmd ) const;

    /// Returns true if given notifcation callback has been added via
    /// addOpInterest().
    int                  hasOpInterest(void *data, OP_EventMethod m) const
                             { return myEventValue.hasOpInterest(data, m); }

    /// Add a notification callback for changes to the node. See the @c
    /// OP_EventType enum in OP_Value.h for the list of events and data sent.
    void                 addOpInterest(void *data, OP_EventMethod m)
                             { myEventValue.addOpInterest(data, m); }

    /// Remove notification callback added via addOpInterest()
    void                 removeOpInterest(void *data, OP_EventMethod m)
                             { myEventValue.removeOpInterest(data, m); }

    int                  isBeingDeleted() const
                             { return myBeingDeleted; }
    void                 setNodeBeingDeleted(int beingdeleted);

    /// Sets the flag that prevents consolidation of variable inputs.
    /// Returns previous value of the flag;
    bool                 setInhibitInputConsolidation(bool value);

    /// Move the upper-left most node in 'ops' to x-coordinate 'x' and to have
    /// its TOP border at y-coordinate 'y', and move all other nodes in 'ops'
    /// by the same amount. All netboxes in 'netboxes' will also be moved that
    /// amount. If a netbox's top border is higher than any node's top border,
    /// everything will be moved down accordingly. Note that the repositioning
    /// calculation does not include the nodes contained in the network boxes
    /// in 'netboxes'.
    static void          repositionOpsMaxY(OP_NetworkBoxItemList &items, 
                                fpreal x, fpreal y);

    /// Minimum inputs that must be connected to a node for it to cook.
    virtual unsigned     minInputs() const;

    /// Maximum inputs that can be connected to a node.
    virtual unsigned     maxInputs() const;

    /// Number of input connectors that should be visible on a node. This is
    /// only used by VOPs and DOPs. All other OPs return maxInputs() here.
    virtual unsigned     getNumVisibleInputs() const;

    /// Returns the number of ordered inputs on a node that remain separate
    /// even on nodes that have a variable number of inputs. These separate
    /// inputs always start at the beginning (variable input connectors are
    /// always last).
    ///
    /// The default implementation returns getOperator()->numOrderedInputs() so
    /// prefer calling OP_Operator::setNumOrderedInputs() instead of overriding
    /// this.
    virtual unsigned     orderedInputs() const;

    /// Maximum number of output connectors on a node. Only VOPs and DOPs ever
    /// return a value other than 1 here.
    virtual unsigned     maxOutputs() const;

    /// Maximum number of spare output connectors on a node. Only COPs returns
    /// a value other than 0 here for the cable of all outputs.
    virtual exint        maxSpareOutputs() const;

    /// Number of output connections that should be visible on a node tile.
    /// Only used by VOPs and DOPs.
    virtual unsigned     getNumVisibleOutputs() const;

    /// Returns true if the operator type says we have unordered inputs.
    bool                 hasUnorderedInputs() const;

    /// Returns the index of the last connected input incremented by one. 
    /// If there are no inputs connected, returns 0. This means that the
    /// function behaves as if the lasted connected input was always the
    /// last entry in the inputs array. Note that other array entries up
    /// to the index of the one returned may contain null entries, so this
    /// is not necessarily the same as the number of connections. Also note
    /// that there may be more null entries at indices beyond the returned
    /// one.
    virtual unsigned     nInputs() const;

    /// The number of nodes actually connected to this node. This function
    /// goes through the myInputs array and counts non-null entries.
    /// @param check_subnet_inside If true, the (vopnet) subnet node will check
    ///     if a corresponding connector is connected inside, and count it in
    ///     if so.
    unsigned             nConnectedInputs(bool check_subnet_inside=true) const;

    unsigned             getActiveInputIndex() const
                         { return myActiveInputIndex; }
    void                 setActiveInputIndex(unsigned idx);

    /// Returns the node connected to a particular input (may be null).
    OP_Node             *getInput(OP_InputIdx idx, bool mark_used=false) const;

    /// Returns the connected input, may be null.  If it is a SOP & subnet,
    /// and not primary output, will chase to the child output node.
    /// This may induce flag dependencies, the provided micronode
    /// can accumulate them.
    OP_Node             *getInputFollowingOutputs(OP_InputIdx input,
                                DEP_MicroNode *depnode=nullptr) const;

    /// Returns the first non-null input beyond the specified starting index.
    /// This function can be used to easily loop through all connected inputs.
    OP_InputIdx          getConnectedInputIndex(OP_InputIdx start_at = -1) const;

    /// Gets the index of the Nth non-null connection to this node.
    OP_InputIdx          getNthConnectedInput(OP_InputIdx n) const;

    /// Override this to specify the inputs which are needed for cooking this
    /// node which can be executed in parallel.
    virtual void         getParallelInputs(OP_Context &context,
                                           OP_NodeList &nodes) const;

    /// Forcibly clear an input. Used when deleting the input.
    void                 forceClearInput(OP_InputIdx idx);

    /// Sets a given input to connect to an output of a particular node.
    virtual OP_ERROR     setInput(OP_InputIdx idx, OP_Node *op,
                                  OP_OutputIdx output_idx = 0);

    /// Connects an input to an indirect input of our parent subnet.
    virtual OP_ERROR     setIndirectInput(OP_InputIdx idx,
                                          OP_IndirectInput *input);

    /// Connects an input to particular node by name in the network.
    virtual OP_ERROR     setInputReference(
                                OP_InputIdx idx,
                                const char *label,
                                int keeppos,
                                OP_OutputIdx output_idx = 0);

    /// Returns the index of the first connection from node "who" to this node,
    /// or -1 if "who" is not an input.
    OP_InputIdx     whichInputIs(const OP_Node *who) const;

    /// Returns the index of the first connection of an indirect input.
    OP_InputIdx     whichInputIs(const OP_IndirectInput *who) const;

    /// Returns the index of the Nth connection of an indirect input.
    OP_InputIdx     whichInputIs(const OP_IndirectInput *whoi,
                                             int cnt) const;

    /// Returns an index of the output which goes out from this node to
    /// the target_node, and connects to the target_node at the specified
    /// input index. Returns -1 if the connection doesn't exist.
    /// Use `whichOutputIsFollowingIndirect` for a more robust solution.
    OP_OutputIdx    whichOutputIs(const OP_Node* target_node,
                                  OP_InputIdx input_on_target_node) const
                    {
                        OP_OutputIdx output_idx = whichOutputIsIncludeSpare(
                            target_node, input_on_target_node).value_or(-1);
                        if (output_idx < 0)
                            return -1;
                        return output_idx;
                    }
    /// Returns an index of the output which goes out from this node to
    /// the target_node, and connects to the target_node at the specified
    /// input index. This version handles spare outputs and uses negative
    /// indices to refer to spare outputs. Returns `UT_NULLOPT` if the
    /// connection doesn't exist.
    /// Use `whichOutputIsFollowingIndirectIncludeSpare` for a more robust
    /// solution.
    UT_Optional<OP_OutputIdx>   whichOutputIsIncludeSpare(
                                        const OP_Node* target_node,
                                        OP_InputIdx input_on_target_node) const;

    /// Computes the output, but handles the case that target_node's input
    /// is an indirect input.  This will then follow the indirect chain
    /// up until a node's real input. Returns -1 on failure.
    OP_OutputIdx        whichOutputIsFollowingIndirect(
                                const OP_Node* target_node,
                                OP_InputIdx input_on_target_node) const
                        {
                            return whichOutputIsFollowingIndirectIncludeSpare(
                                target_node, input_on_target_node).value_or(-1);
                        }
    /// Computes the output, but handles the case that target_node's input
    /// is an indirect input.  This will then follow the indirect chain
    /// up until a node's real input. This version handles spare outputs and
    /// uses negative indices to refer to spare outputs. Returns `UT_NULLOPT`
    /// on failure.
    UT_Optional<OP_OutputIdx>   whichOutputIsFollowingIndirectIncludeSpare(
                                        const OP_Node* target_node,
                                        OP_InputIdx input_on_target_node) const;

    /// Returns the index of an input into which source_node is connected
    /// on this node. counter determines the Nth such connection from 
    /// source node to this particular node.
    OP_InputIdx     whichInputIs(const OP_Node* source_node,
                                             int counter) const;

    // Compacts the inputs array, removing all null entries.
    void                 consolidateInputs();
    virtual void         clearUnreferencedInputs();
    virtual bool         allowConsolidatingInput(OP_InputIdx idx);

    // Returns a pointer to an input given an input index. If the input index
    // is less than nInputs() it will always return a valid input. If the grow
    // flag is set to true, then any inputs between nInputs and the index
    // given will be created, up to maxInputs().
    virtual OP_Input    *getInputReference(OP_InputIdx idx, bool grow);

    // As before, except missing inputs are not created. NULL is returned for
    // non-existent inputs.
    virtual OP_Input    *getInputReferenceConst(OP_InputIdx idx) const;

    virtual int          doDeleteRewire() const { return 1; }
    // This moves the input at srcidx to dstidx.  forcesubnet will enable
    // modification of subnet inputs and outputs even when inside a
    // blockModify().
    virtual void         moveInput(OP_InputIdx srcidx, OP_InputIdx dstidx,
                                   bool forcesubnet = false);
    OP_ERROR             insertInput(OP_InputIdx idx, OP_Node *op,
                                     OP_OutputIdx output_idx);
    OP_ERROR             insertIndirectInput(OP_InputIdx idx,
                                             OP_IndirectInput *input);

    // For nodes with editable input names, this function is used to set the
    // default name for a new input.
    virtual UT_Options   getInputDataDefault(OP_InputIdx idx) const
                         { return UT_Options(); }

    /// The following methods are used for nodes that allow reordering inputs.
    /// Returns the number of inputs that editor should display. 
    virtual int          getInputEditorInputs();
    /// Returns true if editor should display parameter option menu button.
    virtual bool         allowInputEditorInputParm();
    /// Returns true if editor should display delete input button.
    virtual bool         allowInputEditorInputDelete();
    /// Gets the input label to display in editor and returns true. Otherwise, 
    /// returns false if editor should use backward-compatible labeling scheme.
    virtual bool         getInputEditorInputLabel(UT_StringHolder &label,
                                                  OP_InputIdx idx);

    virtual const OP_DataMicroNode &
                         dataMicroNodeConst() const
                            { return myDataMicroNode; }
    OP_DataMicroNode &   dataMicroNode()
                         {
                             return const_cast<OP_DataMicroNode &>(
                                        dataMicroNodeConst());
                         }

    /// Subclasses should override this to customize the micro-node dependency
    /// of their parameter list. The default is just dataMicroNode().
    virtual const OP_DataMicroNode &
                         parmListMicroNodeConst() const 
                            { return dataMicroNodeConst(); }
    OP_DataMicroNode &   parmListMicroNode()
                         {
                             return const_cast<OP_DataMicroNode &>(
                                        parmListMicroNodeConst());
                         }

    bool                 hasIndepParmListMicroNode() const
                         {
                             return (&parmListMicroNodeConst()
                                        != &dataMicroNodeConst());
                         }

    /// This micronode is guaranteed to trigger when any flag changes.
    DEP_MicroNode &      flagMicroNode()
                            { return myFlagMicroNode; }
    /// This micronode is guaranteed to trigger when the specified flag changes;
    /// it may also trigger on unrelated flag changes.
    DEP_MicroNode &      flagMicroNode(char flag)
                            { return myIndividualFlagMicroNodes[flag]; }
    DEP_MicroNode &      parmMicroNode(int parm_idx, int vi)
                            { return getParmList()->parmMicroNode(
                                                            parm_idx, vi); }

    /// Accessors to event micro nodes.
    const DEP_MicroNode &eventMicroNodeConst(OP_EventType e) const
                         {
                             return SYSconst_cast(this)->eventMicroNode(e);
                         }
    DEP_MicroNode &      eventMicroNode(OP_EventType e);

    bool                 hasEventMicroNode(OP_EventType e) const
                         {
                             UT_ASSERT_P(e >= 0 && e < OP_EVENT_TYPE_COUNT);
                             if (!myEventMicroNodes)
                                 return false;
                             return bool(myEventMicroNodes[e]);
                         }

    /// Subclasses should override this provide any additional micronodes that
    /// they own. This list is used in places such as node deletion so that
    /// dependents are dirtied.
    virtual void         getOwnedMicroNodes(
                            DEP_MicroNodeList &micronodes);

    /// Explicitly propagate dirtiness for a particular micronode owned by
    /// some node.
    void                 propagateDirtyMicroNode(
                            DEP_MicroNode &micronode,
                            OP_EventType reason,
                            void *data,
                            bool send_root_event);

    /// Declares that this node's data depends on the @c op for the given
    /// reason (OP_INTEREST_DATA, OP_INTEREST_FLAG).
    /// @note There are no other acceptable values for type.
    virtual void         addExtraInput(OP_Node *op, OP_InterestType type);

    /// Declares that this node's data depends on @c op channel. If vec_i is
    /// -1, then this node depends on all the channels of the parameter.
    void                 addExtraInput(OP_Node &op, int parm_i, int vec_i);

    /// Generic version of addExtraInput() which adds a dependency from an
    /// source ref to this node's data micronode.
    void                 addExtraInput(const OP_InterestRef &source_ref);

    /// Generic version of addExtraInput() which adds a dependency from an
    /// source micronode to this node's data micronode.
    void                 addExtraInput(DEP_MicroNode &source_micronode);

    /// Marks this to be dependent on all the parameters inside of the
    /// multiparm.
    void                 addMultiparmInterests(OP_Node *srcnode, PRM_Parm &parm);


    static DEP_MicroNode *getEvalChannelMicroNode(int thread);

    /// Declare from an expression callback that the current evaluation channel
    /// is dependent on the given source.
    // @{
    static void          addExtraInputToEvalChannel(
                            int thread,
                            OP_Node &op, OP_InterestType type)
                        {
                            addExtraInputToEvalChannel(
                                    thread,
                                    OP_InterestRef(op, type));
                        }
    static void          addExtraInputToEvalChannel(
                            int thread,
                            OP_Node &op, int parm_i, int vec_i)
                        {
                            addExtraInputToEvalChannel(
                                    thread,
                                    OP_InterestRef(op,parm_i,vec_i));
                        }
    static void          addExtraInputToEvalChannel(
                            int thread,
                            const OP_InterestRef &source_ref)
                        {
                            DEP_MicroNode *
                                target = getEvalChannelMicroNode(thread);
                            if (target)
                                OP_Node::addExtraInput(*target, source_ref);
                        }
    static void          addExtraInputToEvalChannel(
                            int thread,
                            DEP_MicroNode &src_micronode)
                        {
                            DEP_MicroNode *
                                target = getEvalChannelMicroNode(thread);
                            if (target)
                                target->addExplicitInput(src_micronode);
                        }
    // @}

    /// Generic versions of addExtraInput() used by the others. In particular,
    /// the static version of addExtraInput() allows you to define channel to
    /// channel dependencies.
    // @{
    static void          addExtraInput(
                            const OP_InterestRef &target_ref,
                            const OP_InterestRef &source_ref);
    static void          addExtraInput(
                            const OP_InterestRef &target_ref,
                            DEP_MicroNode &source_micronode);
    static void          addExtraInput(
                            DEP_MicroNode &target_micronode,
                            const OP_InterestRef &source_ref);
    // @}

    static void          addMultiparmInterests(const OP_InterestRef &target_ref,
                                               OP_Node *srcnode,
                                               PRM_Parm &parm);
    static void          addMultiparmInterests(DEP_MicroNode &target,
                                               OP_Node *srcnode,
                                               PRM_Parm &parm);

    void                 getExtraInputNodes(
                            OP_NodeList &extras,
                            bool remove_duplicates = true,
                            bool data_interest = true,
                            bool parm_interest = true,
                            bool flag_interest = true,
                            bool include_parmlist = true,
                            bool follow_simulation_inputs = false) const;
    void                 getExtraOutputNodes(
                            OP_NodeList &extras,
                            bool remove_duplicates = true,
                            bool data_interest = true,
                            bool parm_interest = true,
                            bool flag_interest = true) const;

    int                  getNumExtraInputs() const;

    void                 dumpExtraInputs(
                            std::ostream &os,
                            bool as_DOT,
                            int indent_level = 0) const;

    /// Appends to the provided context the expected parameters
    /// from the containing network.
    /// Adds dependencies to those parameters to the provided depnode.
    virtual bool         buildDefaultCopContext(OP_Context &context,
                                DEP_MicroNode *depnode=nullptr);

    // addExprOpDependency is a helper function for building dependencies for
    // the expression library callback functions.
    static void          addExprOpDependency(const char *arg_str,
                                             const PRM_RefId &ref_id,
                                             OP_InterestType interest_type);
    static void          addExprOpDependency1From2(const char *arg_str1,
                                             const char *arg_str2,
                                             const PRM_RefId &ref_id,
                                             OP_InterestType interest_type);
    static void          addExprOpParmDependency(const char *arg_str,
                                                 const PRM_RefId &ref_id,
                                                 OP_InterestType interest_type);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpRef(const char *arg_str,
                                         char *&new_arg,
                                         const char *new_fullpath,
                                         const char *old_fullpath,
                                         const char *old_cwd);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpRef1From2(const char *arg_str1,
                                         const char *arg_str2,
                                         char *&new_arg1,
                                         char *&new_arg2,
                                         const char *new_fullpath,
                                         const char *old_fullpath,
                                         const char *old_cwd);
    // NB: is reponsible for freeing new_arg!
    static void          changeExprOpParmRef(const char *arg_str,
                                             char *&new_arg,
                                             const char *new_fullpath,
                                             const char *old_fullpath,
                                             const char *old_cwd,
                                             const char *chan_name,
                                             const char *old_chan_name);

    void                 addGenericOpNameReference( const UT_String &oppath );
    void                 addGenericOpNameReference( const PRM_RefId &ref_id,
                                                    OP_Node *node );
    void                 addGenericOpInputReference( const PRM_RefId &ref_id,
                                                    OP_Node *node );

    static void          moveAndUpdateDependencies( 
                            const OP_NodeList &src_nodes,
                            const OP_NodeList &dest_nodes );

    static void          updateChannelPtrs( CH_CollectionList &parents );

    bool                 getParmBaseNodePath(
                            UT_String &path,
                            int parm_index,
                            int thread) const;

    // Make this function public so it can be called by OPUI_EditSubnet
    // and possibly others. Note that it is defined in PRM_ParmOwner so
    // that it can be called from the PRM library.
    void                 rebuildParmDependency(int parm_index) override;

    // Clear op name dependencies
    void                 clearParmDependency(int parm_index) override;
    // decrementOpReference() should only be called by clearParmDependency()
    void                 decrementOpReference(int node_id);

    virtual void         dumpDependencies(std::ostream &os);
    void                 dumpOpDependents(OP_Node *ref, int brief, 
                                          std::ostream &os);
    const OP_DependencyList
                        &getOpDependents() const { return myOpDependents; }


    // INTERNAL: Do NOT use outside of OP_Node! Will be made private.
    int                  countReferences(int op_id);

    // Get the existing node *NAME* references (eg. expr references)
    // NB: This function assumes that refs is sorted without duplicate entries!
    void                 getExistingOpReferences(OP_NodeList &refs,
                                                 bool recurse) const;

    // Get the as complete list of data references as possible for this node.
    // This combines getExistingOpReferences() which exist without cooking, and
    // getExtraInputNodes() which are the current references since the last
    // cook of its refernces.
    void                 getFullOpReferences(OP_NodeList &refs,
                                             bool include_descendants) const;

    // Get the existing node *NAME* dependents (eg. expr references)
    // NB: This function assumes that deps is sorted without duplicate entries!
    void                 getExistingOpDependents(OP_NodeList &deps,
                                             bool include_descendants) const;

    // Get the as complete list of data dependents as possible for this node.
    // This combines getExistingOpDependents() which exist without cooking, and
    // getExtraOutputNodes() which are the current dependents since the last
    // cook.
    void                 getFullOpDependents(OP_NodeList &deps,
                                             bool include_descendants) const;

    // Gets a list of parms that reference one of our channels/parms.
    void                 getParmsThatReference(const char *channame,
                                               UT_ValArray<PRM_Parm *> &parms,
                                               UT_IntArray &parmsubidxs);

    virtual void         inputConnectChanged(OP_InputIdx which);

    // Returns the number of output entries in the output array. Note 
    // that this done regardless of which entries have any outputs connected.
    unsigned             nOutputEntries() const;
    // Get access to the raw network items connected to our outputs.
    // These functions can focus on a single output connector, or treat
    // all outputs as a flat array by passing output_idx = -1.
    int                  nOutputItems(OP_OutputIdx output_idx = -1) const
                        {
                            static constexpr bool include_spare = false;
                            if (output_idx < 0)
                                return static_cast<int>(
                                    nOutputItemsIncludeSpare(
                                        UT_NULLOPT, include_spare));
                            else
                                return static_cast<int>(
                                    nOutputItemsIncludeSpare(
                                        output_idx, include_spare));
                        }
    OP_NetworkBoxItem   *getOutputItem(int idx,
                                       OP_OutputIdx output_idx = -1) const
                        {
                            static constexpr bool include_spare = false;
                            if (output_idx < 0)
                                return getOutputItemIncludeSpare(
                                    idx, UT_NULLOPT, include_spare);
                            else
                                return getOutputItemIncludeSpare(
                                    idx, output_idx, include_spare);
                        }
    /// Get access to the raw network items connected to our outputs.
    /// These functions can focus on a single output connector, or treat
    /// all outputs as a flat array by passing output_idx = UT_NULLOPT.
    /// These updated versions handle spare outputs, which use negative indices.
    /// @{
    exint               nOutputItemsIncludeSpare(
                                UT_Optional<OP_OutputIdx> output_idx =
                                    UT_NULLOPT,
                                bool include_spare = true) const;
    OP_NetworkBoxItem   *getOutputItemIncludeSpare(
                                int idx,
                                UT_Optional<OP_OutputIdx> output_idx =
                                    UT_NULLOPT,
                                bool include_spare = true) const;
    /// @}
    // Quick check if this node has any node outputs.
    bool                 hasAnyOutputNodes(
                                bool through_dots = true,
                                OP_OutputIdx output_idx = -1
                                ) const;
    /// Fills a node list with all outputs from this node. This function can
    /// search through dots, and dive into subnets. It can also run on a
    /// single output connector or all of them.
    /// @{
    void                 getOutputNodes(
                                UT_Array<OP_Node*> &outputs,
                                bool into_subnets = false,
                                bool through_dots = true,
                                OP_OutputIdx output_idx = -1) const
                        {
                            constexpr bool include_spare = false;
                            if (output_idx < 0)
                                return getOutputNodesIncludeSpare(
                                    outputs, into_subnets, through_dots,
                                    UT_NULLOPT, include_spare);
                            else
                                return getOutputNodesIncludeSpare(
                                    outputs, into_subnets, through_dots,
                                    output_idx, include_spare);
                        }
    /// This version handles spare outputs and uses negative indices to refer
    /// to spare outputs.
    void                 getOutputNodesIncludeSpare(
                                UT_Array<OP_Node*> &outputs,
                                bool into_subnets = false,
                                bool through_dots = true,
                                UT_Optional<OP_OutputIdx>
                                    output_idx = UT_NULLOPT,
                                bool include_spare = true) const;
    /// @}
    // Quick function to return the first output node, searching depth first
    // through dots if requested.
    OP_Node             *getFirstOutputNode(
                                bool through_dots = true,
                                OP_OutputIdx output_idx = -1
                                ) const;

    // obtains an output node that leads to a target node (e.g., during network
    // traversal). Null if target is not a descendant. 
    OP_Node             *getOutputTowardsNode(const OP_Node *target);

    /// Fill in 'tree' with details that are common to all node types. Then call
    /// fillInfoTreeNodeSpecific() to get specific details about this specific
    /// node (be it a SOP, CHOP, etc)
    void                 fillInfoTree(UT_InfoTree &tree,
                                const OP_NodeInfoTreeParms &parms);

    /// Triggered by 'fillInfoTree()', this virtual function adds all node-
    /// specific info to 'tree'. All child classes must create their own 
    /// branches under 'tree' to place their info
    virtual void         fillInfoTreeNodeSpecific(UT_InfoTree &tree,
                                const OP_NodeInfoTreeParms &parms);

    /// Optionally called on parent from fillInfoTreeNodeSpecific() to provide
    /// some information about node that only parent network can provide.
    /// @return True if parent added info specific to that child.
    virtual bool         fillInfoTreeChildSpecific(UT_InfoTree &tree,
                                const OP_NodeInfoTreeParms &parms,
                                OP_Node *child);

    //  These methods get input data for the OP.  If they return an error code
    //  >= UT_ERROR abort, then the errno should be set, and there may be a
    //  further local error message.  There is no error checking to ensure that
    //  each locked source is only released once, so it's up to the user.  The
    //  standard method is to call lockInputs(), then call unlockInputs() on
    //  exit.  However, in some cases (i.e. switch SOP) only some sources need
    //  to be cooked.
    //
    //  lockInput() will return an error code >= UT_ERROR iff idx <
    //  minInputs().  Otherwise, it's considered to be an optional input, so no
    //  data will be returned.  A simple rule of thumb:  If lockInput() returns
    //  ok, the source has to be unlocked, otherwise it shouldn't be unlocked!
    //  If lockInputs() detects an error, it will automatically unlock the
    //  inputs so that unlockInputs() should NOT be called!
    virtual OP_ERROR       lockInput(OP_InputIdx idx, OP_Context &context);
    virtual void         unlockInput(OP_InputIdx idx);
    virtual OP_ERROR       lockInputs(OP_Context &context);
    virtual void         unlockInputs();

    //  This "serial" number refers to the number of times that the geometry
    //  had been changed.  Note, only the "modeller" should bump the cook count,
    //  the OP cook method does this also, but has privilaged access.
    exint                getCookCount() const { return myCookCount; }
    /// The cache misses are when our state was "clean" but it turned
    /// out we didn't have any data cached.  (Note: This doesn't include
    /// ping-ponging on context options.)
    exint                cacheMisses() const { return myCacheMisses; }
    void                 triggerOutputChanged();
    
    void                 triggerUIChanged(
                                OP_UIChangeType type = OP_UICHANGE_ANY);

    //  Returns the index of cooked input to a SOP switch
    virtual OP_InputIdx  cookedInputIndex() const { return -1; }

    /// For nodes which simply pass-through their data from some other node,
    /// this returns the node whose data will used transparently as this node's
    /// output. This function can give different values depending on its
    /// parameters. Used by node traversal algorithms.
    ///
    /// The default implementation returns the first input if it's bypassed, so
    /// subclasses should only do something different if this function returns
    /// NULL.
    ///
    /// @param t            Eval time
    /// @param mark_used    Mark this node is using the returned node (if
    ///                     non-NULL).
    /// 
    virtual OP_Node     *getPassThroughNode(
                            fpreal t,
                            bool mark_used = false);

    bool                 setMinimumCacheSize(int min_size);

    OP_VERSION           getVersionParms() const
                            { return dataMicroNodeConst().modVersion(); }

    // This will be called if the timeInterest flag is set.
    // This will return true if the node needs to be dirtied for cooking
    virtual bool         handleTimeChange(fpreal /* t */) { return false; }

    /// Returns true if the OP depends on time at the given time.  This
    /// is sensitive to handleTimeChange's overrides.
    bool                 isTimeDependent(const OP_Context &context);

    // Returns true if this node is an HDA with a dive target, or a C++ node
    // with a subnework, but is not an OBJ, subnet, or manager.
    virtual bool         isDiveable() const;

    static int           getGlobbedNodes(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);
    
    static int           getGlobbedNetworkBoxes(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);

    static int           getGlobbedPostIts(OP_Node *cwd, UT_String &holder,
                                const char *pattern, UT_WorkArgs &argv,
                                OP_GlobContext *context);

    
    /// Obtains additional nodes that should be copied or deleted when this
    /// node is copied or deleted. It applies to situations, such as, where
    /// an hidden input node feeds only to this node and serves only that
    /// purpose, so it should be coppied/deleted along with the master. 
    virtual void         getExtraNodesForCopyOrDelete(OP_NodeList &extras)const;

    // Runs the creation script (if there is one). The return value is false
    // if the node was deleted while running the script. In this case
    // obviously the node pointer becomes invalid and should not be used
    // any more. It returns true if the node still exists.
    virtual bool         runCreateScript();
    // Go through all our parms to match the values to the current hip file
    // units settings.
    void                 updateParmsToMatchCurrentUnits();

    /// True if the otl is marked as matching, but hasn't actually been
    /// synced yet.
    bool                 getDelaySyncOTL() const
    { return myDelaySyncOTL; }

    /// Shallowly sets the delayed sync flag,
    void                 setDelaySyncOTL(bool isdelayed);

    /// Determines if this node should do delayed syncing or not.
    bool                 shouldDelaySyncOTL() const;

    /// Verifies this node has been synchronized in case it was delayed.
    void                 syncDelayedOTL()
    {
        if (!getDelaySyncOTL()) return;
        internalSyncDelayedOTL();
    }

    /// Matches the node to the current HDA definition, loading the contents
    /// section if ncecessary and setting the match flag.
    virtual void         matchOTLDefinition();

    /// Unmatches (unlocks) the node from the current HDA definition.
    virtual void         unmatchOTLDefinition();

    /// Method that is invoked when the HDA index file has been cleared
    /// because the underlying HDA definition has changed.
    virtual void         handleOTLIndexFileCleared();

    /// Returns the error string where we keep all errors generated during
    /// our most recent synchronization attempt.
    const UT_String     &getSyncErrors() const
                         { return mySyncErrors; }
    /// Returns the error level generated in our last synchronization attempt.
    OP_ERROR             getSyncErrorLevel() const
                         { return mySyncErrorLevel; }

    /// Return true if any ancestor of this node is currently running the
    /// syncContents function (and so has mySyncDepth > 0). This is used to
    /// detect changes to nodes that are not currently "locked", but will
    /// become locked once the sync is complete.
    bool                 isAnyAncestorBeingSynced() const;

    /// Interface to flag that specifies whether or not we match our definition.
    int                  getMatchesOTLDefinition() const;

    /// Utility function for syncing/unsyncing all uncestor nodes.
    static void          propagateMatchOTLDefinitionToAncestors(OP_Node *node,
                                                  bool sync_flag);

    // Some extra functions for dealing with access rights as they relate
    // to matching the OTL definition.
    int                  getCanDeviateFromOTLDefinition() const;
    void                 setAllChildAssetPermissions(int permission);
    // Recompute the asset permissions because something changed like the node
    // was locked or unlocked.
    void                 computeAllChildAssetPermissions();
    // Returns true if this node is contained inside a locked HDA, but
    // is marked as an editable node within that HDA.
    bool                 getIsEditableAssetSubNode() const;

    // Turn off our export flag and the export flags of our children.
    void                 turnOffAllChildExports();

    // Collection of methods for working with licensed assets.
    bool                 haveLicenseToAccessContents(
                                OP_Node* opt_specific_child = nullptr) const;
    bool                 haveLicenseToAccessParentContents() const;
    bool                 haveAncestorWithoutFullLicense(bool ignore_self) const;
    OP_OTLLicenseType    getLicense() const;
    // Get the first (oldest) ancestor without a license to access contents.
    OP_Node             *getFirstExecLicenseOnlyAncestor(
                                bool ignore_self = true) const;
    // Get the last (youngest) ancestor without a license to access contents.
    OP_Node             *getLastExecLicenseOnlyAncestor(
                                bool ignore_self = true) const;

    bool                 isCompiled() const;

    // Save as a series of ASCII commands.
    void                 saveWires(std::ostream &os, const char *name, 
                                int dogeneral = 0);
    void                 saveOutputWires(std::ostream &os, const char *name, 
                                int dogeneral = 0);
    virtual void         saveIntrinsicCommand(std::ostream &os, 
                                const char *name);
    
    /// Writes to 'os' a string of hscript commands to recreate this node.
    virtual OP_ERROR     saveCommand(std::ostream &os,
                                     const char *name,
                                     fpreal x,
                                     fpreal y,
                                     const char *netboxname,
                                     const OP_SaveCommandOptions &options);

    // This method saves a chlock style command for this node's parameters.
    // name        - the name of the node to print on the command;
    // command     - the name of the command;
    // flag_method - a PRM_Parm method that can be queried for the flag to
    //               output;
    // defaultstoo - prints a default "-*" or "+*" as the first parameter
    // reverse     - normally the default is "-*" followed by the list of
    //               parameters that result true for flag_method().  If 
    //               reverse is true, then the default is "+*" followed by
    //               the parameters where flag_method() is false.  Only useful
    //               when defaultstoo is true.
    // parm_array  - an optional array of parameters whose values should be
    //               printed.  If this array is NULL, then the entire node
    //               is searched.
    void                 saveParameterFlags(std::ostream &os, const char *name,
                                     const char *command,
                                     bool (PRM_Parm::*flag_method)(int) const,
                                     bool defaultstoo, bool reverse,
                                     UT_Array<opParmData> *parm_array);

    void                 saveUserDataCommand(
                                     std::ostream &os, const char *node_name,
                                     bool omit_version = false);

    enum RampError
    {
        RAMP_ERR_SUCCESS,
        RAMP_ERR_NOT_FOUND,
        RAMP_ERR_ONLY_KEY
    };
    virtual RampError    rampCommand(bool remove, fpreal pos, float rgba[4]);
    RampError            rampCommand(bool remove, fpreal pos, float rgba[4],
                                     UT_Ramp &ramp);

    virtual bool         loadRamp(UT_IStream &is, const char *path=nullptr);

    bool                 loadRamp(UT_IStream &is, UT_Ramp &ramp,
                                  const char *path=nullptr);
    OP_ERROR             saveRamp(std::ostream &os, UT_Ramp &ramp,
                                  const char *name = nullptr, int command = 0);

    bool                 getUserData(const UT_StringRef &key,
                                UT_StringHolder &result) const;
    void                 setUserData(const UT_StringRef &key,
                                const UT_StringHolder &data,
                                bool save_undo);
    bool                 hasUserData(const UT_StringRef &key) const;
    bool                 deleteUserData(const UT_StringRef &key,
                                bool save_undo);
    const UT_Options    &userData() const
                         { return myUserData; }
    bool                 loadUserData(UT_IStream &is, const char *path=nullptr);
    OP_ERROR             saveUserData(std::ostream &os, const char *path);
    void                 clearUserData(bool save_undo);
    virtual void         userDataChanged(const UT_StringHolder &key);

    /// Prefix to use for internally used user data.
    static const char   *internalUserDataPrefix() { return "sidefx::"; }
    
    /// Returns a shared pointer to a previously stored blind data. If no
    /// blind data exists with the given key, an empty shared pointer is
    /// returned.
    UT_SharedPtr<void>   getBlindData(const char *key) const;

    /// Return a pointer to a previously stored blind data, statically cast
    /// to the type given. If the cast fails, or if there's no data of that
    /// type, a NULL pointer is returned. To distinguish between the two cases
    /// call hasBlindData().
    template<typename T>
    UT_SharedPtr<T>      getBlindData(const char *key) const
    { return UTstatic_pointer_cast<T>(getBlindData(key)); }

    /// Stores a blind data pointer on this OP_Node object. Any entry that
    /// previously existed will be erased, and, if it is the last reference,
    /// the object itself deleted. The \c void type can convert from any other
    /// shared pointer type, while storing the deleter function, allowing
    /// OP_Node to delete the data without knowing anything about the class.
    /// Blind data is *not* stored with the class.
    void                 setBlindData(const char *key, UT_SharedPtr<void> ptr);

    /// Returns true if this object stores a blind data with the given key.
    bool                 hasBlindData(const char *key) const;

    /// Remove any reference to the blind data of the given key from this 
    /// object.
    bool                 deleteBlindData(const char *key);

    void                 getDataBlockKeys(UT_StringArray &keys,
                                const UT_StringHolder &type =
                                    UT_StringHolder()) const;
    OP_DataBlockPtr      getDataBlock(const char *key) const;
    bool                 setDataBlock(const char *key, OP_DataBlockPtr ptr);
    OP_ERROR             saveDataBlocksPacket(std::ostream &os,
                                const char *path_prefix,
                                const UT_StringHolder &node_name);
    bool                 loadDataBlocks(UT_IStream &is, const char *path);
    bool                 clearDataBlocks();
    virtual void         dataBlockChanged(const UT_StringHolder &key);

    // deleteNodeData is called when the OP_Cache wants to delete some data.
    // This method should return 1 if you want change events to be propagated
    // to the extra inputs when data is deleted from the cache.
    virtual int          deleteNodeData(void *);
    void                 propagateNodeDataDeleted();

    // getCachedPythonObject returns NULL if no object exists with the given
    // key.
    PY_OpaqueObject     *getCachedPythonObject(const UT_StringRef &key) const;
    // Call setCachedPythonObject with a PyObject * cast to a void *, not with
    // a PY_OpaqueObject * cast to a void *.  The pointer must not be null.
    void                 setCachedPythonObject(
                            const UT_StringHolder &key, void *opaque_py_object);
    // deleteCachedPythonObject returns false if no value exists with that key.
    bool                 deleteCachedPythonObject(const UT_StringRef &key);
    void                 clearCachedPythonObjects();
    // cachedPythonObjects returns a UT_StringMap containing pointers to 
    // PY_OpaqueObjects.  The pointers are not null.
    const OP_PythonObjectCache &cachedPythonObjects() const
                            { return myCachedPythonObjects; }

    bool                 loadExtraInputs(UT_IStream &is,
                                         const char *path = nullptr);

    void                 saveOverrides(std::ostream &os);
    void                 saveOverrides(std::ostream &os, OP_Node *root,
                                       const UT_String &rootpath,
                                       bool &added);
    void                 saveChildOverrides(std::ostream &os, OP_Node *root,
                                            const UT_String &rootpath,
                                            bool &added);
    bool                 loadOverride(UT_IStream &is);
    UT_ErrorSeverity     prmCookOverrides(
                            fpreal t, int thread,
                            const char *parm_name,
                            int vec_idx) override;
    bool                 isParmPendingOverride(const char *parm_name,
                                               int vec_idx) const override;
    OP_ERROR             cookOverrides(OP_Context &c);

    virtual void         removeOverrideDestination(OP_Node * /*dest*/) {}
    virtual void         removeOverrideDestination(OP_Node * /*dest*/,
                                                   int /*parm_idx*/) {}

    // Overriding virtual function in PRM_ParmOwner to run a command.
    void                 executeCommand(const char *command,
                                        std::ostream *out,
                                        std::ostream *err) const override;

    SYS_NO_DISCARD_RESULT
    UT_UniquePtr<PRM_ParmOwnerContext>
                         pushAsPwd() const override;

    OP_ERROR             executeHscriptScript(const char *script,
                                const OP_Context &context);
    OP_ERROR             executePythonScript(const char *script,
                                const OP_Context &context);

    void                 addPythonNodeError(const PY_Result &py_result);
    
    void                 saveInputs(std::ostream &os, bool compile_basic);
    bool                 loadInputs(
                                UT_IStream &is,
                                const char *path = nullptr,
                                bool named = false);
    void                 saveNamedInputs(std::ostream &os, bool compile_basic);
    void                 saveNamedOutputs(std::ostream &os);
    bool                 loadNamedOutputs(
                                UT_IStream &is,
                                const char *path = nullptr);

    // These methods provide access to the options that can be stored on each
    // input of a node, if the node type enables this feature.
    void                 getEditableInputDataKeys(OP_InputIdx idx,
                                UT_StringArray &keys) const;
    const UT_OptionEntry*getEditableInputData(OP_InputIdx idx,
                                const UT_StringRef &key) const;
    bool                 setEditableInputData(OP_InputIdx idx,
                                const UT_StringHolder &key,
                                const UT_OptionEntry &value);
    void                 saveEditableInputData(std::ostream &os) const;
    bool                 loadEditableInputData(UT_IStream &is,
                                const char *path);
    // Special case functions for getting and setting the input "name", which
    // just call the generic InputData functions.
    UT_StringHolder      getEditableInputString(OP_InputIdx idx,
                                const UT_StringRef &key) const;
    bool                 setEditableInputString(OP_InputIdx idx,
                                const UT_StringRef &key,
                                const UT_StringHolder &str);

    /// @{ If a subclass is interested in the saved input or output names, then
    /// it should  override this method. The array will be filled during load.
    virtual UT_StringArray *    getArrayForLoadedInputNames();
    virtual UT_StringArray *    getArrayForLoadedOutputNames();
    /// @}

    void                 checkInputs(); // this method will check the
                                        // node references in all the inputs

    // Saves out extra information for this node to be included in a dialog
    // script that defines an operator type created from this one.
    virtual void         saveDialogScriptExtraInfo(std::ostream &os);

    // Fills in the supplied default gallery entry with info from this node.
    virtual void         createGalleryEntry(OP_GalleryEntry &entry);

    // When a string parameter can have the syntax: 'op:/...', use these
    // evaulate methods to do the approprate checking and reference building.
    // These methods will return a reference to the OP_Node if one is
    // referenced.  If the syntax is something like:
    //          op:/foo/bar[32]
    // Then the optime will be (32-1)/$FPS rather than the evaluation time.
    void                 evalOpPathString(UT_String &val, int pi, int vi,
                                    fpreal t, int &op_id, fpreal &op_time,
                                    int expanded = 1);
    void                 evalOpPathString(UT_String &val, const char *pn,
                                    int &pi, int vi, fpreal t,
                                    int &op_id, fpreal &op_time,
                                    int expanded=1);
    static int           findOpFramePair(const char *path, int &op_id,
                                    fpreal &frame);

    /// Build a UT_XformOrder out of TRS and XYZ parameter values
    static void          buildXformOrder(int trs, int xyz,
                                UT_XformOrder &order);

    static const UT_XformOrder&  buildXformOrder(int trs, int xyz );

    /// Translate a TRS parameter menu index into the UT_XformOrder type
    static UT_XformOrder::rstOrder  getMainOrder( int trs );
    /// Translate a UT_XformOrder type into a TRS parameter menu index
    /// (inverse of getMainOrder())
    static int           getMainOrderMenuIndex(UT_XformOrder::rstOrder order);
    /// Translate a XYZ parameter menu index into the UT_XformOrder type
    static UT_XformOrder::xyzOrder  getRotOrder( int xyz );
    /// Translate a UT_XformOrder type into a XYZ parameter menu index
    /// (inverse of getRotOrder())
    static int           getRotOrderMenuIndex(UT_XformOrder::xyzOrder order);

    /// NB: None of the getXformPivot() or getPivotParmValue() methods take
    ///     any pivot compensation transform into account.  It is up to the
    ///     caller to account for any such transform.
    static UT_Vector3R   getXformPivot(int trs,
                                  fpreal tx, fpreal ty, fpreal tz,
                                  fpreal px, fpreal py, fpreal pz);
    static UT_Vector3R   getXformPivot(int trs,
                                  fpreal tx, fpreal ty, fpreal tz,
                                  fpreal px, fpreal py, fpreal pz,
                                  fpreal pivot_rx, fpreal pivot_ry,
                                  fpreal pivot_rz, bool inverse = false);
    static UT_Vector3R   getPivotParmValue(int trs,
                                  fpreal tx, fpreal ty, fpreal tz,
                                  fpreal px, fpreal py, fpreal pz);
    static UT_Vector3R   getPivotParmValue(int trs,
                                  fpreal tx, fpreal ty, fpreal tz,
                                  fpreal px, fpreal py, fpreal pz,
                                  fpreal pivot_rx, fpreal pivot_ry,
                                  fpreal pivot_rz, bool inverse = false);

    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float px, float py, float pz,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                double tx, double ty, double tz,
                                double rx, double ry, double rz,
                                double sx, double sy, double sz,
                                double px, double py, double pz,
                                UT_DMatrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                const UT_Matrix4F::PivotSpace &pivot,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                double tx, double ty, double tz,
                                double rx, double ry, double rz,
                                double sx, double sy, double sz,
                                const UT_DMatrix4::PivotSpace &pivot,
                                UT_DMatrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                float px, float py, float pz,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                double tx, double ty, double tz,
                                double rx, double ry, double rz,
                                double sx, double sy, double sz,
                                double s_xy, double s_xz, double s_yz,
                                double px, double py, double pz,
                                UT_DMatrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                float tx, float ty, float tz,
                                float rx, float ry, float rz,
                                float sx, float sy, float sz,
                                float s_xy, float s_xz, float s_yz,
                                const UT_Matrix4F::PivotSpace &pivot,
                                UT_Matrix4 &mat);
    static void          buildXform(int trs, int xyz,
                                double tx, double ty, double tz,
                                double rx, double ry, double rz,
                                double sx, double sy, double sz,
                                double s_xy, double s_xz, double s_yz,
                                const UT_DMatrix4::PivotSpace &pivot,
                                UT_DMatrix4 &mat);
    static void          buildXform(
                                const UT_Matrix4F::FullTransformModel &parms,
                                UT_Matrix4F &mat);
    static void          buildXform(
                                const UT_Matrix4D::FullTransformModel &parms,
                                UT_Matrix4D &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float px, float py,
                                UT_Matrix3 &mat);
    static void          buildXform(int trs, 
                                double tx, double ty, double rz,
                                double sx, double sy, double px, double py,
                                UT_DMatrix3 &mat);
    static void          buildXform(int trs, 
                                float tx, float ty, float rz,
                                float sx, float sy, float s_xy,
                                float px, float py,
                                UT_Matrix3 &mat);
    static void          buildXform(int trs, 
                                double tx, double ty, double rz,
                                double sx, double sy, double s_xy,
                                double px, double py,
                                UT_DMatrix3 &mat);

    virtual int          getTranslateParmIndex();

    // This is done only after a load to make sure that
    // all inputs have been resolved correctly.
    void                 resolveInputReferences();

    static void          clearAllPendingUndoFlags();

    void                 clearUndoFlags() override;
    void                 setAnyUndoFlag() override;
    void                 saveForUndoInput();

    /// When doing bulk parameter modifications, they can be sandwiched between
    /// blockModify(true) and blockModify(false) statements as an optimization.
    /// Parameters modified during blockModify(true) will have their dirtiness
    /// propagation to other scene entities like nodes and parameters
    /// suppressed until blockModify(false) is called.
    ///
    /// @note This will NOT suppress events to addOpInterest() callbacks.
    ///       In fact, blockModify(false) currently sends out an extraneous
    ///       OP_PARM_CHANGED with parm index of -1.
    void                 blockModify(int on_off, int propagate = 1);

    int                  isBlockModify() const;
    bool                 isModifyWaiting() const;
    virtual void         propagateEndBlockModify();

    // Only returns anything in the case of chops
    virtual const CL_Clip *getClip(OP_Context *context = nullptr);

    /// Returns the a chop network path suitable for storing motion effects
    /// associated with this node.
    void                 getMotionEffectsNetworkPath(UT_String &path);

    fpreal               getLastCookTime() const;
    /// Return the last cook time as a formatted string.
    void                 getLastCookTime(UT_String &last_cook_time) const;
    /// Return the cook information as a formatted string.
    void                 getCookInfo(UT_String &info) const;
    /// Return the cook information in a UT_InfoTree.
    void                 getCookInfoTree(UT_InfoTree &tree) const;

    // Those operators which need a ramp editor must define this method.
    virtual UT_Ramp     *getRamp();

    virtual int          isCookingRender() const { return 0; }
    virtual void         setCookingRender(int val);

    virtual void         clearInterrupted()
                            { clearInterruptedImpl(/*allow_recook*/true); }
    bool                 wasInterrupted() const
                            { return flags().getInterrupted(); }

    // work-around to display warning message when export src or destination
    // are renamed.  OP_Node::cook clears the error messages when a node export
    // changes so we had to save the fact that a rename conflict is pending
    void                setRenameConflict()
                        { myRenameConflict = 1; }
    void                setRunningCreateScript(int onoff);

    // Base class methods to output code to a file or a stream:
    virtual int         outputCode(OP_OutputCodeParms &, OP_Context &);

    virtual fpreal      getTimeTransform(int input, fpreal t);
    virtual void        getInputRes(int input, fpreal t,
                                    const OP_Context &context,
                                    OP_Context &input_context);

    // Utility methods:
    UT_TokenString &     getHashCode(OP_Context &context, int group_mask =1);
    virtual UT_TokenString & getParmHashCode(OP_Context &context,
                                             int group_mask = 1);

    virtual int         getNumInputsToHash();
    virtual OP_Node    *getInputToHash(OP_InputIdx i);
    
    void                clearHashCodeFlags();
    bool                isHashCodeBuilt() const { return myBuiltHashCode;}
    void                builtHashCode(bool b = true) { myBuiltHashCode = b; }
    void                buildInputHashCode(UT_TokenString &string,
                                           OP_Context &context,
                                           int group_mask,
                                           int level);

    // If an interactive state was used to create this node, set it here.
    void                 setCreatorState(const char *s)
                         { myCreatorState.harden(s); }
    const UT_String     &getCreatorState() const   { return myCreatorState;    }
    void                 builtExplicitly(int yn)   { myBuiltExplicitly = yn;   }
    int                  wasBuiltExplicitly() const{ return myBuiltExplicitly; }

    bool                 matchesState(const char *state) const;

    /// Some nodes (VOPs and SHOPs) represent shaders, so this method
    /// returns node parameters that are used as shader parameters.
    virtual const PRM_Template  *getShaderParmTemplates();

    // Don't even think about calling changeParmTemplate if you aren't
    // OP_Operator.
    virtual void         changeParmTemplate(PRM_Template *new_template);

    // Deletes any input or output connections in excess of maximum allowed.
    virtual void         ensureInputsAndOutputsAreValid();

    // Connect the node to an input.  If branch_off is false and the input node
    // currently has outputs, the node will be inserted before the outputs.
    void                 connectToInputNode(OP_Node &inputnode,
                                            OP_InputIdx input_idx,
                                            int branch_off=0);

    // This method should be called when the user edits an overridden channel
    virtual int                  editCallback(CL_Track *track, fpreal t,
                                              fpreal new_value);

    // This mechanism allows users to communicate editing changes
    static OP_EditCallback       getEditCallback(void *&data);
    //static void                        setEditCallback(OP_EditCallback func,
                                                 //void *data);

    // These build an xform matrix based upon the given parameters.
    // The axis is the axis around which to rotate by 90 degrees.  If
    // it is lower case, it will be rotated by +90, if it is upper case,
    // by -90.  To not rotate at all, use '-'.
    static void          buildQuadricXform(UT_Matrix4 &mat,
                                float tx, float ty, float tz,
                                float sx, float sy, float sz,
                                char axis = 'y',
                                float rx = 0.0f, float ry = 0.0f,
                                float rz = 0.0f);

    static void          buildQuadricXform(UT_DMatrix4 &mat,
                                double tx, double ty, double tz,
                                double sx, double sy, double sz,
                                char axis = 'y',
                                double rx = 0.0, double ry = 0.0,
                                double rz = 0.0);

    static int           buildOpMenu(
                                OP_Network *net,
                                PRM_Name *the_menu,
                                int the_menu_size,
                                int (*do_add)(OP_Node *) = nullptr,
                                int start_item = 0,
                                const PRM_Parm *parm = nullptr,
                                int show_subnets = 1,
                                int expand_subnets = 1,
                                bool recurse = false);

    // Build the "Predefined Rules" menu that is common to several OPs
    // including Event and Group POPs. This is built from the text file table
    // OP<name>Rules, where name is the OP type (ie Event).
    static void          buildPreDefRulesMenu(PRM_Name *menu,
                                              OP_PreDefRules &pdr);

    // Allows operators to use their own local table for variables and build
    // structures on demand...  Implement the syntax highlight version only
    // if you need to resolve variables for syntax highlighting that are not
    // normally resolved by the generic resolveVariable() method.
    virtual const CH_LocalVariable *resolveVariable(const char *name);
    virtual const CH_LocalVariable *resolveExtraVariableForSyntaxHighlight(
                                                            const char *name);

    // This value bumps whenever nodes are created/deleted/renamed.
    static int           getNameSerialIndex();

    // export mapping techniques
    virtual void        setMapping(int idx, int type,
                                   const char *label = nullptr);
    virtual int         getMapping(int idx, const char *&label) const;

    // drag-n-drop receive methods
    virtual int         acceptDragDrop(DD_Source &src, const char *label);
    virtual int         testDragDrop(DD_Source &src);
    virtual void        getDragDropChoice(DD_Source &src, DD_ChoiceList &c);

    // These methods are used to give quick overview information about a node
    bool                hasComment() const;
    bool                hasParmsNotAtFactoryDefault() const;
    bool                hasAnimatedParms() const;
    bool                hasChopOverriddenParms() const;

    /// traverseInputs calls 'callback' on this node and all its inputs.
    /// If callback returns true for any node, it will stop and return
    /// true, otherwise it will return false;
    /// @param callback             Callback function
    /// @param data                 User data passed to the callback function
    /// @param opts                 A set of flags to configure the traversal:
    /// TRAVERSE_INTO_SUBNETS       If input is a subnet, we continue
    ///                             traversing from its display node.
    /// TRAVERSE_REF_INPUTS         Follow inputs marked as reference inputs
    /// TRAVERSE_ONLY_USED_INPUTS   Follow only inputs used in the last cook
    /// TRAVERSE_PASSTHROUGH_INPUTS Use the getPassThroughNode to traverse
    ///                             through nodes that directly steal their
    ///                             input node's data.
    /// TRAVERSE_EXTRA_INPUTS       Follow nodes which this node implicitly
    ///                             depends on.
    /// TRAVERSE_SIMULATION_INPUTS  For nodes that are DOP parents, grab extra
    ///                             inputs from the simulation.
    /// TRAVERSE_COOKED_INPUT_INDEX_INPUTS
    ///                             Uses the cookedInputIndex method to
    ///                             traverse "passthrough"-type inputs for
    ///                             nodes that might trigger a cook when
    ///                             calling getPassThroughNode, but where we
    ///                             want to avoid triggering a cook.
    /// @param extra_interest_mask  For extra inputs, this mask allows one to
    ///                             restrict which of those dependency types
    ///                             follow.
    //@{
    enum TraverseOptions {
        TRAVERSE_DEFAULT                        = 0x0000,
        TRAVERSE_INTO_SUBNETS                   = 0x0001,
        TRAVERSE_REF_INPUTS                     = 0x0002,
        TRAVERSE_ONLY_USED_INPUTS               = 0x0004,
        TRAVERSE_PASSTHROUGH_INPUTS             = 0x0008,
        TRAVERSE_EXTRA_INPUTS                   = 0x0010,
        TRAVERSE_SIMULATION_INPUTS              = 0x0020,
        TRAVERSE_COOKED_INPUT_INDEX_INPUTS      = 0x0040,
    };
    bool                traverseInputs(bool (*callback)(OP_Node &, void *),
                                       void *data,
                                       TraverseOptions opts,
                                       OP_InterestType extra_interest_mask =
                                                OP_INTEREST_ALL);
    bool                traverseInputs(bool (*callback)(const OP_Node &, void*),
                                       void *data,
                                       TraverseOptions opts,
                                       OP_InterestType extra_interest_mask =
                                                OP_INTEREST_ALL) const;
    //@}

    /// Using this node as a starting point, traverse our inputs recursively
    /// to get our best guess of the nodes that have been cooked to generate
    /// the current cooked result of this node.
    void                getCookPathNodes(OP_NodeList &nodes);

    /// Traverses children of this node, calling 'callback' on all children.
    /// If callback returns true, the traversal stops at that node.
    bool                traverseChildren(bool (*callback)(OP_Node &, void*),
                                         void *data,
                                         bool recurse_into_subnets);

    // Very specialized to see if this node (and optionally, any input
    // ancestors are also cooking.
    bool                isCooking(bool include_ancestors) const;

    // This method returns true if the OP_Node makes use of its footprint
    // flag and false otherwise.
    virtual bool         usesFootprint() const  { return false; }

    void                 getExternalReferences(
                                UT_StringArray &reflist,
                                UT_StringArray *nodelist = nullptr,
                                bool from_children_too = true,
                                bool collapse = false,
                                bool check_missing = false,
                                bool show_missing_only = false);
    virtual bool         getSaveWithVopnets();
    virtual void         runDelScript();
    /// Overriden in VOPs to remove any channel refrences we may have 
    /// to the node being deleted.
    virtual void         preDelete() { }

    // Two functions for upcasting this node to a DOP_Parent. DOP_Parent
    // is a class which owns a simulation and has DOP_Nodes as children.
    virtual DOP_Parent          *castToDOPParent()       { return nullptr; }
    virtual const DOP_Parent    *castToDOPParent() const { return nullptr; }

    // These provide a version which you can query without being above DOP.
    // This will also return dop parents for non-DOPs that have cache
    // like interfaces.
    virtual OP_DopParent        *castToOpDopParent()
                         { return (OP_DopParent *) castToDOPParent(); }
    virtual const OP_DopParent  *castToOpDopParent() const
                         { return (const OP_DopParent *) castToDOPParent(); }

    // This function upcasts this node to a VOP_CodeGenerator.
    // VOP_CodeGenerator is a class which generates VEX code from the VOPs
    // contained inside the node.
    virtual VOP_CodeGenerator   *getVopCodeGenerator()          { return nullptr; }
    virtual VOP_CodeGenerator   *getVopAutoCodeGenerator()      { return nullptr; }
    virtual const VOP_CodeGenerator
                                *getVopAutoCodeGenerator() const{ return nullptr; }
    // Some nodes will only generate vop code generators on demand, this
    // will ensure they are built.
    virtual void                 buildVopCodeGenerator() {}

    // Return the manager that handles exported parameters from contained
    // Parameter VOPs.  Only certain kinds of VOP nodes can have such a manager
    // (i.e. Subnet VOPs, VOP HDAs).  Note that a node cannot have both a code
    // generator AND a parms manager because the code generator already has its
    // own parms manager.
    virtual VOP_ExportedParmsManager *getVopExportedParmsManager(
                                        bool create_if_needed=false)
                                        { return nullptr; }

    /// @{
    /// Methods to postpone the update of the code generator until ending
    /// the last (level zero) update. This avoids recalculation of parameters
    /// and vop signatures, which can be quite costly.
    // TODO: remove these two virtuals in farour of getVopCodeGenerator()
    //       returning OP_VopCodeGenerator from which VOP_CodeGenerator
    //       derives and which has these two virtuals available at OP level.
    virtual int                  beginVopCodeGeneratorUpdate()  { return 0; }
    virtual void                 endVopCodeGeneratorUpdate(int update_level) {}
    /// @}

    // Build a command line for a VEX script to be called with.  This does all
    // the channel evaluation and string expansion required.  If there is an
    // error, 0 is returned (otherwise 1).
    int                  buildVexCommand(UT_String &result,
                                         const PRM_Template *templatelist,
                                         fpreal now,
                                         int start_parm = 0,
                                         int end_parm = INT_MAX,
                                         bool use_parmvop_tag=true
                                         );
    int                  buildVexCommandWithDependencies(OP_Node *owner, 
                                         DEP_MicroNode *depnode,
                                         UT_String &result,
                                         const PRM_Template *templatelist,
                                         fpreal now,
                                         int start_parm = 0,
                                         int end_parm = INT_MAX,
                                         bool use_parmvop_tag=true
                                         );

    // Builds a VEX script using standardized parameter names.
    // "vexsrc": int for myself, shop, or script.
    // "script": raw vex script
    // "soppath": for the shop path.
    static PRM_ChoiceList       theVexSrcParmMenu;
    static PRM_Name             theVexSrcParmName;
    static PRM_Name             theVexScriptParmName;
    static PRM_Name             theVexNodePathParmName;
    static PRM_Name             theVexClearParmName;
    static PRM_Name             theVexCWDName;
    virtual void         buildVexScript(UT_String &script, fpreal t,
                                OP_Node *owner,
                                UT_Map<int, bool> *visitlist = nullptr);
    virtual void         buildVexScript(UT_String &script, fpreal t,
                                DEP_MicroNode *depnode,
                                UT_Map<int, bool> *visitlist = nullptr);


    // Returns true if vex shader has parameter by a given name.
    virtual bool         hasVexShaderParameter(const char *parm_name);


    /// This function returns a string that encodes all the necessary
    /// information about a node-based material that helps the script-based
    /// materials to function properly. The string usually encodes info stored
    /// on child nodes, such as rendering properties or procedurals. Then
    /// the script node can use that info to provide necessary data
    /// for rendering.
    /// Returns true if the method provides usable information.
    virtual bool                getScriptMaterialInfo( UT_String & mat_info,
                                    VOP_ScriptMaterialCodeMapper * mapper )
                                { return false; }

    /// Returns the sub type name, if the node's operator wants to be
    /// saved as an HDA in a special way (ie, other than the regular
    /// scripted operator handling). The sub type name is then used
    /// to distinguish how to handle the HDA creation.
    virtual const char  *getHDASubType()
                                { return nullptr; }

    // Set the channel alias for a channel (or parm subindex).  Returns true
    // if successful and false otherwise.
    bool                 setChannelAlias(PRM_Parm &parm, int subindex, 
                                         const char *alias_name);

    void                 disconnectAllInputsOutputs(
                                bool keep_selected, 
                                bool force_disconnect_outputs = false);

    void                 disconnectAllInputs();
    void                 disconnectAllOutputs();

    // Notify dependents that a parm name has changed.
    virtual void         notifyParmRenameDependents( 
                                        const UT_String &chan_name,
                                        const UT_String &old_chan_name );

    void                 writeChannel(CH_Channel *channel, std::ostream &os,
                                      const char *name, bool frames);
    void                 writeAllChannels(std::ostream &os, const char *name,
                                          bool frames, bool dochblock,
                                          bool dospareparms);

    // Run the callback function for a particular parm, and the callbacks
    // of any parms linked to this parm. Returns false if the node is
    // deleted while running the callback.
    bool                 triggerParmCallback(
                            PRM_Parm *parmptr,
                            fpreal now,
                            int value,
                            void *data,
                            const UT_Options *options = nullptr) override;

    // Run the callback function for a particular parm only.
    //  Returns false if the node is deleted while running the callback.
    bool                 triggerSoloParmCallback(
                            PRM_Parm *parmptr,
                            fpreal now,
                            int value,
                            void *data,
                            const UT_Options *options = nullptr);

    int64                getMemoryUsage(bool inclusive) const override;
    int64                getExtraInputMemoryUsage() const;
    static void          printOpMemoryUsageStats(std::ostream &os);

    /// This method will unscope all the channels belonging to this op.
    /// If the recurse flag is set it will recurse through the children
    /// (at this level the recurse flag is ignored).
    virtual void         unscopeChannels(bool recurse);

    /// This method will undisplay all the channels belonging to this op.
    /// If the recurse flag is set it will recurse through the children
    /// (at this level the recurse flag is ignored).
    virtual void         undisplayChannels(bool recurse);

    /// This method will unpin all the channels belonging to this op.
    /// If the recurse flag is set it will recurse through the children
    /// (at this level the recurse flag is ignored).
    virtual void         unpinChannels(bool recurse);

    /// This method takes a pattern string and will perform the ch_scope_op
    /// on each of our paramaeters that match the pattern.   This method
    /// primarily supports the chscope command.
    virtual void         setChannelScope(const char *pattern, 
                                         OP_ScopeOp scope_op,
                                         const OP_ScopeOptions &scope_opts);

    /// A simple wrapper around getName() to allow us to abstract its 
    /// functionality up to OP_NetworkBoxItem.
    const UT_StringHolder       &getItemName() const override
                                 { return getName(); };
    bool                 setItemName(const UT_StringHolder &name) override;

    /// Caches the descriptive name to member data, and returns that. The
    /// cache is automatically dirtied in opChanged.
    const UT_StringHolder &getCachedDescriptiveName();

    // This function is called when our spare parm definition is changing.
    bool                 changeSpareParms(UT_IStream &istream,
                                          UT_String &errors) override;
    // This function is called during the changeSpareParms operation when
    // one of our parameters is being removed.
    void                 spareParmRemoved(const char *parmname) override;
    
    // This is a secondary parm list where all obsolete parameters are
    // placed (if any)
    PRM_ParmList        *createObsoleteParmList() override;
    void                 resolveAndDeleteObsoleteParmList(
                            PRM_ParmList *&obsolete_parms) override;

    unsigned             referenceAllParameters(
                            OP_Parameters *from,
                            bool relative_references = true) override;

    void                 clearVersionUserData();
    void                 updateVersionUserData();

    /// After the nodes parameter list is loaded, syncNodeVersionIfNeeded() is
    /// called to perform any necessary upgrades if the version number of
    /// the loaded node (taken from user data) is different from the node
    /// type's version number (getOperator()->getVersion()). Use the
    /// from_version parameter to override the node current version.
    /// If needed, this will call syncNodeVersion(). After synching, the node's
    /// version user data will be set to the current version if
    /// update_node_version is true.
    void                 syncNodeVersionIfNeeded(
                                bool *node_deleted,
                                const char *from_version = nullptr,
                                bool update_node_version = false);

    /// Sync the node assuming that it is currently at old_version to the
    /// current_version. By default, this will call the corresponding
    /// OTL_SYNCNODEVERSION section if it exists.
    void                 syncNodeVersion(
                                const char *old_version,
                                const char *current_version,
                                bool *node_deleted) override;

    // Sets the given stamping parameter.
    // Returns true if the param was changed. Note that we may return false
    // even if this was a valid operation as param might have already been
    // set to the given value.
    // If the warned variable is given, then we only warn if its contents
    // is false. Then in that case, we will set it to true when needed.
    bool                 setGlobalFloatParam(const char *param,
                                        fpreal value,
                                        bool *warned);
    bool                 setGlobalStringParam(const char *param,
                                        const char *strvalue,
                                        bool *warned);

    // This allows one to prevent chop cooking due to parameter modifications
    // until the outermost block is done.
    void                 beginPropagateModification();
    void                 endPropagateModification();

    // Add any OTL-defined operators used by this node to the specified table.
    virtual void         getActiveOperatorsDefinedByOTL(
                                UT_Set<OP_Operator *> &active_operators) const;

    // Returns true if we are in the middle of a call to sendBulkNotifications,
    // Or doing some other operation that involves sending out a whole bunch
    // of change notifications all at once. This allows VOP Networks to avoid
    // over-cooking.
    static bool          getDoingBulkNotification();
    static bool          isDirectorDoingBulkNotification();

    /// Returns whether multi-inputs on this particular op might have different
    /// names for each of the inputs, or if the name will always be the same for
    /// all the inputs.
    virtual bool         hasDifferentMultiInputs() const;


    virtual bool         canCreateNewOpType() const;
    static bool          createNewOpType
                            (OP_Node *node,
                             UT_String &errors,
                             const char *type_name=nullptr,
                             const char *type_label=nullptr,
                             const char *otl_file=nullptr,
                             const char *meta_source=nullptr,
                             const char *comment=nullptr,
                             const char *version=nullptr,
                             const char *new_name=nullptr,
                             int         minimum_inputs=-1,
                             int         maximum_inputs=-1,
                             bool ignore_external_references=false, 
                             bool compress_contents=false,
                             bool force=false,
                             int *new_node_id=nullptr,
                             bool compile_contents = false,
                             bool change_node_type = true,
                             bool create_backup = true);

    virtual UT_String   *getMaterialIconFilename() { return nullptr; }
    virtual void         setMaterialIconFilename(const char * /*icon_file*/) {}
    virtual IMG_Raster  *getMaterialIconImage() { return nullptr; }
    virtual bool         getMaterialIconAllowRegenerateFlag() { return true; }
    virtual void         setMaterialIconAllowRegenerateFlag(bool) {}

    // Call these functions when making a lot of calls to opChanged on a
    // list of nodes. These functions make sure that VOP Networks only get
    // one change notification no matter how many child nodes are about
    // to send any number of change events.
    // @parm caller The node that starts the bulk notifications, if applicable.
    static void          startBulkNotifications(
                                const OP_NodeList &changed,
                                OP_Node *caller = nullptr);
    static void          endBulkNotifications(
                                const OP_NodeList &changed);

    /// This is overriden in VOPs. It returns true if the input at input_idx
    /// will need *and* can perform autoconversion of its input type to the
    /// type it needs. If autoconversion is not needed, or is impossible,
    /// this will return false.
    virtual bool         willAutoconvertInputType(OP_InputIdx input_idx);

    bool                 isDependentOn(OP_Node* other_node, PRM_Parm* parm);

    // Gets whether the input at idx is collapsed.  Currently this is only used
    // in VOPs.  
    virtual bool         getIsInputVisibleDefault(OP_InputIdx idx);

    // Debugging function to confirm that all PRM_Template's are consistent
    // with their parameters.
    bool                 verifyTemplatesWithParameters() const;

    // Same as getInputReference, except using a named reference.
    OP_Input            *getNamedInputReference(
                                const OP_ConnectorId& input_name, bool grow);
    OP_Input            *getNamedInputReferenceConst(
                                const OP_ConnectorId& input_name) const;

    OP_Node             *getNamedInput(const OP_ConnectorId& input_name,
                                bool mark_used=false) const;
    /// Note that this function only looks through currently connected
    /// inputs for the name, not through all possible input names on
    /// this node. mapInputNameToIndex does that instead.
    virtual OP_InputIdx          getInputFromName(const UT_String &in) const;
    virtual OP_OutputIdx         getOutputFromName(const UT_String &out) const;
    virtual void         getInputName(UT_String &in, OP_InputIdx idx) const;
    virtual void         getOutputName(UT_String &out, OP_OutputIdx idx) const;
    static UT_StringHolder defaultInputName(OP_InputIdx idx);
    static UT_StringHolder defaultOutputName(OP_OutputIdx idx);

    OP_OutputIdx                getSpareOutputFromName(const UT_StringHolder& name) const;

    OP_InputIdx                 getInputFromUniqueName(
                                        const OP_ConnectorId& id) const;
    UT_Optional<OP_OutputIdx>   getOutputFromUniqueName(
                                        const OP_ConnectorId& id) const;

    // Returns the unique name of the input at index idx. Creates the input if
    // grow is set to true.
    void                 getUniqueInputName(OP_ConnectorId& id_out,
                                            OP_InputIdx idx, bool grow);
    bool                 getUniqueInputNameConst(
                                OP_ConnectorId& id_out, OP_InputIdx idx) const;

    void                 getUniqueOutputName(OP_ConnectorId& id_out,
                                             OP_OutputIdx idx);
    bool                 getUniqueOutputNameConst(
                                OP_ConnectorId& id_out, OP_OutputIdx idx) const;

    /// New input functions that use names instead of indices.
    virtual OP_ERROR     setNamedInput(const OP_ConnectorId& input_name,
                                OP_Node *op,
                                const OP_ConnectorId* output_name = nullptr);

    virtual OP_ERROR     setNamedIndirectInput(
                                const OP_ConnectorId& input_name,
                                OP_IndirectInput *input);
    virtual OP_ERROR     setNamedInputReference(
                                const OP_ConnectorId& input_name, 
                                const char *label, int,
                                const OP_ConnectorId* output_name = nullptr);

    OP_ERROR             insertNamedInput(
                                const OP_ConnectorId& input_name, OP_Node *op,
                                const OP_ConnectorId*  output_name);
    OP_ERROR             insertNamedIndirectInput(
                                const OP_ConnectorId& input_name,
                                OP_IndirectInput *input);

    /// Returns input for the spare parm input.
    virtual OP_Input    *getParmInput(OP_OutputIdx idx) const
                         { return nullptr; }

    /// Overriden in VOPs.
    virtual void         onCreated() { }

    virtual bool         isOrderedInput(const OP_ConnectorId& input_name) const;

    /// Returns the name of the first connection from node "who" to this node,
    /// or an empty string if "who" is not an input.
    OP_ConnectorId       whichNamedInputIs(const OP_Node *who) const;

    /// Returns the index of the first connection of an indirect input.
    OP_ConnectorId       whichNamedInputIs(const OP_IndirectInput *who) const;
    virtual bool         willAutoconvertNamedInputType(
                                const OP_ConnectorId& input_name);

    /// Note: Use these carefully, since they assume that no inputs are actually 
    /// added or removed (or renamed) during the traversal.
    OP_ConnectorInputIter traverseInputs(OP_ConnectorInputIter* prev_iter);
    OP_ConnectorInputIter traverseConnectedInputs(OP_ConnectorInputIter* prev_iter);
    OP_ConnectorInputIter getTraverseEndIterator();

    unsigned             getInputsArraySize()
                         { return myInputs.entries(); }
    /// Deprecated in favour of getInputsArraySize()
    SYS_DEPRECATED(17.0) unsigned isInput(unsigned idx)
                         { return (getInputsArraySize() > idx) ? 1 : 0; }

    /// Retrieve a sorted list of local variables visible to this OP_Node.
    void                 getLocalVarNames(UT_StringArray &out_vars);

    // Forcibly enable evaluation of local variables outside of cooking code
    // paths so that the last cooked value can be used for things like
    // pivot values for handles. 
    bool                 setLocalVarActive(bool f)
                         {
                            bool old = myLocalVarActive;
                            myLocalVarActive = f;
                            return old;
                         }

    /// Get the myLocalVarActive flag
    bool                 isLocalVarActive() const
                         { return myLocalVarActive; }

    /// Return a UT_AttributeEvaluator for dealing with the evaluation of
    /// local variables designated by an "@" prefix.
    virtual UT_AttributeEvaluator *createAttributeEvaluator(const char *name);
    virtual void getAttributeEvaluatorNames(UT_StringArray &names);

    void                 recomputeCompiledHash();

    /// Clears the compiled hash (needed when switching from a compiled library
    /// definition to one that is not compiled).
    void                 clearCompiledHash()
                         { myCompHash = DEFAULT_COMP_HASH_VALUE; }

    /// You should use opChanged() instead. This is only for very special
    /// cases. If you don't know you are a special case, you aren't.
    void                 directSendEvent(OP_EventType type, void *data=nullptr)
                         { sendEvent(type, data); }

    virtual bool         scopedChannelsDirty();

    /// This mechanism allows users to evaluate active layer contribution
    /// without needing to link against CHOP.
    virtual bool         getActiveLayerContribution(const UT_String &track_name,
                                fpreal t, fpreal &value, fpreal &weight)
                         { return false; }

    /// Try to resolve exports on CHOP Channel Nodes from a value parameter
    /// within the array.
    virtual bool         resolveExport(const PRM_Parm* p, int subindex,
                                CH_ChannelRef& out_export )
                         { return false; }

    /// Creates or moves an existing visualizer in this network to
    /// this nodes output.
    virtual bool         addOrMoveVisualizerToOutput(int outputidx)
                         { return false; }

    const PRM_Parm      *traverseRef(
                            int *sub_idx,
                            fpreal time,
                            int parm_idx,
                            int vec_idx) const override;

    OP_Bundle *          getParmBundle(const char* parm_name, int vector_index,
                                UT_String &pattern, OP_Network *creator,
                                const char *filter, bool subnet_inclusion);

    /// For node types with no other default color override, this is the
    /// final fallback default color for all nodes.
    static const UT_Color &getGlobalDefaultColor();

    /// The following methods are to be used to implement getW() and getH() in
    /// sub-classes.  They are in absolute, pan-and-scale independent UI units.

    /// Get the width of flags.
    static fpreal        getFlagWidth();
    /// Get the default node height.
    static fpreal        getNodeHeight();
    /// Get the default width of the "node button" (the part of the node 
    /// that you can drag and click on that isn't flags).
    static fpreal        getNodeButtonWidth();
    /// Get the default connector height.
    static fpreal        getConnectorHeight();

    /// Returns true if we are allowed to destroy the specified nodes. If
    /// nodes is non-null, we test those nodes. If nodes is null, we test
    /// the picked nodes of the src_net. The return value assumes that all
    /// specified nodes will be destroyed, which is important because it
    /// may be safe to delete node A iff node B is also going to be deleted.
    static bool          canDestroyNodes(OP_Network *src_net,
                                         const OP_NodeList *nodes);

    /// Add an error to the given error manager, collapsing chains
    /// of invalid sources.
    static void          addInputNodeErrorToManager(UT_ErrorManager *error,
                                OP_Node *src);

    /// Must be implemented to associate this node to a viewer state.
    /// @parm default_state_name should be set with the viewer state type name.
    /// OP_Node implementation first looks for a 'viewerstate' node string 
    /// parameter. The parameter can be added as a spare parameter to any node.
    /// If the node is an HDA it can define a default state section.
    /// Otherwise, the operator name is returned as a default state name.
    virtual void         getDefaultState(UT_String &default_state_name);

    // If this node sets a context option to a specific value, we can clear
    // this option dependency for this node (and its outputs), because we
    // know that changing this option value past this node won't affect the
    // cooking of our input nodes, even if they use this context option. One
    // exception to this is if this node sets the context option as a
    // function of the option value handed to it. This exception is dealt with
    // when transferring option dependencies from our inputs to this node.
    //
    // Another exception is when the context used to cook this node has a
    // non-default (i.e. set by a node) value for the option. Because our
    // context option change may get "popped" by a node higher up the chain,
    // we must assume that nodes above this "pop" node depend on this option
    // set by one of our outputs, so we need to recook when that node changes
    // option value (even though we overwrite it). This isn't a problem when
    // the option is set to a default value because dependencies on default
    // values are tracked by micro nodes, so changing the default will force
    // a recook from the top of the chain. Testing for this case is why we
    // need to be passed the context passed to this nodes cook method.
    void                 clearInputContextOptionDepIfSafe(
                                const UT_StringHolder &opt,
                                const OP_Context &context);

    // CHOP Transform Tracks
    virtual bool hasTransformTracks() const { return false; }
    virtual bool evaluateTransformTracks( OP_Context &context, OP_EvaluateTransformTracksArgs &args ) { return false; }
    virtual bool evaluateTransformTracksTargets( OP_Context &context, OP_NodeList &nodes, OP_Node *caller) { return false; }
 


    const UT_StringHolder &getOriginalOperatorName() const;
    void setOriginalOperatorName(const UT_StringHolder & optype);

    /// Get the op table name and the op name concatenated together to get a
    /// unique name.
    /// Returns full name with table, including namespace and version tags
    /// if there are any, eg "artistA::table/op::2.0"
    void getOriginalOperatorTableAndName(UT_WorkBuffer &name) const;
    void getOriginalOperatorTableAndName(UT_String &name) const;


protected:

             OP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
            ~OP_Node() override;

    /// Implement the method from PRM_ParmOwner
    void                 doGetFullPath(UT_WorkBuffer &str) const override;

    /// Retrieve a list of the local variables visible to this OP_Node.
    /// This list is unsorted and may contain duplicates.
    virtual void         buildLocalVarNames(UT_StringArray &out_vars);

    UT_StringHolder      evaluateDisableExpression(const PRM_Parm &prm,
                                const UT_StringRef &function) const override;

    /// Resolves any inputs for which the names were not found during
    /// actual loading.
    void                 resolveUnresolvedLoadedInputs();

    /// Called when loadNetwork finishes loading the whole parent network of
    /// this node.
    void                 finishedLoadingParentNetwork();

    void                 setNewParent( OP_Network *new_parent );

    static void          bumpNameSerialIndex();

    /// @{
    /// Methods to disallow node deletion during the execution of a script.
    void                 beginScriptBlockingDel()
                         { myScriptsBlockingDelCount += 1; }
    void                 endScriptBlockingDel()
                         { myScriptsBlockingDelCount -= 1; }
    /// @}

    void                 setLegacyConnectingInputIndex(OP_InputIdx index)
                         { myLegacyConnectingInputIndex = index; }

    // All external references must be removed by the time this function
    // returns!
    virtual void         clearAndDestroy();

    // invalidate any cached data
    virtual void         clearCache();

    void                 clearInterruptedImpl(bool allow_recook);

    // "cookMe" is where the actual work is done.
    // The error is returned (OP_ERR_NONE on success).
    virtual OP_ERROR     cookMe(OP_Context &context) = 0;

    // "bypassMe" is used to cook the op when the bypass flag is set. 
    // The copied_input parameter should be set to indicate which input was
    // copied. Use -1 if no input was copied.
    // The error is returned (OP_ERR_NONE on success).
    virtual OP_ERROR     bypassMe(OP_Context &context, int &copied_input) = 0;

    // The following two functions are called from evaluateAllParms() so that
    // subclasses may hook into it to do some work before and after evaluating
    // all the parameters.
    virtual void         doOverridePreCook()    { }
    virtual void         doOverridePostCook()   { }

    // These "serial" numbers are used for keeping track of how many sources
    // are accessing us. Only call getSourceCount() when locked inside
    // getCookLock()!
    int                  getSourceCount() const;
    virtual int          bumpSourceCount(int d);

    // This is what you should override to do your own OP specific cooking.
    // This should not be called other than from pubCookInputGroups.
    virtual OP_ERROR     cookInputGroups(OP_Context &context, int alone = 0);

    //  I/O methods
    virtual OP_ERROR     saveIntrinsic(std::ostream &os,
                                       const OP_SaveFlags &flags);
    virtual OP_ERROR     save(std::ostream &os, const OP_SaveFlags &flags,
                                const char *path_prefix = "",
                                const UT_StringHolder &name_override = UT_StringHolder());
    OP_ERROR             saveUserDataPacket(std::ostream &os,
                                const char *path_prefix,
                                const UT_StringHolder &node_name);

    bool                 loadIntrinsicParentUneditable(
                                UT_IStream &is,
                                const char *path = nullptr);
    bool                 loadIntrinsic(
                                UT_IStream &is,
                                const char *path = nullptr);
    virtual bool         loadPacket(UT_IStream &is, short class_id,
                                    short sig, const char *path=nullptr);
    virtual bool         loadPacket(UT_IStream &is, const char *token,
                                    const char *path=nullptr);
    virtual bool         load(UT_IStream &is,
                              const char *ext="",
                              const char *path = nullptr);

    // load only things that that an uneditable parent deems uneditable, e.g.
    // input/output connections.  This is so that it can be matched to the OTL
    // rather than the editable contents of a node.
    bool                 loadParentUneditable(UT_IStream &is,
                                              const char *ext="",
                                              const char *path = nullptr);

    // this called when the entire network is done loading
    virtual void         loadStart();
    virtual void         loadFinished();

    // Loads the OTL_CONTENTS_SECTION for our OTL definition, if it exists,
    // using the syncContents method.
    void                 loadContentsSection();

    // This is a dummy virtual that just exists to be overridden by
    // OP_Network. See that class for more description.
    virtual bool         syncContents(UT_IStream &is);

    /// Sets the flag idicating if the node is synced (matched) to the HDA.
    void                 setMatchesOTLDefinition(int matches);

    virtual const char  *getFileExtension(int binary) const = 0;
    virtual const char  *getDataFileExtension(int binary) const;

    /// This will set the time dependent flag based on parms, inputs and/or
    /// extra (non-graph) inputs. This can be overridden by subclasses to have
    /// more control over a node's time dependent flag by forcibly calling the
    /// bass class method with false for these parameters.
    /// 
    /// @param do_parms Controls whether this node should become time dependent
    ///                 if any of its own cooking parameters are time dependent.
    /// @param do_inputs Controls whether the node should become time dependent
    ///                  if any of its used inputs are time dependent
    /// @param do_extras Controls if this node should become time dependent if
    ///                  any of the "extra" inputs (see
    ///                  OP_Node::addExtraInput()) nodes are time dependent.
    ///                  These extra inputs typically nodes referenced by the
    ///                  expressions on this node's parameters.
    virtual void         checkTimeDependencies(int do_parms=1,
                                int do_inputs=1,
                                int do_extras=1);
    // This will gather context option dependencies based on parms,
    // inputs and extra (non-graph) inputs. These dependencies are
    // applied to the data micro node and the node itself.
    virtual void         checkContextOptionDependencies(int do_parms);

    // To allow our sub-classes to send events, we make this protected.
    void                 sendEvent(OP_EventType type, void *data=nullptr);

    // haveSeenDataModification() can be used by sub-classes to decide if they
    // need to respond to a particular modification notice.
    int                  haveSeenDataModification(exint modification_id);

    // If you sub-class propagateModification, then be sure to call this
    // OP_Node base class method *last*.
    //
    // This routine will return TRUE if the modification is a new one for this
    // node.  FALSE will be returned if the modification has been seen before.
    //
    // Note that "by_whom" is the immediate input node that caused the
    // propagation to "this" node.
    virtual int          propagateModification(OP_Node *by_whom,
                                               OP_EventType reason,
                                               int parm_index,
                                               OP_PropagateData &prop_data);

    // Use this to obtain the cook cache.
    // @pre The caller has locked myCookLock if it is currently being cooked.
    OP_Cache *           getCookCache() { return &myCache; }

    static void          cmd_locate(CMD_Args &);

    virtual void         saveFlagsForUndo();
    void                 saveForUndoLayout();

    static void          saveForUndoDelete(OP_NodeList &nodes);

    /// Clears all cook dependencies (i.e., items that may cause it to cook)
    void                 clearDependency();

    /// This function will dirty our data if the given time is different from
    /// our last cooked time.
    ///
    /// This function is normally called from cook() but subclasses can prevent
    /// this with flags().setClearDependency(false). In that case, subclasses
    /// are responsible for calling this function at the appropriate time. This
    /// is primarily for nodes which cache their data across time. In that
    /// case, if they did _not_ reuse their cached data, then
    /// dirtyForTimeChange() needs to be called.
    ///
    /// @returns true if node was dirtied, false otherwise.
    bool                dirtyForTimeChange(fpreal t)
                        {
                            if (isCookedTime(t))
                                return false;

                            OP_DataMicroNode &dm = dataMicroNode();
                            OP_DataMicroNode &pm = parmListMicroNode();
                            dm.setDirty(true);
                            if (&dm != &pm && pm.isTimeDependent())
                                pm.setDirty(true);

                            return true;
                        }

    // clone dependencies from the proxy. proxy is no longer valid
    // after the clone!
    virtual void         cloneFromProxyRefNode( OP_Network *proxy );
    // clone a new proxy node. this node is no longer valid after this!
    virtual OP_Network * cloneToProxyRefNode();
    void                 stealDependents( OP_Node *other );

    bool                 hasOpDependents()
                            { return !myOpDependents.isEmpty(); }
    virtual int          hasProxyRefNodes() const
                            { return 0; }
    virtual void         moveProxyRefNodes( OP_Network * /*dest */ ) { }
    void                 clearOpReferences();
    virtual void         rebuildOpDependents( bool proxy_only );

    /// removeOpDependent() returns the number of dependents removed
    virtual int          removeOpDependent(
                            int op_id, const PRM_RefId &ref_id,
                            OP_InterestType mask = OP_INTEREST_ALL );
    virtual int          removeOpDependent(
                            int op_id, OP_InterestType mask = OP_INTEREST_ALL );

    // new method for dependencies: use the PRM_TYPE_OP_REF_*
    //  in your parm template to add your dependency.
    // override this to do special cases, make sure you call the base class
    // first before adding your own dependencies!
    void                 buildOpDependencies() override;
    void                 checkChannelDependencies(
                            CH_Channel *ch,
                            CH_CHANGE_TYPE reason) override;

    void                 notifyOpDependents( OP_InterestType interest,
                                             bool recurse );
    virtual void         moveDependencies( OP_Node *from_node );
    // Two functions for notifying dependent nodes of name changes. The
    // non-virtual function is the one that should be called to do the
    // update. It calls the virtual function to do the actual updating,
    // and generate a list of dependent nodes that were changed. Then it
    // forces a recook on the changed nodes.
    void                 notifyRenameDependents( const UT_String &full_from );
    virtual void         notifyRenameDependents( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    // Two functions for notifying referencing nodes of name changes. The
    // non-virtual function is the one that should be called to do the
    // update. It calls the virtual function to do the actual updating,
    // and generate a list of dependent nodes that were changed. Then it
    // forces a recook on the changed nodes.
    void                 notifyRenameReferences( const UT_String &full_from );
    virtual void         notifyRenameReferences( const UT_String &full_from,
                                                 OP_NodeList &cook_nodes );
    // this method is called to alert this op that its dependency has
    // changed. if it's a name interest, then the old full path is given
    virtual void         handleOpDependency( int referenced_op_id,
                                             const OP_Dependency &op_dep,
                                             OP_InterestType interest_type,
                                             bool &need_cook,
                                             const char *old_fullpath,
                                             const char *old_cwd,
                                             const char *old_chan_name );
    virtual void         buildParmDependency( int parm_index );

    void                 addOpNameReference(
                            const PRM_RefId &ref_id, const UT_String &op_path,
                            OP_InterestType type );
    // chan_name must be real channel name not an alias
    void                 addChannelNameReference(
                            const PRM_RefId &ref_id,
                            const UT_StringRef &op_path,
                            const UT_StringRef &chan_name,
                            OP_InterestType type );

    OP_Node             *getNodeOrCreateProxy(const UT_StringRef &op_path);

    void                 addOpReference( const PRM_RefId &ref_id, OP_Node *node,
                                         const PRM_RefId &source_ref_id,
                                         OP_InterestType type );

    void                 removeOpReference(
                            const PRM_RefId &ref_id,
                            OP_InterestType mask = OP_INTEREST_ALL );
    void                 removeOpReference(
                            const PRM_RefId &ref_id,
                            int op_id,
                            OP_InterestType mask = OP_INTEREST_ALL );

    /// This function takes the given parm string value containing an op path
    /// and does a search and replace given the old and new op paths.
    ///
    /// value_str           - the old parm value to modify
    /// new_fullpath        - the new path value to change to
    /// old_fullpath        - the old path that needs changing
    /// old_cwd     - the old path that the parm value was relative to
    /// new_cwd     - the new path that the parm value is to be relative to
    ///
    /// The reason for old_cwd & new_cwd is when collapsing a node into a
    /// subnet.  We need to figure out the new path references of the collapsed
    /// subnet since it has changed location. We match using the old_cwd but
    /// take the new path relative to new_cwd. Note that in this situation,
    /// old_fullpath is the same as new_fullpath.
    bool                 changeOpPathRef( UT_String &value_str,
                                          const char *new_fullpath,
                                          const char *old_fullpath,
                                          const char *old_cwd,
                                          const char *new_cwd );

    // handy functions for dealing with string parms that can have the
    // op:/path[frame] syntax
    static bool          getStringParmOpPath(
                                PRM_Parm &parm, int vi, UT_String &oppath,
                                int thread );
    void                 handleStringParmOpPathDependency(
                                int parm_index, int vi,
                                const char *new_fullpath,
                                const char *old_fullpath, const char *old_cwd );

    //  Only OP_Network should call notifyNodeDeletion()
    void                 notifyNodeDeletion();

    //  Only notifyNodeDeletion() should call nodeDeleted().
    //  nodeDeleted()           - gets called every time a node is deleted
    virtual void         nodeDeleted(OP_Node *op, int propagate=1);

    void                 startCookTimer(const OP_Context &context);
    void                 stopCookTimer(const OP_Context &context);

    virtual const char  *getCookTimerLabel(const OP_Context &context) const;

    // Overrides permission errors so that we don't have problems when cooking.
    void                 permissionError(const char *chname = nullptr) override;

    // Add an error for the invalid input given by input_idx
    void                 addInputError(OP_InputIdx input_idx);

    // Add an error for the given node having failed to load.
    void                 addInputNodeError(OP_Node *src);

protected:
    /// This function is currently only used by VOPs. It checks if an input 
    /// on the subnet is connected inside the subnet. The default implementation
    /// here simply returns false to preserve existing behaviour for all other
    /// contexts.
    virtual bool         isInputConnectedInsideSubnet(
                                OP_InputIdx input_idx) const;
    virtual bool         isNamedInputConnectedInsideSubnet(
                                const OP_ConnectorId& input_name) const;

    // notifier when this node is unlocked
    virtual void         nodeUnlocked() { ; }

    // These functions must be used with care!
    virtual void         setUniqueId(int id);
    void                 changeOpDependentUniqueId( int old_id, int new_id );
    void                 changeOpReferenceUniqueId( int old_id, int new_id );
    virtual void         clearUniqueId();

    void                 setAllowBuildDependencies( int yesno )
                            { myAllowBuildDependencies = yesno; }
    int                  allowBuildDependencies() const
                            { return myAllowBuildDependencies; }

    /// Evaluate all parameters for this operator. This is used for scripted
    /// Ops to make sure that our dependencies get set up properly.
    void                 evaluateAllParms(fpreal t);

    /// Override and assign any external (file) references to the reflist,
    /// and if nodelist is non-null, the full pathname of the node with the
    /// reference.
    virtual void         getMyExternalReferences(
                                UT_StringArray &reflist,
                                UT_StringArray *nodelist = nullptr,
                                bool collapse = false,
                                bool check_missing = false,
                                bool show_missing_only=false);

    void                 getExternalFiles(UT_StringArray &files,
                                          const char *stringparm,
                                          int framestart, int frameend,
                                          bool collapse,
                                          bool check_missing,
                                          bool show_only_missing,
                                          UT_KnownPath path);

    /// Rather than overloading the descriptive name, you can instead
    /// just provide a parameter name that will be evaluated to
    /// become the descriptive name.
    virtual void         getDescriptiveParmName(UT_String &str) const;

    /// Additional information that should be provided at the network
    /// level in addition to the name.
    /// By default will inspect the getDescriptiveParmName.
    virtual void         getDescriptiveName(UT_String &str) const;

    /// Marks our cached descriptive name as dirty.
    void                 dirtyDescriptiveNameCache();

    /// Return true if it is safe at this time to destroy this node.
    virtual bool         canDestroyNode();

    /// Override this to return true in an operator type that wants its
    /// cooked data to rely on all its parameter values but doesn't actually
    /// evaluate any parameters in its cook function (the prototypical
    /// example of this is SHOPs).
    virtual bool         cookedDataUsesAllParameters() const
                         { return false; }
    /// If the cook method relies on the base class cook to evaluate parameters
    /// (like in SHOPs), we need to trap the errors during this evaluation.
    virtual bool         cookedDataNeedsErrors() const
                         { return false; }
    /// If this node should be cooked for any output connected to it, return
    /// true here. Otherwise we only cook a node if something is connected to
    /// it's primary output. This does not let the node cook differently for
    /// each output, since the cook method doesn't know what output is being
    /// cooked for. So this should only be used if the cook is unaffected by
    /// the specific connected output.
    virtual bool         cookDataForAnyOutput() const
                         { return false; }

    // Returns true if we are running our creation script, or any parent
    // node of us is running its creation script.
    bool                 getIsRunningInCreateScript() const;

    /// This method is called whenever something in the network changes
    /// that may have an impact on the representative node this network may
    /// have.  It is used at this level to notify parents, and at the OBJ level
    /// to actually refresh the representative object.
    virtual void         refreshRepresentativeNode(OP_Node &changed_child);

    /// Sets up the inputs and outputs after all nodes have been loading 
    /// from file (in case it needs its children to determine inputs/oututs).
    virtual void         setupConnectorsAfterLoad();

    /// Converts opdef and oplib format paths from opdef:nodepath to
    /// opdef:tablename/optype.
    void                 convertOpdefToAbsolutePath(
                            UT_String &str) const override;

    bool                 isCookedTime(fpreal t) const
                         {
                            return dataMicroNodeConst()
                                .isEqualToLastUpdateTime(t);
                         }

    /// Subclasses should override this to dump extra micronodes that they own
    /// for debugging purposes.
    virtual void         dumpMicroNodes(
                            std::ostream &os,
                            bool as_DOT,
                            int indent_level) const;


    UT_TokenString                myHashCode;           // Generates a unique
    UT_TokenString                myParmHashCode;       // parameters & inputs.
    int                           myLastGroupMask;
    OP_VERSION                    myHashVersion;
    fpreal                        myHashTime;
    int                           myParmLastGroupMask;
    OP_VERSION                    myParmHashVersion;
    fpreal                        myParmHashTime;
    UT_String                     mySyncErrors;
    OP_ERROR                      mySyncErrorLevel;
    int                           mySyncDepth;

    /// Deletes an input completely if it is disconnected. If the input
    /// is connected, does nothing.
    void                 deleteInput(OP_InputIdx idx);
    void                 deleteInput(const OP_ConnectorId& input_name);

    /// Performs actual removal from the member input array.
    virtual void         doDeleteInput(OP_InputIdx idx);

    /// Update the error severity of this node.
    void                 updateErrorSeverity();

    /// Overriden in VOPs.
    virtual void         onInputAllocated(OP_Input* new_input,
                                          OP_InputIdx index) { }

    /// Debug method for checking connector consistency.
    void                 checkConnectorsConsistency();

    /// Use these to collect all inputs/outputs in cases where they will
    /// need to be modified.
    void                 gatherInputs(UT_Array<OP_InputPair> &input_pairs);
    void                 gatherOutputs(UT_Array<OP_OutputPair> &output_pairs);

    void                 renameInput(OP_Input* input, int new_id);

    void notifyChannelOpDependents(PRM_Parm * in_parm, int vecid);
    // Compiled hash code
    uint32               myCompHash;

private:

    void                 updateSpareParmTemplates(
                            PRM_Template *newtemplates,
                            bool leavedefaultsunchanged) override;

    bool                 doDebugConsistencyCheck();
    void                 createCollection( OP_Operator *entry );

    // these are extra private. only to be called from saveIntrinsic and save
    // respectively
    OP_ERROR             saveIntrinsicError();
    OP_ERROR             saveError();
    OP_ERROR             saveGroupMemberships(std::ostream &os,
                                              const OP_SaveFlags &flags,
                                              const char *path_prefix);
    bool                 loadGroupMemberships(UT_IStream &is,
                                              const char*path = nullptr);

    ///Make a note of which network box we're in
    OP_ERROR             saveNetworkBox(std::ostream &os,
                                        const OP_SaveFlags &flags,
                                        const char *path_prefix);

    ///Put ourselves into a network box if we saved ourselves as being in one
    bool                 loadNetworkBox(UT_IStream &is,
                                        const char *path = nullptr);

    bool                 loadNodeFlags(UT_IStream &is, const char *path);

    void                 saveForUndoComment();
    void                 saveForUndoDelScript();

    UT_BitArray         &getGroups()       { return myGroups; }
    const UT_BitArray   &getGroups() const { return myGroups; }
    // Only OP_Input should call setOutput() and delOutput() functions.
    bool                 setOutput(OP_NetworkBoxItem *item,
                                   OP_OutputIdx output_idx);
    bool                 delOutput(OP_NetworkBoxItem *item,
                                   OP_OutputIdx output_idx);
    bool                 setNamedOutput(OP_NetworkBoxItem *item,
                                const OP_ConnectorId& output_name);
    bool                 delNamedOutput(OP_NetworkBoxItem *item,
                                const OP_ConnectorId& output_name);
    OP_Output           *getOutput(OP_OutputIdx output_idx);
    const OP_Output     *getOutput(OP_OutputIdx output_idx) const;
    bool                 isOutputIdxValid(OP_OutputIdx output_idx) const;
    bool                 isOutputIdxWithinMax(OP_OutputIdx output_idx) const;

    void                 setInterrupted();

    int                  findAncestor(const OP_Node *node) const;
    int                  findDataAncestor(const OP_Node *node) const;
    void                 clearRecursionBit() const;

    void                 initializeExpressions() const;
    void                 clearInputs();
    void                 clearOutputs();

    PRM_ParmMicroNode   *createParmMicroNodes(PRM_Parm &parm) const override;

    static bool          getMicroNodesFromRef(
                            const OP_InterestRef &ref,
                            DEP_MicroNodeList &micronodes,
                            bool data_target);
    static void          traverseInputsAddInputs(
                            opNodeOutput &output,
                            UT_ValArray<opNodeOutput> &q,
                            UT_Set<opNodeOutput> &visited,
                            TraverseOptions opts,
                            OP_InterestType extra_interest_mask,
                            bool include_parmlist);

    // ref_chan_name must be the real channel name and not an alias
    int                  addOpDependent( int op_id, 
                                         const PRM_RefId &source_ref,
                                         const PRM_RefId &ref_id,
                                         OP_InterestType type );

    void                 updateRenameDependent( OP_Node *dependent,
                                                const char *old_cwd,
                                                OP_NodeList &cook_nodes );

    /// Trigger notifications when the given input has changed.
    /// If input has no value, then it notifies as if all inputs changed.
    void                 notifyInputOpDependents(OP_InputIdx input);

    void                 getExistingOpReferencesImpl(
                            OP_NodeList &refs, bool include_descendants) const;
    void                 getExistingOpDependentsImpl(
                            OP_NodeList &deps, bool include_descendants) const;

    void                 buildScriptOpDependencies();
    void                 changeScriptOpRef( const char *new_fullpath,
                                            const char *old_path,
                                            const char *old_cwd );
    static void          changeScriptCB( UT_String &str,
                                         const char *token_start,
                                         const char *&ch, void *userdata );

    // Go through and find all nodes which have time interest and requires
    // cooking.  If the update_cook flag is true, then we will call force
    // recook on the node as long as node != this. 'interests' if non-null,
    // stores the path of nodes that has time interest and will set the time
    // interest cook flag on those nodes.
    bool                 findTimeInterests(const OP_Context &context, OP_Node *node,
                                           bool update_cook,
                                           OP_NodeCycleDetect &cycle,
                                           OP_NodeList *interests = nullptr);

    /// Helper method for 'completePath()'
    bool                 attemptPrefixMatch(const OP_NetworkBoxItem *item, 
                                            char *childpref, int childpreflen, 
                                            UT_String &maxprefix) const;
        
    /// Helper for propagateModification()
    void                 findUsedDataInterests(OP_NodeList &nodes, OP_Node *op);

    /// Helper function for the setGlobal*Param functions. This function
    /// interprets the return value from CH_Manager::setGlobal*Param.
    bool                 internalSetGlobalParam(const char *param,
                                                int setreturned,
                                                bool *warned);

    bool                 internalSetPicked(bool on_off,
                                           bool propagate_parent_event,
                                           bool edit);

    OP_ERROR             internalCookInput(OP_Context &context,
                                           OP_InputIdx input_idx,
                                           OP_Node &input_node);

    virtual void         removeInputFromMapping(OP_InputIdx idx);
    void                 removeOutputFromMapping(OP_OutputIdx idx);

    void                 generateConnectorUniqueId(OP_ConnectorId& id_out);
    OP_Output           *getOrCreateOutput(OP_OutputIdx array_index, bool create,
                                int id_to_use);

    uint32               computeCompiledHash() const;

    // Adds a warning to the current error manager if this node has been
    // marked as deprecated.
    void                 addDeprecationWarningsIfAny();

    // Find an unused connectorId to assign to the next input/output
    int                  getConnectorNextId() const;

    bool                 computeCompiledStatus() const;

    bool                 isOperatorThreadSafe() const;

    void                 internalSyncDelayedOTL();

public:
    /// SOP, OBJ, and SOP Solver DOP nodes can be a selection owner,
    /// but other nodes cannot.
    /// This replaces the previous inheritance from SOP_SelectionOwner.
    virtual bool isSelectionOwnerType() const
    { return false; }

    /// Add many extra inputs in one call. See addExtraInput
    void addExtraInputs(const UT_Array<OP_InterestRef> &source_refs);
    void addExtraInputs(const DEP_MicroNodeList &deps);

    static void          addExtraInputs(
                            const UT_Array<OP_InterestRef> &target_refs,
                            const UT_Array<OP_InterestRef> &source_refs);

    /// Optimized version of addExtraInput that doesn't create OP_InterestRef
    static void addExtraInput(OP_Node &source, int source_pi, int source_vi, 
                              OP_Node &target, int target_pi, int target_vi
    );

    static bool          getMicroNodesFromRef(
                            OP_Node *op, OP_InterestType type,
                            DEP_MicroNodeList &micronodes, bool data_target);

    static bool          getMicroNodesFromRef(
                            OP_Node &op, int parm_i, int vec_i,
                            DEP_MicroNodeList &micronodes);

    void         addExtraInput(OP_Node *op, OP_InterestType type, DEP_MicroNodeList &sources_cache);

    /// Optimized version of addExtraInput that doesn't create OP_InterestRef
    static void addExtraInput(OP_Node &source, PRM_Parm &source_parm, int source_vi, 
                              OP_Node &target, PRM_Parm &target_parm, int target_vi
    );

    void         addExtraInputs(const UT_Array<OP_Node*> &nodes, OP_InterestType type, DEP_MicroNodeList &sources_cache);

    virtual bool isUsingCurrentFrameForVexTransformContext() const {return true;}
private:
    OP_Cache                     myCache;

    OP_ERROR                     myLastErrorSeverity;
    exint                        myLastErrorVersion;
    OP_Network                  *myParent;
    OP_Network                  *myRootCompiledParent;
    UT_ValArray<OP_Input *>      myInputs;
    // This is a map of names to inputs. 
    OP_ConnectorInputMap         myInputsMap;
    mutable UT_BitArray          myUsedInputs;
    using OutputPtr = UT_UniquePtr<OP_Output>;
    UT_SmallArray<OutputPtr, 1 * sizeof(OutputPtr)>
                                 myOutputs;
    UT_SmallArray<OutputPtr, 1 * sizeof(OutputPtr)>
                                 mySpareOutputs;
    /// Map from names to outputs, including spare outputs.
    OP_ConnectorOutputMap        myOutputsMap;

    // Default data micro node.
    OP_DataMicroNode             myDataMicroNode;
    DEP_MicroNode                myFlagMicroNode;
    UT_Map<char, DEP_MicroNode>  myIndividualFlagMicroNodes;
    UT_StringArray               myClearInputContextOptionDeps;

    // Event micronodes for OP events
    using MicroNodePtr = UT_UniquePtr<DEP_MicroNode>;
    using EventMicroNodesPtr = UT_UniquePtr<MicroNodePtr[]>;
    EventMicroNodesPtr           myEventMicroNodes;

    UT_String                    myComment;
    UT_String                    myDelScript;
    UT_String                    myCreatorState;
    UT_BitArray                  myGroups;
    OP_Value                     myEventValue;
    fpreal                       myPosX;
    fpreal                       myPosY;
    exint                        myCookCount;
    exint                        myCacheMisses = 0;
    SYS_AtomicInt32              mySourceCount;
    int                          myBlockModify;
    int                          myScriptsBlockingDelCount;
    int                          myUniqueId;
    int                          myNextIdOverride;
    unsigned                     myActiveInputIndex;
    // Indicates which input is currently being connected,
    // -1 if none.
    OP_InputIdx                  myLegacyConnectingInputIndex;

    bool                         myAutoscope;

    fpreal                       myCookDuration;        // time spent cooking
    unsigned int                 myRenameConflict               : 1,
                                 myCookedForRender              : 1,
                                 myModifyWaiting                : 1,
                                 myBuiltExplicitly              : 1,
                                 myAllowBuildDependencies       : 1,
                                 myBeingDeleted                 : 1,
                                 myRunningCreateScript          : 1,
                                 myRunningDelScript             : 1,
                                 myAlreadyRunDelScript          : 1,
                                 myMatchesOTLDefinition         : 1,
                                 myLoadCookedDataError          : 1,
                                 myBuiltHashCode                : 1,
                                 myIsProxyRefNode               : 1,
                                 myInhibitInputConsolidation    : 1,
    // Tracks if we have engaged our local variables, true from the
    // SOP_Node::setupLocalVars() until the SOP_Node::resetLocalVarRefs().  Any
    // attempt to evaluate local vars outside of here will redflag. This
    // flag is here instead of SOP_Node so that PI_OpHandleLink has access
    // to temporarily enable it.
                                 myLocalVarActive               : 1,
                                 myDelaySyncOTL                 : 1,
                                 mySyncingDelayedOTL            : 1;

    mutable bool                 myRecursionFlag;

    // Tracks the nesting level of the modification propagation chains
    static int                   thePropagateLevel;

    // ops that we have a reference to
    OP_ReferenceList             myOpReferences;
    // ops that depend on us
    OP_DependencyList            myOpDependents;

    // bundles that we have a reference to
    OP_BundleReferences          myBundleRefs;

    // Locking for cooking and adding extra inputs
    mutable OP_CookLock          myCookLock;

    // Arbitrary string data that users can attach to nodes that gets saved 
    // with the hip file.
    UT_Options                   myUserData;
    // Cached value for the node shape.
    UT_StringHolder              myNodeShape;
    
    // Arbitrary blind data that users can attach to nodes. These do not get
    // saved with the hip file.
    UT_StringMap<UT_SharedPtr<void> > myBlindData;

    // Arbitrary data blocks that, unlike blind data, are saved with the node.
    // This obviously implies the data must be self contained (no pointers).
    UT_StringMap<OP_DataBlockPtr> myDataBlocks;

    // Arbitrary data (in the form of Python objects) the users can attach to
    // nodes that does not get saved with the hip file.
    OP_PythonObjectCache         myCachedPythonObjects;

    // During load, not all of our input names are known. This stores
    // unresolved input names until OP_Node::loadFinished() is called,
    // where they are resolved.
    UT_Array<OP_UnresolvedConnection *> *myUnresolvedInputs;

    OP_NodeFlags                 myFlags;

    /// Cached evaluation of the node's descriptive name.
    UT_StringHolder              myCachedDescriptiveName;
    bool                         myCachedDescriptiveNameDirty;

    /// Only used during loading. Set to false initially, it is set to true
    /// once we load inputsNamed intrinsic section. If we do, the regular
    /// inputs section will then be ignored.
    bool                         myLoadedNamedInputs;

    /// Used for caching the compiled status of the node. Initially undefined,
    /// gets set on first isCompiled() call.
    mutable OP_CompileStatusType myCachedCompileStatus;

    OP_ERROR                     myChildErrorSeverity;
    int                          myChildErrorSeverityTimestamp;

    UT_StringHolder              myOverriddenOperatorName;


    // Maintenance of node id's
    static int                   makeUniqueId(OP_Node *node);

    static bool                 *theCheckConnectionConsistency;
    static int                   theUniqueId;
    static int                   theUniqueSize;
    static OP_Node             **theUniqueNodes;
    static bool                  theDoingBulkNotification;
    static OP_Node              *theBulkNotificationCaller;

    friend class                 OP_Channels;
    friend class                 OP_DataMicroNode;
    friend class                 OP_EventMicroNode;
    friend class                 OP_Group;
    friend class                 OP_IndirectInput;
    friend class                 OP_Input;
    friend class                 OP_Network;
    friend class                 OP_OperatorTable;
    friend class                 OP_ParmMicroNode;
    friend class                 OP_UndoCreate;
    friend class                 OP_UndoDelete;
    friend class                 OP_UndoInput;
    friend class                 OP_UndoSpareParm;
    friend class                 OP_UndoUserData;

    friend class                 op_MicroNodeDirtied;
    friend class                 MOT_RemoteExecMessage;
};

// helper function
// should always return a valid pointer
OP_API OP_Node * OPgetNodeFromChannel( const CH_Channel *chp );

// Link a Node to a Channel for SOP Channels
OP_API void OPlinkNodeToChannel( const OP_Node *node, const CH_Channel *chp );
OP_API void OPclearNodeToChannelLinks();

// Replaces CH_Manager::getUniqueCollections() as it needs access to OP.
OP_API void OPgetUniqueCollections( 
    const CH_ChannelList &channels, 
    CH_CollectionList &collections );

// UTformat support.
static inline size_t
UTformatBuffer(char *buffer, size_t buffer_size, const OP_Node &v)
{
    UT_StringHolder s = v.getFullPath();
    if (!buffer)
        return s.length();
    else
    {
        size_t len = std::min(size_t(s.length()), buffer_size);
        ::memcpy(buffer, s.c_str(), len);
        return len;
    }
}

class OP_API OP_DisablePropagateAssertScope
{
public:
    OP_DisablePropagateAssertScope();
    ~OP_DisablePropagateAssertScope();
};

#define CAST_INSTANTIATE(PREFIX)                                        \
inline static PREFIX##_Node *CAST_##PREFIX##NODE(OP_Node *op)           \
{                                                                       \
    return ((op) ? (op)->castTo##PREFIX##Node() : 0);                   \
}                                                                       \
                                                                        \
inline static const PREFIX##_Node *CAST_##PREFIX##NODE(const OP_Node *op) \
{                                                                       \
    return ((op) ? (op)->castTo##PREFIX##Node() : 0);                   \
}                                                                       \

/// @anchor OP_Node_CAST_FOONODE
/// These convenience functions let you do the cast without worrying if the
/// underlying pointer is null or not. They aren't macros because this way we
/// avoid double evaluating the op.
///     CAST_OBJNODE()
///     CAST_SOPNODE()
///     CAST_CHOPNETNODE()
///     CAST_CHOPNODE()
///     CAST_ROPNODE()
///     CAST_SHOPNODE()
///     CAST_COPNODE()
///     CAST_COP2NODE()
///     CAST_COP2NETNODE()
///     CAST_VOPNODE()
///     CAST_VOPNETNODE()
///     CAST_DOPNODE()
///     CAST_TOPNODE()
///     CAST_TOPNETNODE()
///     CAST_LOPNODE()
//@{
INSTANTIATE_FOR_ALL_NODE_TYPES(CAST_INSTANTIATE)
//@}

#undef CAST_INSTANTIATE

// We don't want anyone to conflict with this..
#undef INSTANTIATE_FINDNODE_FUNCTIONS
#undef INSTANTIATE_CASTNODE_FUNCTIONS
#undef INSTANTIATE_FOR_ALL_NODE_TYPES

//___________________________________________________________________________

/// Simple class that makes it easy to write loops that iterate over all the
/// outputs from a node. The parameters are passed on to getOutputNodes.
class OP_API OP_OutputIterator : private UT_SmallArray<OP_Node*>
{
    using Parent = UT_SmallArray<OP_Node*>;

public:
    OP_OutputIterator(
            const OP_Node &node,
            bool into_subnets = false,
            bool through_dots = true,
            OP_OutputIdx output_idx = -1)
    {
        node.getOutputNodes(*this, into_subnets, through_dots, output_idx);
    }
    struct IncludeSpareTag {};
    OP_OutputIterator(
            IncludeSpareTag,
            const OP_Node &node,
            bool into_subnets = false,
            bool through_dots = true,
            UT_Optional<OP_OutputIdx> output_idx = UT_NULLOPT)
    {
        node.getOutputNodesIncludeSpare(*this, into_subnets, through_dots,
                                        output_idx);
    }

     using Parent::begin;
     using Parent::end;

     using Parent::rbegin;
     using Parent::rend;

     using Parent::operator();
     using Parent::entries;
     using Parent::size;

     using Parent::sort;
};

/// Same as OP_OutputIterator, but with the iterators all swapped around so a
/// range loop will go backwards (without having to mess with reverse adaptors)
class OP_API OP_OutputReversedIterator : private UT_SmallArray<OP_Node*>
{
    using Parent = UT_SmallArray<OP_Node*>;

public:
    OP_OutputReversedIterator(
            const OP_Node &node,
            bool into_subnets = false,
            bool through_dots = true,
            OP_OutputIdx output_idx = -1)
    {
        node.getOutputNodes(*this, into_subnets, through_dots, output_idx);
    }
    struct IncludeSpareTag {};
    OP_OutputReversedIterator(
            IncludeSpareTag,
            const OP_Node &node,
            bool into_subnets = false,
            bool through_dots = true,
            UT_Optional<OP_OutputIdx> output_idx = UT_NULLOPT)
    {
        node.getOutputNodesIncludeSpare(*this, into_subnets, through_dots,
                                        output_idx);
    }

     const_reverse_iterator     begin() const   { return Parent::rbegin(); }
     const_reverse_iterator     end() const     { return Parent::rend(); }
     reverse_iterator           begin()         { return Parent::rbegin(); }
     reverse_iterator           end()           { return Parent::rend(); }

     const_iterator             rbegin() const  { return Parent::begin(); }
     const_iterator             rend() const    { return Parent::end(); }
     iterator                   rbegin()        { return Parent::begin(); }
     iterator                   rend()          { return Parent::end(); }

     using Parent::operator();
     using Parent::entries;
     using Parent::size;

     using Parent::sort;
};

/// Safe reference to an OP node
class OP_API OP_NodeId
{
public:
           OP_NodeId() { myId = OP_INVALID_NODE_ID; }
           OP_NodeId(const OP_Node *node) { *this = node; }
           OP_NodeId(const OP_NodeId &id) { myId = id.myId; }

    bool           isValid() const
                   { return (OP_Node::lookupNode(myId) != nullptr); }
                     
    OP_Node       *ptr()       { return OP_Node::lookupNode(myId); }
    const OP_Node *ptr() const { return OP_Node::lookupNode(myId); }

    void            clear() { myId = OP_INVALID_NODE_ID; }

    void operator=(const OP_Node *node)
         { myId = node ? node->getUniqueId() : OP_INVALID_NODE_ID; }

    bool operator==(const OP_Node *node) const
         {
             const int id = node ? node->getUniqueId() : OP_INVALID_NODE_ID;
             return id == myId;
         }
    bool operator!=(const OP_Node *node) const
         {
             const int id = node ? node->getUniqueId() : OP_INVALID_NODE_ID;
             return id != myId;
         }
    void setId(int id) { myId = id; }
private:
    int myId;
};

#endif