HOM_Defines.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __HOM_Defines_h__
#define __HOM_Defines_h__

#include <UT/UT_Assert.h>

// Unfortunately, we can't compare against UT_ASSERT_LEVEL_PARANOID here,
// otherwise the comparison sometimes succeeds under swig when it shouldn't.
// So, we instead compare against the numeric value itself.
#if UT_ASSERT_LEVEL >= 2
#define HOM_DEBUG
#endif

#ifdef SWIG
#define SWIGOUT(x) x
#else
#define SWIGOUT(x)
#endif

#if defined(SWIG) && defined(SWIGPYTHON)
#define SWIGPYTHONOUT(x) x
#else
#define SWIGPYTHONOUT(x)
#endif

// Define a synonym for hboost::any to customize a typemap for arguments that
// are to hold values to be inserted into a UT_Options object.  SWIG allows
// typemaps to be defined for each typename independently.
#include <hboost/any.hpp>
typedef hboost::any HOM_UTOptionAny;

// Define a synonym for hboost::any to customize a typemap for arguments that
// are to return drag-n-drop source data.  SWIG allows typemaps to be defined
// for each typename independently.
typedef hboost::any HOM_DDSourceAny;

#include <UT/UT_Optional.h>
typedef UT_Optional<double> HOM_OptionalDouble;
typedef UT_Optional<int> HOM_OptionalInt;

// The following define should go in SYS_Math.h when we are ready to
// add equivalent defines for MAX_DOUBLE, MAX_INT, MIN_INT etc.
#define HOM_MIN_NEGATIVE_DOUBLE -1 * std::numeric_limits<double>::max()

#ifdef SWIG

//----------------------------------------------------------------------------

// Since there's no way for a C++ function to have varying return types,
// we need to add special methods and functions that are only known
// to swig.  For python, there's a typemap for PyObject* so that when
// swig encounters a function returning that type it won't try to wrap
// the return value, and will instead send it directly to the interpreter.
// We create a typemap for this type so our code can use it instead of
// PyObject* directly so it's easier to use more than just python in the
// future.

// The swig code we output directly to the swig wrapper below (using %{%})
// uses InterpreterObject, so we need to say what it is.
%{
#ifdef SWIGPYTHON
typedef PyObject *InterpreterObject;

PyObject *HOMincRef(PyObject *object)
{
    if (!object)
        object = Py_None;
    Py_INCREF(object);
    return object;
}
#endif
%}

// We need to tell swig what InterpreterObject is so it applies the PyObject*
// typemap properly.
typedef PyObject *InterpreterObject;

//----------------------------------------------------------------------------

%{

#include <UT/UT_StdUtil.h>
#include <HOM/HOM_ErrorUtil.h>

// These helper functions convert from C++ objects to corresponding
// interpreter objects (PyObject*'s in python).  They're roughly the same
// as swig::from(), but swig::from() does a slow lookup on the name of the
// type.  These functions know the type at compile-time so they're faster.
// Unfortunately, we need to explicitly specialize all the types supported by
// the functions.  Specifically, since HOM_IterableList calls these functions,
// objects that can be inside HOM_IterableList need to be specialized below.

// The general case is left unimplemented so we get compiler errors if
// we call the function with an unspecialized type.
template <typename T> InterpreterObject
HOMconvertValueForInterpreter(const T &value, int own);

// These functions specialize the native data types.
template <> InterpreterObject
HOMconvertValueForInterpreter<int>(const int& value, int /*own*/)
{ return SWIG_From_int(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<float>(const float& value, int /*own*/)
{ return SWIG_From_float(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<double>(const double& value, int /*own*/)
{ return SWIG_From_double(value); }

template <> InterpreterObject
HOMconvertValueForInterpreter<std::string>(
    const std::string& value, int /*own*/)
{ return SWIG_From_std_string(value); }

// These functions specialize base classes to return interpreter instances
// of the proper subclass.
template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_Node*>(HOM_Node *const &node, int own)
{
    OP_OpTypeId          optypeid;
    HOM_NodeType        *nodetype = nullptr;
    HOM_OpNode          *opnode = dynamic_cast<HOM_OpNode* const>(node);
    HOM_ApexNode        *apexnode = dynamic_cast<HOM_ApexNode* const>(node);
    bool                 isnetwork = false;

    if (!node || (!opnode && !apexnode))
        return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_Node, own);

    if (apexnode)
        return SWIG_NewPointerObj(node, SWIGTYPE_p_HOM_ApexNode, own);

    optypeid = (OP_OpTypeId)opnode->opTypeIdAsInt();
    switch (optypeid)
    {
    case OBJ_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ObjNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
                (void*)dynamic_cast<HOM_ObjNode* const>(node),
                SWIGTYPE_p_HOM_ObjNode, own);

    case SOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_SopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_SopNode* const>(node),
            SWIGTYPE_p_HOM_SopNode, own);

    case CHOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ChopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_ChopNode* const>(node),
            SWIGTYPE_p_HOM_ChopNode, own);

    case COP2_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_Cop2Node so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_Cop2Node* const>(node),
            SWIGTYPE_p_HOM_Cop2Node, own);

    case COP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_CopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_CopNode* const>(node),
            SWIGTYPE_p_HOM_CopNode, own);

    case DOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_DopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_DopNode* const>(node),
            SWIGTYPE_p_HOM_DopNode, own);

    case SHOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_ShopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_ShopNode* const>(node),
            SWIGTYPE_p_HOM_ShopNode, own);

    case VOPNET_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_VopNetNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_VopNetNode* const>(node),
            SWIGTYPE_p_HOM_VopNetNode, own);

    case ROP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_RopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_RopNode* const>(node),
            SWIGTYPE_p_HOM_RopNode, own);

    case VOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_VopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_VopNode* const>(node),
            SWIGTYPE_p_HOM_VopNode, own);

    case TOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_TopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<HOM_TopNode* const>(node),
            SWIGTYPE_p_HOM_TopNode, own);

    case LOP_OPTYPE_ID:
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_LopNode so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        //
        // Special test for LOP Network management nodes, since LOP_Networks
        // have their own HOM data type.
        nodetype = node->type();
        isnetwork = (nodetype && nodetype->isManager(true));
        delete nodetype;
        if (isnetwork)
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<HOM_LopNetwork* const>(node),
                SWIGTYPE_p_HOM_LopNetwork, own);
        else
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<HOM_LopNode* const>(node),
                SWIGTYPE_p_HOM_LopNode, own);

    case DATA_OPTYPE_ID:
        // Data operator types have no subclass so fall through to the
        // generic HOM_Node.
        break;

    case MGR_OPTYPE_ID:
        // Special case for the /stage manager node, which is actually a
        // LOP_Network, and therefore a LOP_Node.
        if (HOM().lopNodeTypeCategory() == node->childTypeCategory())
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<HOM_LopNetwork* const>(node),
                SWIGTYPE_p_HOM_LopNetwork, own);

    default:
        break;
    };

    return SWIG_NewPointerObj(opnode, SWIGTYPE_p_HOM_OpNode, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NodeType*>(
    HOM_NodeType *const &nodetype, int own)
{
    OP_OpTypeId      optypeid;
    HOM_OpNodeType  *opnodetype = dynamic_cast<HOM_OpNodeType* const>(nodetype);
    HOM_ApexNodeType*apexnodetype = dynamic_cast<HOM_ApexNodeType* const>(nodetype);

    if (!nodetype || (!opnodetype && !apexnodetype))
        return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_NodeType, own);

    if (apexnodetype)
        return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_ApexNodeType, own);

    if( !nodetype->isManager() )
    {
        optypeid = (OP_OpTypeId)opnodetype->opTypeIdAsInt();
        switch (optypeid)
        {
        case SOP_OPTYPE_ID:
            // Because of multiple inheritance, it's extremely important that
            // we explicitly cast the pointer to a HOM_SopNodeType so we
            // pass the right address to SWIG_NewPointerObject, since it takes
            // a void*.
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_SopNodeType* const>(nodetype),
                SWIGTYPE_p_HOM_SopNodeType, own);

        case SHOP_OPTYPE_ID:
            // Because of multiple inheritance, it's extremely important that
            // we explicitly cast the pointer to a HOM_ShopNodeType so we
            // pass the right address to SWIG_NewPointerObject, since it takes
            // a void*.
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_ShopNodeType* const>(nodetype),
                SWIGTYPE_p_HOM_ShopNodeType, own);

        case VOP_OPTYPE_ID:
            // Because of multiple inheritance, it's extremely important that
            // we explicitly cast the pointer to a HOM_VopNodeType so we
            // pass the right address to SWIG_NewPointerObject, since it takes
            // a void*.
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_VopNodeType* const>(nodetype),
                SWIGTYPE_p_HOM_VopNodeType, own);
        default:
            break;
        }
    }

    return SWIG_NewPointerObj(nodetype, SWIGTYPE_p_HOM_OpNodeType, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NodeTypeCategory*>(
    HOM_NodeTypeCategory *const &nodetypecategory, int own)
{
    HOM_OpNodeTypeCategory *opnodetypecategory =
        dynamic_cast<HOM_OpNodeTypeCategory* const>(nodetypecategory);
    HOM_ApexNodeTypeCategory *apexnodetypecategory =
        dynamic_cast<HOM_ApexNodeTypeCategory* const>(nodetypecategory);

    if (!nodetypecategory || (!opnodetypecategory && !apexnodetypecategory))
        return SWIG_NewPointerObj(nodetypecategory,
            SWIGTYPE_p_HOM_NodeTypeCategory, own);

    if (apexnodetypecategory)
        return SWIG_NewPointerObj(nodetypecategory,
            SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);

    return SWIG_NewPointerObj(nodetypecategory,
        SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NodeTypeCategory&>(
    HOM_NodeTypeCategory &nodetypecategory, int own)
{
    HOM_OpNodeTypeCategory *opnodetypecategory =
        dynamic_cast<HOM_OpNodeTypeCategory* const>(&nodetypecategory);
    HOM_ApexNodeTypeCategory *apexnodetypecategory =
        dynamic_cast<HOM_ApexNodeTypeCategory* const>(&nodetypecategory);

    if (!opnodetypecategory && !apexnodetypecategory)
        return SWIG_NewPointerObj(&nodetypecategory,
            SWIGTYPE_p_HOM_NodeTypeCategory, own);

    if (apexnodetypecategory)
        return SWIG_NewPointerObj(&nodetypecategory,
            SWIGTYPE_p_HOM_ApexNodeTypeCategory, own);

    return SWIG_NewPointerObj(&nodetypecategory,
        SWIGTYPE_p_HOM_OpNodeTypeCategory, own);
}

namespace swig {
    template <>
    struct traits_from<HOM_NodeTypeCategory *>
    {
        static PyObject *from(HOM_NodeTypeCategory * const &val)
        {
            // Guard exceptions here that are normally for python. This is
            // similar to what we do with HOM_CONVERT_AND_CATCH code below
            PyObject *result;
            try
            {
                // HOM_NodeTypeCategory objects are always singletons, not
                // owned by python/SWIG.
                result = HOMconvertValueForInterpreter(val, 0);
            }
            catch (...)
            {
                // Unlike HOM_CONVERT_AND_CATCH, we can't raise a SWIG exception
                // here because it will be ignored anyways in the list
                // conversion code. Plus, we'll also run into an assertion
                // failure inside the Python interpreter if we do this:
                // (void)hom::raise_swig_exception();
                result = Py_None;
            }
            return result;
        }
    };
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NetworkBox*>(
    HOM_NetworkBox *const &obj, int own)
{
    HOM_OpNetworkBox  *opobj = dynamic_cast<HOM_OpNetworkBox* const>(obj);

    if (!obj || !opobj)
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkBox, own);

    return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkBox, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NetworkDot*>(
    HOM_NetworkDot *const &obj, int own)
{
    HOM_OpNetworkDot  *opobj = dynamic_cast<HOM_OpNetworkDot* const>(obj);

    if (!obj || !opobj)
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NetworkDot, own);

    return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNetworkDot, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NodeConnection*>(
    HOM_NodeConnection *const &obj, int own)
{
    HOM_OpNodeConnection   *opobj = dynamic_cast<HOM_OpNodeConnection* const>(obj);
    HOM_ApexNodeConnection *apexobj = dynamic_cast<HOM_ApexNodeConnection* const>(obj);

    if (!obj || (!opobj && !apexobj))
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_NodeConnection, own);

    if (apexobj)
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexNodeConnection, own);

    return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpNodeConnection, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_StickyNote*>(
    HOM_StickyNote *const &obj, int own)
{
    HOM_OpStickyNote *opobj = dynamic_cast<HOM_OpStickyNote* const>(obj);
    HOM_ApexStickyNote *apexobj = dynamic_cast<HOM_ApexStickyNote* const>(obj);

    if (!obj || (!opobj && !apexobj))
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_StickyNote, own);

    if (apexobj)
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_ApexStickyNote, own);

    return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpStickyNote, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_SubnetIndirectInput*>(
    HOM_SubnetIndirectInput *const &obj, int own)
{
    HOM_OpSubnetIndirectInput  *opobj = dynamic_cast<HOM_OpSubnetIndirectInput* const>(obj);

    if (!obj || !opobj)
        return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_SubnetIndirectInput, own);

    return SWIG_NewPointerObj(obj, SWIGTYPE_p_HOM_OpSubnetIndirectInput, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_BaseKeyframe*>(
    HOM_BaseKeyframe *const &keyframe, int own)
{
    if (!keyframe)
        return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);

    if (keyframe->evaluatedType() == HOM_parmData::Float)
    {
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_Keyframe so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Keyframe* const>(keyframe),
            SWIGTYPE_p_HOM_Keyframe, own);
    }
    else if (keyframe->evaluatedType() == HOM_parmData::String)
    {
        // Because of multiple inheritance, it's extremely important that
        // we explicitly cast the pointer to a HOM_Keyframe so we
        // pass the right address to SWIG_NewPointerObject, since it takes
        // a void*.
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_StringKeyframe* const>(keyframe),
            SWIGTYPE_p_HOM_StringKeyframe, own);
    }

    return SWIG_NewPointerObj(keyframe, SWIGTYPE_p_HOM_BaseKeyframe, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_PackedPrim*>(HOM_PackedPrim *const &prim, int own)
{
    if (!prim)
        return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_PackedPrim, own);

    // Because of multiple inheritance, it's extremely important that
    // we explicitly cast the pointer to the right HOM type so we
    // pass the right address to SWIG_NewPointerObject, since it takes
    // a void*.

    switch (prim->type().id())
    {
    case HOM_primType::Agent_Id:
        return SWIG_NewPointerObj(
            (void *)dynamic_cast<HOM_Agent *const>(prim),
            SWIGTYPE_p_HOM_Agent, own);

    case HOM_primType::PackedFragment_Id:
        return SWIG_NewPointerObj(
            (void *)dynamic_cast<HOM_PackedFragment *const>(prim),
            SWIGTYPE_p_HOM_PackedFragment, own);

    case HOM_primType::PackedGeometry_Id:
        return SWIG_NewPointerObj(
            (void *)dynamic_cast<HOM_PackedGeometry *const>(prim),
            SWIGTYPE_p_HOM_PackedGeometry, own);
    }

    // NOTE: No dynamic_cast needed here
    return SWIG_NewPointerObj((void *)prim, SWIGTYPE_p_HOM_PackedPrim, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_Prim*>(HOM_Prim *const &prim, int own)
{
    if (!prim)
        return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);

    // Because of multiple inheritance, it's extremely important that
    // we explicitly cast the pointer to the right HOM type so we
    // pass the right address to SWIG_NewPointerObject, since it takes
    // a void*.
    HOM_PackedPrim * packed = dynamic_cast<HOM_PackedPrim *>(prim);
    if(packed)
        return HOMconvertValueForInterpreter(packed, own);

    switch (prim->type().id())
    {
    case HOM_primType::Polygon_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Polygon* const>(prim),
            SWIGTYPE_p_HOM_Polygon, own);

    case HOM_primType::NURBSCurve_Id:
    case HOM_primType::BezierCurve_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Face* const>(prim),
            SWIGTYPE_p_HOM_Face, own);

    case HOM_primType::Mesh_Id:
    case HOM_primType::NURBSSurface_Id:
    case HOM_primType::BezierSurface_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Surface* const>(prim),
            SWIGTYPE_p_HOM_Surface, own);

    case HOM_primType::Circle_Id:
    case HOM_primType::Sphere_Id:
    case HOM_primType::Tube_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Quadric* const>(prim),
            SWIGTYPE_p_HOM_Quadric, own);

    case HOM_primType::Volume_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_Volume* const>(prim),
            SWIGTYPE_p_HOM_Volume, own);

    case HOM_primType::VDB_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_VDB* const>(prim),
            SWIGTYPE_p_HOM_VDB, own);

    case HOM_primType::ChannelPrim_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ChannelPrim* const>(prim),
            SWIGTYPE_p_HOM_ChannelPrim, own);

    // TODO: Support more primitive types.
    }

    return SWIG_NewPointerObj(prim, SWIGTYPE_p_HOM_Prim, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_ParmTemplate*>(
    HOM_ParmTemplate *const &parm_template, int own)
{
    if (!parm_template)
        return SWIG_NewPointerObj(
            parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);

    // Because of multiple inheritance, it's extremely important that we
    // explicitly cast to a pointer to the subclass so we pass the right
    // address to SWIG_NewPointerObject, since it takes a void*.
    switch (parm_template->type().id())
    {
    case HOM_parmTemplateType::Int_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_IntParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_IntParmTemplate, own);

    case HOM_parmTemplateType::Float_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FloatParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FloatParmTemplate, own);

    case HOM_parmTemplateType::String_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_StringParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_StringParmTemplate, own);

    case HOM_parmTemplateType::Data_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_DataParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_DataParmTemplate, own);

    case HOM_parmTemplateType::Toggle_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ToggleParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_ToggleParmTemplate, own);

    case HOM_parmTemplateType::Menu_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_MenuParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_MenuParmTemplate, own);

    case HOM_parmTemplateType::Button_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ButtonParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_ButtonParmTemplate, own);

    case HOM_parmTemplateType::Label_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_LabelParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_LabelParmTemplate, own);

    case HOM_parmTemplateType::Separator_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SeparatorParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_SeparatorParmTemplate, own);

    case HOM_parmTemplateType::FolderSet_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FolderSetParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FolderSetParmTemplate, own);

    case HOM_parmTemplateType::Folder_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_FolderParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_FolderParmTemplate, own);

    case HOM_parmTemplateType::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_RampParmTemplate* const>(
                parm_template),
            SWIGTYPE_p_HOM_RampParmTemplate, own);
    };

    UT_ASSERT(!"Unknown parm template type");
    return SWIG_NewPointerObj(parm_template, SWIGTYPE_p_HOM_ParmTemplate, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_PaneTab*>(
    HOM_PaneTab *const &pane_tab, int own)
{
    if (!pane_tab)
        return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);

    // Because of multiple inheritance, it's extremely important that
    // we explicitly cast the pointer to the HOM type so we pass the right
    // address to SWIG_NewPointerObject, since it takes a void*.

    switch (pane_tab->type().id())
    {
    case HOM_paneTabType::ContextViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ContextViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_ContextViewer, own);

    case HOM_paneTabType::SceneViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SceneViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_SceneViewer, own);

    case HOM_paneTabType::CompositorViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_CompositorViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_CompositorViewer, own);

    case HOM_paneTabType::NetworkEditor_Id:
    case HOM_paneTabType::ApexEditor_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_NetworkEditor* const>(pane_tab),
            SWIGTYPE_p_HOM_NetworkEditor, own);
            
    case HOM_paneTabType::HelpBrowser_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_HelpBrowser* const>(pane_tab),
            SWIGTYPE_p_HOM_HelpBrowser, own);

    case HOM_paneTabType::PythonPanel_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PythonPanel* const>(pane_tab),
            SWIGTYPE_p_HOM_PythonPanel, own);

    case HOM_paneTabType::IPRViewer_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_IPRViewer* const>(pane_tab),
            SWIGTYPE_p_HOM_IPRViewer, own);

    case HOM_paneTabType::AssetBrowser_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_AssetBrowser* const>(pane_tab),
            SWIGTYPE_p_HOM_AssetBrowser, own);

    case HOM_paneTabType::PerformanceMonitor_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PerformanceMonitor* const>(pane_tab),
            SWIGTYPE_p_HOM_PerformanceMonitor, own);

    case HOM_paneTabType::ChannelEditor_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ChannelEditorPane* const>(pane_tab),
            SWIGTYPE_p_HOM_ChannelEditorPane, own);

    case HOM_paneTabType::DataTree_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_DataTree* const>(pane_tab),
            SWIGTYPE_p_HOM_DataTree, own);

    case HOM_paneTabType::SceneGraphTree_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_SceneGraphTree* const>(pane_tab),
            SWIGTYPE_p_HOM_SceneGraphTree, own);

    case HOM_paneTabType::Parm_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_ParameterEditor* const>(pane_tab),
            SWIGTYPE_p_HOM_ParameterEditor, own);

    case HOM_paneTabType::DetailsView_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_GeometrySpreadsheet * const>(pane_tab),
            SWIGTYPE_p_HOM_GeometrySpreadsheet, own);

    case HOM_paneTabType::ChannelViewer_Id:
    case HOM_paneTabType::OutputViewer_Id:
    case HOM_paneTabType::ShaderViewer_Id:
    case HOM_paneTabType::TreeView_Id:
    case HOM_paneTabType::RenderGallery_Id:
        return SWIG_NewPointerObj(
            (void*)dynamic_cast<const HOM_PathBasedPaneTab* const>(pane_tab),
            SWIGTYPE_p_HOM_PathBasedPaneTab, own);

    case HOM_paneTabType::ChannelList_Id:
    case HOM_paneTabType::Textport_Id:
    case HOM_paneTabType::PythonShell_Id:
    case HOM_paneTabType::HandleList_Id:
    case HOM_paneTabType::BundleList_Id:
    case HOM_paneTabType::TakeList_Id:
    case HOM_paneTabType::ParmSpreadsheet_Id:
    case HOM_paneTabType::LightLinker_Id:
    case HOM_paneTabType::MaterialPalette_Id:
    case HOM_paneTabType::EngineSessionSync_Id:
        return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
    };

    UT_ASSERT(!"Unknown pane tab type");
    return SWIG_NewPointerObj(pane_tab, SWIGTYPE_p_HOM_PaneTab, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_SopVerb*>(
    HOM_SopVerb *const &verb, int own)
{
    return SWIG_NewPointerObj(verb, SWIGTYPE_p_HOM_SopVerb, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_Geometry*>(
    HOM_Geometry *const &geo, int own)
{
    return SWIG_NewPointerObj(geo, SWIGTYPE_p_HOM_Geometry, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NetworkItem*>(
    HOM_NetworkItem *const &item, int own)
{
    if (item)
    {
        // Defer to the type-specific implementations of
        // HOMconvertValueForInterpreter so we return the correct value
        // based on which subclass of the object we have.
        switch (item->networkItemType().id())
        {
        case HOM_networkItemType::Node_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_Node* const>(item), own);

        case HOM_networkItemType::NetworkBox_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_NetworkBox* const>(item), own);

        case HOM_networkItemType::StickyNote_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_StickyNote* const>(item), own);

        case HOM_networkItemType::SubnetIndirectInput_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_SubnetIndirectInput* const>(item), own);

        case HOM_networkItemType::Connection_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_NodeConnection* const>(item), own);

        case HOM_networkItemType::NetworkDot_Id:
            return HOMconvertValueForInterpreter(
                    dynamic_cast<HOM_NetworkDot* const>(item), own);

        default:
            break;
        };
    }

    return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkItem, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_NetworkMovableItem*>(
    HOM_NetworkMovableItem *const &item, int own)
{
    if (!item)
        return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_NetworkMovableItem, own);

    return HOMconvertValueForInterpreter<HOM_NetworkItem *>(item, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<
    std::vector<HOM_ElemPtr<HOM_NodeConnection> >*>(
        std::vector<HOM_ElemPtr<HOM_NodeConnection> > *const &list,
        int own)
{
    return swig::from(*list);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_DopData*>(HOM_DopData *const &data, int own)
{
    const HOM_DopObject *const dop_object =
        dynamic_cast<const HOM_DopObject *const>(data);
    if (dop_object)
        return SWIG_NewPointerObj(
            (void *)dop_object, SWIGTYPE_p_HOM_DopObject, own);

    const HOM_DopRelationship *const dop_relationship =
        dynamic_cast<const HOM_DopRelationship *const>(data);
    if (dop_relationship)
        return SWIG_NewPointerObj(
            (void *)dop_relationship, SWIGTYPE_p_HOM_DopRelationship, own);

    return SWIG_NewPointerObj(data, SWIGTYPE_p_HOM_DopData, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_RadialItem*>(
    HOM_RadialItem *const &item, int own)
{
    if (item)
    {
        switch (item->type().id())
        {
        case HOM_radialItemType::Script_Id:
            return SWIG_NewPointerObj(
                    (void*)dynamic_cast<const HOM_RadialScriptItem* const>(item),
                    SWIGTYPE_p_HOM_RadialScriptItem, own);

        case HOM_radialItemType::Submenu_Id:
            return SWIG_NewPointerObj(
                (void*)dynamic_cast<const HOM_RadialSubmenu* const>(item),
                SWIGTYPE_p_HOM_RadialSubmenu, own);

        default:
            break;
        };
    }

    return SWIG_NewPointerObj(item, SWIGTYPE_p_HOM_RadialItem, own);
}

template <> InterpreterObject
HOMconvertValueForInterpreter<HOM_EnumValue*>(
    HOM_EnumValue *const &item, int own)
{
    // We should NEVER heap allocate HOM_EnumValue because only return
    // static instances of them to SWIG.
    UT_ASSERT(!own);

    // NOTE: No dynamic_cast needed here
    return SWIG_NewPointerObj((void*)item, SWIGTYPE_p_HOM_EnumValue, /*own*/0);
}

// These functions specialize pointers to other classes.  If a class is
// used inside HOM_IterableList or HOM_ElemPtr, it must be listed here.
#define HOM_PROVIDE_SWIG_LOOKUP(type) \
    template <> InterpreterObject HOMconvertValueForInterpreter<type*>( \
        type* const& value, int own) \
    { \
        return SWIG_NewPointerObj(SWIG_as_voidptr(value), \
            SWIGTYPE_p_ ## type, own); \
    }

HOM_PROVIDE_SWIG_LOOKUP(HOM_AdvancedDrawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentClip)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentDefinition)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentLayer)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentShape)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentShapeBinding)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentShapeDeformer)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AgentTransformGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AnimBar)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AssetGalleryDataSource)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Attrib)
HOM_PROVIDE_SWIG_LOOKUP(HOM_AttribDataId)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Bookmark)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ChannelPrim)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ChannelGraphSelection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_clone_Connection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Color)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Desktop)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Dialog)
HOM_PROVIDE_SWIG_LOOKUP(HOM_DopRecord)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Drawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_FloatingPanel)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GadgetContext)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GadgetDrawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Gallery)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GalleryEntry)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometrySelection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometryViewport)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Handle)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometryDrawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_GeometryDrawableGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_HDADefinition)
HOM_PROVIDE_SWIG_LOOKUP(HOM_HDASection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ik_Joint)
HOM_PROVIDE_SWIG_LOOKUP(HOM_IndexPairPropertyTable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_logging_LogEntry)
HOM_PROVIDE_SWIG_LOOKUP(HOM_LopInstanceIdRule)
HOM_PROVIDE_SWIG_LOOKUP(HOM_LopSelectionRule)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix2)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix3)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Matrix4)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeBundle)
HOM_PROVIDE_SWIG_LOOKUP(HOM_NodeGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Pane)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Parm)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ParmTuple)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PluginHotkeyDefinitions)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Point)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Polygon)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PythonPanelInterface)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Edge)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PointGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_PrimGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_EdgeGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_VertexGroup)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Quaternion)
HOM_PROVIDE_SWIG_LOOKUP(HOM_RadialMenu)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Ramp)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Selection)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Selector)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Shelf)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ShelfSet)
HOM_PROVIDE_SWIG_LOOKUP(HOM_SimpleDrawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Take)
HOM_PROVIDE_SWIG_LOOKUP(HOM_TextDrawable)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Tool)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Track)
HOM_PROVIDE_SWIG_LOOKUP(HOM_UIEvent)
HOM_PROVIDE_SWIG_LOOKUP(HOM_UIEventDevice)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector2)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector3)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vector4)
HOM_PROVIDE_SWIG_LOOKUP(HOM_Vertex)
HOM_PROVIDE_SWIG_LOOKUP(HOM_VexContext)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerHandleContext)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerHandleTemplate)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerState)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerStateContext)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerStateMenu)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewerStateTemplate)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewportVisualizer)
HOM_PROVIDE_SWIG_LOOKUP(HOM_ViewportVisualizerType)

%}

//----------------------------------------------------------------------------

// We create typemaps for base classes that appear as return types to make
// sure swig instances the proper subclasses in the interpreter.

#define HOM_CONVERT_AND_CATCH \
    try \
    { \
        $result = HOMconvertValueForInterpreter($1, $owner); \
    } \
    catch (...) \
    { \
        (void)hom::raise_swig_exception(); \
        $result = nullptr; \
    } \
/**/

%typemap(out) HOM_Prim* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_PackedPrim* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_Node* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NodeType* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NodeTypeCategory* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NodeTypeCategory& {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NetworkBox* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NetworkDot* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_StickyNote* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_SubnetIndirectInput* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NodeConnection* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_BaseKeyframe* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_ParmTemplate* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_Pane* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_PaneTab* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_DopData* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_RadialItem* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NetworkMovableItem* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) HOM_NetworkItem* {
    HOM_CONVERT_AND_CATCH
}

%typemap(out) std::vector<HOM_ElemPtr<HOM_NodeConnection> > * {
    HOM_CONVERT_AND_CATCH
}

//----------------------------------------------------------------------------

// These typemaps convert HOM exceptions into corresponding python standard
// exceptions.
%typemap(throws) HOM_TypeError %{
    SWIG_exception_fail(SWIG_TypeError, $1.instanceMessage().c_str());
%}

%typemap(throws) HOM_ValueError %{
    SWIG_exception_fail(SWIG_ValueError, $1.instanceMessage().c_str());
%}

#ifdef SWIGPYTHON
%typemap(throws) HOM_SystemExit %{
    PyErr_SetObject(PyExc_SystemExit, SWIG_From_int($1.code()));
    SWIG_fail;
%}
#endif

//----------------------------------------------------------------------------

// This typemap lets you declare a hboost::any parameter and swig will convert
// the interpreter (Python) object to a hboost::any that wraps the C++ data
// type.
%typemap(in) hboost::any {
    try
    {
        // Note that if we can't convert to a hboost::any, we leave the
        // hboost::any as empty (i.e. its empty() method returns true).
        HOMinterpreterObjectToBoostAny($input, $1);
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

// This typemap lets you declare a HOM_UTOptionAny (hboost::any) parameter and
// swig will convert the interpreter (Python) object into the C++ data type
// for interpreter objects that correspond to a UT_OptionType.
%typemap(in) HOM_UTOptionAny {
    try
    {
        // Note that if we can't convert to a hboost::any, we leave the
        // hboost::any as empty (i.e. its empty() method returns true).
        HOMinterpreterObjectToUTOptionAny($input, $1);
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

// This typemap lets you return hboost::any objects.
%typemap(out) hboost::any {
    try
    {
        $result = HOMboostAnyToInterpreterObject($1);
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

%typemap(out) HOM_DDSourceAny {
    try
    {
        $result = HOMDDSourceAnyToInterpreterObject($1);
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

//----------------------------------------------------------------------------

%typemap(in) HOM_OptionalDouble {
    try
    {
#ifdef SWIGPYTHON
        if ($input != Py_None)
        {
#endif
            double res;
            if (SWIG_IsOK(SWIG_AsVal_double($input, &res)))
                $1 = res;
#ifdef SWIGPYTHON
        }
#endif
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

%typemap(in) HOM_OptionalInt {
    try
    {
#ifdef SWIGPYTHON
        if ($input != Py_None)
        {
#endif
            int res;
            if (SWIG_IsOK(SWIG_AsVal_int($input, &res)))
                $1 = res;
#ifdef SWIGPYTHON
        }
#endif
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

%typemap(out) HOM_OptionalInt {
    try
    {
        if ($1.has_value())
            $result = SWIG_From_int($1.value());
        else
            $result = SWIG_Py_Void();
    }
    catch (...)
    {
        (void)hom::raise_swig_exception();
    }
}

//----------------------------------------------------------------------------

#ifdef SWIGPYTHON
%typemap(out) PY_OpaqueObject {
    $result = HOMincRef((InterpreterObject)$1.opaqueObject());
}
#endif

// For whatever reason, adding the typemap does not customize swig::from(),
// so we do that manually.
%{
#ifdef SWIGPYTHON
namespace swig {
    template <>
    struct traits_from<PY_OpaqueObject>
    {
        static PyObject *from(const PY_OpaqueObject &val)
        {
            return HOMincRef((InterpreterObject)val.opaqueObject());
        }
    };
}
#endif

template <typename T>
bool
HOMinterpreterObjectConvertPtr(InterpreterObject input, hboost::any &result,
    swig_type_info *descriptor)
{
    void *t_ptr = NULL;
    int res = SWIG_ConvertPtr(input, &t_ptr, descriptor, 0);;
    if (SWIG_IsOK(res) && t_ptr)
    {
        // Assign the pointer directly, taking ownership
        result = reinterpret_cast<T*>(t_ptr);
        return true;
    }
    else
    {
        return false;
    }
}

// Reworked traits_asptr_stdseq for std::vector
// Avoid calling it.end() within the loop and pre-allocate the std::vector.
template <typename Seq, typename T = typename Seq::value_type>
bool
HOMinterpreterObjectConvertSeq(InterpreterObject input, hboost::any &result)
{
    swig::SwigPySequence_Cont<T> swigpyseq(input);
    if (!swigpyseq.check())
        return false;

    auto n = swigpyseq.size();

    Seq seq(n);
    for (auto i=0;i<n; ++i)
        seq[i] = swigpyseq[i];

    result = std::move(seq);

    return true;
}

template <typename T>
bool
HOMinterpreterObjectConvertVal(InterpreterObject input, hboost::any &result)
{

    // This branch is using swig_input which was already filled by
    // SWIG_Python_GetSwigThis
    swig_type_info *descriptor = swig::type_info<T>();
    if (!descriptor)
        return false;
    
    T *t_ptr = NULL;
    int res = SWIG_ConvertPtr(input, (void**)&t_ptr, descriptor, 0);

    if (!SWIG_IsOK(res) || !t_ptr)
        return false;

    // This is a clever trick using std::move, since we can't take 
    // ownership of the pointer
    // Deleting t_ptr will delete the cleared instance which is going to
    // be faster than deleting the real instance and the internal data
    // of std containers should be moved properly.
    result = std::move(*t_ptr);
    if (SWIG_IsNewObj(res))
        delete t_ptr;

    return true;
}

template <typename T>
bool
HOMinterpreterObjectConvertAsPtr(InterpreterObject input, hboost::any &result)
{
    // First call is to check if the conversion is valid.
    // It doesn't perform allocations when failing
    int res = swig::asptr(input, (T**)NULL);
    if (!SWIG_IsOK(res))
        return false;

    // Second call does the conversion
    T *t_ptr = NULL;
    res = swig::asptr(input, &t_ptr);
    if (!SWIG_IsOK(res) || !t_ptr)
        return false;

    // This is a clever trick using std::move, since we can't take 
    // ownership of the pointer
    // Deleting t_ptr will delete the cleared instance which is going to
    // be faster than deleting the real instance and the internal data
    // of std containers should be moved properly.
    result = std::move(*t_ptr);
    if (SWIG_IsNewObj(res))
        delete t_ptr;

    return true;
}

#define CONVERT_PTR(X) \
    if (HOMinterpreterObjectConvertPtr<X>(\
        swig_input,result,SWIGTYPE_p_##X))\
        return true;

#define CONVERT_VAL(X) \
    if (HOMinterpreterObjectConvertVal<X>(swig_input,result))\
        return true;

#define CONVERT_ASPTR(X) \
    if (HOMinterpreterObjectConvertAsPtr<X>(input,result))\
        return true;

#define CONVERT_SEQ(X) \
    if (HOMinterpreterObjectConvertSeq<X>(input,result))\
        return true;

// Need typedefs to pass as a macro argument
typedef std::map<std::string,hboost::any> std__map_std__string_hboost__any_;
typedef std::vector<std::map<std::string,hboost::any>> std__vector_std__map_std__string_hboost__any__;

//----------------------------------------------------------------------------

// This helper function takes an interpreter (Python) object and converts it
// into a hboost::any object.  It returns whether or not the conversion was
// possible, and leaves the hboost::any unchanged if a conversion wasn't
// possible.
bool
HOMinterpreterObjectToBoostAny(InterpreterObject input, hboost::any &result)
{
#ifdef SWIGPYTHON
    if (input == Py_None)
    {
        result = (void *)NULL;
        return true;
    }

    // SWIG_AsVal_bool is too permissive, and treats thinks that an integer
    // is a bool.  So, we explicitly check against True and False.
    if (input == Py_True)
    {
        result = true;
        return true;
    }

    if (input == Py_False)
    {
        result = false;
        return true;
    }
#endif

    int int_result;
    if (SWIG_IsOK(SWIG_AsVal_int(input, &int_result)))
    {
        result = int_result;
        return true;
    }

    double double_result;
    if (SWIG_IsOK(SWIG_AsVal_double(input, &double_result)))
    {
        result = double_result;
        return true;
    }

    {
        char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
        if (SWIG_IsOK((SWIG_AsCharPtrAndSize(input, &buf, &size, &alloc))))
        {
            if (buf)
            {
                result = std::string(buf, size - 1);
                if (alloc == SWIG_NEWOBJ)
                    delete[] buf;
            }
            else
            {
                result = std::string();
            }
            return true;

        }
    }

    // Sequences and Dict must go through swig::asptr()
    // because of traits_asptr_stdseq and traits_asptr<std::map<K,T,Compare,Alloc > >
    // It is a faster code path that doesn't use SWIG_Python_GetSwigThis
    bool is_seq = PyList_Check(input) || PyTuple_Check(input);
    bool is_dict = PyDict_Check(input);
    if (is_seq)
    {
        CONVERT_SEQ(std::vector<int>);
        CONVERT_SEQ(std::vector<double>);
        CONVERT_SEQ(std::vector<std::string>);
        CONVERT_SEQ(std::vector<HOM_Quaternion>);
        CONVERT_SEQ(std::vector<HOM_Vector2>);
        CONVERT_SEQ(std::vector<HOM_Vector3>);
        CONVERT_SEQ(std::vector<HOM_Vector4>);
        CONVERT_SEQ(std::vector<HOM_Matrix2>);
        CONVERT_SEQ(std::vector<HOM_Matrix3>);
        CONVERT_SEQ(std::vector<HOM_Matrix4>);
        CONVERT_SEQ(std__vector_std__map_std__string_hboost__any__);
    }
    else if (is_dict)
    {
        CONVERT_ASPTR(std__map_std__string_hboost__any_);
    }
    else
    {
        // This greatly speeds up the casting for the remaining cases.
        // The int,float,string,seq,dict checks were simple and didn't rely
        // on calling SWIG_Python_GetSwigThis.
        InterpreterObject swig_input = 
            (InterpreterObject)SWIG_Python_GetSwigThis(input);

        CONVERT_VAL(std::string);

        CONVERT_PTR(HOM_Geometry);
        CONVERT_PTR(HOM_Ramp);
        CONVERT_PTR(HOM_Color);
        CONVERT_PTR(HOM_Parm);
        CONVERT_PTR(HOM_EnumValue);
        CONVERT_PTR(HOM_Quaternion);
        CONVERT_PTR(HOM_Vector2);
        CONVERT_PTR(HOM_Vector3);
        CONVERT_PTR(HOM_Vector4);
        CONVERT_PTR(HOM_Matrix2);
        CONVERT_PTR(HOM_Matrix3);
        CONVERT_PTR(HOM_Matrix4);

        // Call the fallback version that uses SWIG_Python_GetSwigThis
        CONVERT_VAL(std::vector<int>);
        CONVERT_VAL(std::vector<double>);
        CONVERT_VAL(std::vector<std::string>);
        CONVERT_VAL(std::vector<HOM_Quaternion>);
        CONVERT_VAL(std::vector<HOM_Vector2>);
        CONVERT_VAL(std::vector<HOM_Vector3>);
        CONVERT_VAL(std::vector<HOM_Vector4>);
        CONVERT_VAL(std::vector<HOM_Matrix2>);
        CONVERT_VAL(std::vector<HOM_Matrix3>);
        CONVERT_VAL(std::vector<HOM_Matrix4>);
        CONVERT_VAL(std__map_std__string_hboost__any_);
        CONVERT_VAL(std__vector_std__map_std__string_hboost__any__);
    }


    UT_ASSERT(result.empty());
    return false;
}

// This helper function takes an interpreter (Python) object and converts it
// into a HOM_UTOptionAny (hboost::any) object.  It returns whether or not the
// conversion was possible, and leaves the HOM_UTOptionAny unchanged if a
// conversion wasn't possible.
bool
HOMinterpreterObjectToUTOptionAny(InterpreterObject input,
                                  HOM_UTOptionAny &result)
{
    return HOMinterpreterObjectToBoostAny(input, result);
}

// Creating an input typemap isn't sufficient to handle input parameters with
// std::vector's or std::map's of hboost::any's, so we need to specialize
// swig::traits_asptr<hboost::any>.
namespace swig {
    template <>
    struct traits_asptr<hboost::any>
    {
        static int asptr(InterpreterObject obj, hboost::any **val)
        {
            // TODO: Will the hboost::any be properly deleted?
            hboost::any *p = new hboost::any();
            HOMinterpreterObjectToBoostAny(obj, *p);
            if (val)
                *val = p;
            return SWIG_NEWOBJ;
        }
    };
}

// This function is not instantiated until the first use of HOM_BinaryString,
// but we need to use it in HOMboostAnyToInterpreterObject. So just forward
// declare it here.
static PyObject * SWIG_From_HOM_BinaryString(const HOM_BinaryString& s);

// This helper function takes a variable wrapped inside a hboost::any object
// and creates a new instance of the corresponding InterpreterObject.
static InterpreterObject
HOMboostAnyToInterpreterObject(const hboost::any &result)
{
    if (result.empty())
        return SWIG_Py_Void();

    namespace ti = hboost::typeindex;

    if (result.type() == ti::type_id<int>())
        return SWIG_From_int(hboost::any_cast<int>(result));

    if (result.type() == ti::type_id<long>())
        return SWIG_From_long(hboost::any_cast<long>(result));

    if (result.type() == ti::type_id<int64>())
        return swig::from(hboost::any_cast<int64>(result));

    if (result.type() == ti::type_id<float>())
        return SWIG_From_float(hboost::any_cast<float>(result));

    if (result.type() == ti::type_id<double>())
        return SWIG_From_double(hboost::any_cast<double>(result));

    if (result.type() == ti::type_id<bool>())
        return SWIG_From_bool(hboost::any_cast<bool>(result));

    if (result.type() == ti::type_id<std::string>())
        return SWIG_From_std_string(hboost::any_cast<std::string>(result));

    if (result.type() == ti::type_id<HOM_BinaryString>())
        return SWIG_From_HOM_BinaryString(hboost::any_cast<HOM_BinaryString>(result));

    if (result.type() == ti::type_id<std::map<std::string, hboost::any>>())
        return swig::from(
            hboost::any_cast<std::map<std::string, hboost::any> >(result));

    if (result.type() == ti::type_id<std::vector<int>>())
        return swig::from(hboost::any_cast<std::vector<int> >(result));

    if (result.type() == ti::type_id<std::vector<int64>>())
        return swig::from(hboost::any_cast<std::vector<int64> >(result));

    if (result.type() == ti::type_id<std::vector<float>>())
        return swig::from(hboost::any_cast<std::vector<float> >(result));

    if (result.type() == ti::type_id<std::vector<std::string>>())
        return swig::from(hboost::any_cast<std::vector<std::string> >(result));

    if (result.type() == ti::type_id<std::vector<double>>())
        return swig::from(hboost::any_cast<std::vector<double> >(result));

    if (result.type() == ti::type_id<std::vector<std::vector<float> >>())
        return swig::from(
            hboost::any_cast<std::vector<std::vector<float> > >(result));

    if (result.type() == ti::type_id<std::vector<std::vector<double> >>())
        return swig::from(
            hboost::any_cast<std::vector<std::vector<double> > >(result));

    if (result.type() == ti::type_id<std::vector<std::map<std::string, hboost::any> >>())
        return swig::from(
            hboost::any_cast<std::vector<std::map<std::string, hboost::any> > >(result));

    // If a HOM function returns a pointer to a HOM_Vector*/HOM_Matrix*, it
    // will transfer the ownership of that object to swig.
    if (result.type() == ti::type_id<HOM_Vector2 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Vector2 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Vector3 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Vector3 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Vector4 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Vector4 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Matrix2 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Matrix2 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Matrix3 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Matrix3 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Matrix4 *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Matrix4 *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Quaternion *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Quaternion *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_NodeType *>())
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_NodeType *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Ramp *>())
        return HOMconvertValueForInterpreter(
            hboost::any_cast<HOM_Ramp *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Color *>())
        return HOMconvertValueForInterpreter(
            hboost::any_cast<HOM_Color *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_Parm *>())
        return HOMconvertValueForInterpreter(
            hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<HOM_EnumValue *>())
        return HOMconvertValueForInterpreter(
            hboost::any_cast<HOM_EnumValue *>(result), /*own*/0);

    if (result.type() == ti::type_id<HOM_Geometry *>())
        return HOMconvertValueForInterpreter(
            hboost::any_cast<HOM_Geometry *>(result), SWIG_POINTER_OWN);

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector2> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Vector2> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector3> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Vector3> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Vector4> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Vector4> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix2> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Matrix2> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix3> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Matrix3> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Matrix4> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Matrix4> > >(result));

    if (result.type() == ti::type_id<std::vector<HOM_ElemPtr<HOM_Quaternion> >>())
        return swig::from(
            hboost::any_cast<std::vector<HOM_ElemPtr<HOM_Quaternion> > >(result));

#if UT_ASSERT_LEVEL > 0
    std::cout << "Unknown data type: "
         << UTunmangleClassNameFromTypeIdName(result.type().name()) << "\n";
#endif
    UT_ASSERT(!"Unknown data type");
    return SWIG_Py_Void();
}

// This helper function takes a variable wrapped inside a hboost::any object
// and creates a new instance of the corresponding InterpreterObject.
static InterpreterObject
HOMDDSourceAnyToInterpreterObject(const HOM_DDSourceAny &result)
{
    namespace ti = hboost::typeindex;

    if (result.type() == ti::type_id<HOM_Node *>())
    {
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Node *>(result), SWIG_POINTER_OWN);
    }
    if (result.type() == ti::type_id<HOM_Parm *>())
    {
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_Parm *>(result), SWIG_POINTER_OWN);
    }
    if (result.type() == ti::type_id<HOM_GalleryEntry *>())
    {
        return HOMconvertValueForInterpreter(
                hboost::any_cast<HOM_GalleryEntry *>(result), SWIG_POINTER_OWN);
    }

    return HOMboostAnyToInterpreterObject(result);
}

namespace swig {
    // Adding the typemap does not customize swig::from() so we do that
    // manually.
    template <>
    struct traits_from<hboost::any>
    {
        static PyObject *from(const hboost::any &val)
        { return HOMboostAnyToInterpreterObject(val); }
    };
}

static InterpreterObject
HOMoptionsToInterpreterObject(const UT_Options &options);

static InterpreterObject
HOMoptionEntryToInterpreterObject(const UT_OptionEntry &option_entry)
{
    // We're usually called from code that has the GIL released so make sure we
    // acquire it here.
    PY_InterpreterAutoLock py_lock;

    InterpreterObject result = NULL;

    switch (option_entry.getType())
    {
        case UT_OPTION_INT:
            return swig::from(
                ((const UT_OptionInt &)option_entry).getValue());

        case UT_OPTION_BOOL:
            return SWIG_From_bool(
                ((const UT_OptionBool &)option_entry).getValue());

        case UT_OPTION_FPREAL:
            return SWIG_From_double(
                ((const UT_OptionFpreal &)option_entry).getValue());

        case UT_OPTION_STRING:
        case UT_OPTION_STRINGRAW:
        {
            return SWIG_From_std_string(
                 ((const UT_OptionString &)option_entry).getValue().toStdString());
        }

        case UT_OPTION_VECTOR2:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector2(
                     ((const UT_OptionVector2 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_VECTOR3:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector3(
                    ((const UT_OptionVector3 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_VECTOR4:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector4(
                    ((const UT_OptionVector4 &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_QUATERNION:
            return HOMconvertValueForInterpreter(
                 new HOM_Quaternion(
                     ((const UT_OptionQuaternion &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_MATRIX2:
            return HOMconvertValueForInterpreter(
                 new HOM_Matrix2(UT_DMatrix2(
                    ((const UT_OptionMatrix2 &)option_entry).getValue())),
                 SWIG_POINTER_OWN);

        case UT_OPTION_MATRIX3:
            return HOMconvertValueForInterpreter(
                 new HOM_Matrix3(UT_DMatrix3(
                    ((const UT_OptionMatrix3 &)option_entry).getValue())),
                 SWIG_POINTER_OWN);

        case UT_OPTION_MATRIX4:
            return HOMconvertValueForInterpreter(
                 new HOM_Matrix4(UT_DMatrix4(
                    ((const UT_OptionMatrix4 &)option_entry).getValue())),
                 SWIG_POINTER_OWN);

        case UT_OPTION_UV:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector2(
                    ((const UT_OptionUV &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_UVW:
            return HOMconvertValueForInterpreter(
                 new HOM_Vector3(
                     ((const UT_OptionUVW &)option_entry).getValue()),
                 SWIG_POINTER_OWN);

        case UT_OPTION_INTARRAY:
            {
                std::vector<int64> int_vector;
                UTarrayToStdVector(
                    static_cast<const UT_OptionInt64Array &>(option_entry)
                        .getValue(), int_vector);
                return swig::from(int_vector);
            }

        case UT_OPTION_FPREALARRAY:
            {
                std::vector<double> double_vector;
                UTarrayToStdVector(
                    static_cast<const UT_OptionFpreal64Array &>(option_entry)
                        .getValue(), double_vector);
                return swig::from(double_vector);
            }

        case UT_OPTION_STRINGARRAY:
            {
                std::vector<std::string> str_vector;
                UTarrayToStdVectorOfStrings(
                    static_cast<const UT_OptionStringArray &>(option_entry)
                        .getValue(), str_vector);
                return swig::from(str_vector);
            }

        case UT_OPTION_DICT:
            {
                UT_OptionsHolder        opt;
                opt = static_cast<const UT_OptionDict &>(option_entry).getValue();
                return HOMoptionsToInterpreterObject(*opt.options());
            }
        case UT_OPTION_DICTARRAY:
            {
                UT_Array<UT_OptionsHolder>      optlist;
                optlist = static_cast<const UT_OptionDictArray &>(option_entry).getValue();
                InterpreterObject       result = PyList_New(0);

                for (auto && opt : optlist)
                {
                    PyList_Append(result, HOMoptionsToInterpreterObject(*opt.options()));
                }

                return result;
            }
        case UT_OPTION_INVALID:
        case UT_OPTION_NUM_TYPES:
            // Just exit the switch with no result.
            break;
    }

    return result ? result : SWIG_Py_Void();
}

#ifdef SWIGPYTHON
static InterpreterObject
HOMoptionsToInterpreterObject(const UT_Options &options)
{
    // We're usually called from code that has the GIL released so make sure we
    // acquire it here.
    PY_InterpreterAutoLock py_lock;

    InterpreterObject result = PyDict_New();

    for (UT_Options::iterator it = options.begin(); !it.atEnd(); ++it)
    {
        // The Python dictionary object will increment the reference count
        // on the value, so we decrement it since we just allocated it.
        InterpreterObject value=HOMoptionEntryToInterpreterObject(*it.entry());
        PyDict_SetItemString(result, it.name(), value);
        Py_DECREF(value);
    }

    return result;
}

static InterpreterObject
HOMoptionsListToInterpreterObject(const std::vector<UT_Options>& options)
{
    auto pysize = options.size();
    
    // We're usually called from code that has the GIL released so make sure we
    // acquire it here.
    PY_InterpreterAutoLock py_lock;

    InterpreterObject list = PyList_New(pysize);
    for (int i = 0; i < pysize; ++i)
    {
        auto value = HOMoptionsToInterpreterObject(options[i]);
        // PyList_SET_ITEM will steal the reference
        PyList_SET_ITEM(list, i, value);
    }
    return list;
}

#endif

#ifdef SWIGPYTHON

// Helper for  accessing a HOM object python attributes.
// Used by HDAModule, HDAViewerStateModule and HOMF_HDAViewerHandleModule.
template<typename T>
PyObject* HOMgetattr(T* hom_object, const char *name)
{
    HOM_AutoLock hom_lock;
    PY_InterpreterAutoLock py_lock;

    // First check the context's locals dictionary.  If the context
    // pointer is null we treat it as though the dictionary is empty.
    PY_EvaluationContext *context = hom_object->getEvaluationContext();
    PyObject *dict = context
        ? (PyObject *)context->getGlobalsDict() : NULL;
    PyObject *attribute = (dict && name)
        ? PyDict_GetItemString(dict, name) : NULL;

    // If the lookup failed, try the globals dictionary.
    if (!attribute && dict)
    {
        dict = (PyObject *)context->getGlobalsDict();
        attribute = name ? PyDict_GetItemString(dict, name) : NULL;
    }

    // If we found an object in the dictionary, return it, being careful
    // to increment the reference count on the object.
    if (attribute)
        return HOMincRef(attribute);

    // We didn't find the object, so raise an exception.
    if (!name)
        name = "";
    UT_WorkBuffer error_message;
    error_message.sprintf("'module' object has no attribute '%s'", name);
    PyErr_SetString(PyExc_AttributeError, error_message.buffer());
    return NULL;
}
#endif

//----------------------------------------------------------------------------

#ifdef SWIGPYTHON
// This helper class takes a Python buffer object and provides access to
// the underlying C buffer.  Note that the class is only used inside the
// swig file, so it doesn't need to be exported from the current library.
class HOM_PyBuffer
{
public:
    HOM_PyBuffer(InterpreterObject py_object)
    {
#if PY_VERSION_HEX >= 0x03000000
        myBytesObj = nullptr;
#endif
        myData = NULL;
        myLength = 0;

        PyObject *obj = py_object;

#if PY_VERSION_HEX >= 0x03000000
        // Automatically convert HOM binary strings to buffer-like objects.
        if (PyUnicode_Check(obj))
        {
            myBytesObj = 
                PyUnicode_AsEncodedString(obj, "utf-8", "surrogateescape");
            obj = myBytesObj;
        }
#endif

        // Python added a new buffer interface starting with Python 2.6.
#if PY_VERSION_HEX >= 0x02060000
        myUseNewAPI = false;
        if (PyObject_CheckBuffer(obj))
        {
            if (PyObject_GetBuffer(obj, &myPyBuffer, PyBUF_SIMPLE) < 0)
            {
#if PY_VERSION_HEX >= 0x03000000
                cleanBytesObject_();
#endif
                throw HOM_TypeError("failed to get readable buffer");
            }

            myUseNewAPI = true;
            myData = myPyBuffer.buf;
            myLength = myPyBuffer.len;
            return;
        }
#endif

#if PY_VERSION_HEX >= 0x03000000
        cleanBytesObject_();
        throw HOM_TypeError("failed to get readable buffer");
#else
        // Either the new API isn't supported in this Python version or the
        // Python object doesn't support it.  Try the old API.
        if (!PyObject_CheckReadBuffer(obj))
            throw HOM_TypeError("expected a readable buffer");

        if (PyObject_AsReadBuffer(obj, &myData, &myLength) < 0)
            throw HOM_TypeError("failed to get readable buffer");
#endif
    }

    ~HOM_PyBuffer()
    {
#if PY_VERSION_HEX >= 0x03000000
        cleanBytesObject_();
#endif
    
#if PY_VERSION_HEX >= 0x02060000
        if (myUseNewAPI)
            PyBuffer_Release(&myPyBuffer);
#endif
    }

#if PY_VERSION_HEX >= 0x03000000
    void cleanBytesObject_()
    {
        if (!myBytesObj)
            return;

        Py_DECREF(myBytesObj);
        myBytesObj = nullptr;
    }
#endif

#if PY_VERSION_HEX >= 0x03000000
    PyObject *myBytesObj;
#endif

#if PY_VERSION_HEX >= 0x02060000
    bool myUseNewAPI;
    Py_buffer myPyBuffer;
#endif
    const void *myData;
    Py_ssize_t myLength;
};
#endif

//----------------------------------------------------------------------------

// These helper functions are used to implement the attrib() methods of
// Points, Prims, and Vertices.  We need to do extra work for these methods
// because the return type can vary.

template <typename T, typename A>
InterpreterObject
HOMattribValue(T &geo_element, A &hom_attrib,
    int attr_size,
    bool is_array_type,
    int array_data_type
)
{
    InterpreterObject result = NULL;
    const bool scalar = (attr_size == 1 && !is_array_type);
    switch (array_data_type)
    {
    case HOM_attribData::Int_Id:
        if (scalar)
            result = swig::from(
                hboost::any_cast<int64>(geo_element.intAttribValue(hom_attrib)));
        else
            result = swig::from(
                hboost::any_cast<std::vector<int64> >(
                    geo_element.intListAttribValue(hom_attrib)));
        break;

    case HOM_attribData::Float_Id:
        if (scalar)
            result = SWIG_From_double(geo_element.floatAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.floatListAttribValue(hom_attrib));
        break;

    case HOM_attribData::String_Id:
        if (scalar)
            result = SWIG_From_std_string(
                geo_element.stringAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.stringListAttribValue(hom_attrib));
        break;

    case HOM_attribData::Dict_Id:
        if (scalar)
            result = swig::from(geo_element.dictAttribValue(hom_attrib));
        else
            result = swig::from(geo_element.dictListAttribValue(hom_attrib));
        break;
    }
    UT_ASSERT(result);
    return result;
}

template <typename T>
InterpreterObject
HOMattribValue(T &geo_element, HOM_Attrib &hom_attrib)
{
    return HOMattribValue(geo_element,
        hom_attrib,
        hom_attrib.size(),
        hom_attrib.isArrayType(),
        hom_attrib.dataType().id());
}

template <typename T>
InterpreterObject
HOMattribValue(T &geo_element, const char *name)
{
    int attr_size = 1;
    bool is_array_type = false;
    int attr_data_type = 0;
    geo_element._attribInfo(name,attr_data_type,attr_size,is_array_type);
    return HOMattribValue(geo_element,name, attr_size, is_array_type,
        attr_data_type);
}
%}

//----------------------------------------------------------------------------

%{
// These helper functions are used to implement parm evaluation.
static InterpreterObject
HOMevalParm(HOM_Parm &parm)
{
    switch (parm.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(hboost::any_cast<int64>(parm.evalAsInt()));
    case HOM_parmData::Float_Id:
        return SWIG_From_double(parm.evalAsFloat());
    case HOM_parmData::String_Id:
        return SWIG_From_std_string(parm.evalAsString());
    case HOM_parmData::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)parm.evalAsRamp(), SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
    case HOM_parmData::Data_Id:
        if (parm.dataParmTypeEnumId() == HOM_dataParmType::KeyValueDictionary_Id)
            return swig::from(parm.evalAsJSONMap());

        return SWIG_NewPointerObj(
            (void*)parm.evalAsGeometry(), SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmAtFrame(HOM_Parm &parm, double frame)
{
    switch (parm.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(hboost::any_cast<int64>(parm.evalAsIntAtFrame(frame)));
    case HOM_parmData::Float_Id:
        return SWIG_From_double(parm.evalAsFloatAtFrame(frame));
    case HOM_parmData::String_Id:
        return SWIG_From_std_string(parm.evalAsStringAtFrame(frame));
    case HOM_parmData::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)parm.evalAsRampAtFrame(frame),
            SWIGTYPE_p_HOM_Ramp, SWIG_POINTER_OWN);
    case HOM_parmData::Data_Id:
        if (parm.dataParmTypeEnumId() == HOM_dataParmType::KeyValueDictionary_Id)
            return swig::from(parm.evalAsJSONMapAtFrame(frame));

        return SWIG_NewPointerObj(
            (void*)parm.evalAsGeometryAtFrame(frame),
            SWIGTYPE_p_HOM_Geometry, SWIG_POINTER_OWN);
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmTuple(HOM_ParmTuple &parm_tuple)
{
    switch (parm_tuple.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(parm_tuple.evalAsInts());
    case HOM_parmData::Float_Id:
        return swig::from(parm_tuple.evalAsFloats());
    case HOM_parmData::String_Id:
        return swig::from(parm_tuple.evalAsStrings());
    case HOM_parmData::Ramp_Id:
        return swig::from(parm_tuple.evalAsRamps());
    case HOM_parmData::Data_Id:
        if (parm_tuple.dataParmTypeEnumId() 
            == HOM_dataParmType::KeyValueDictionary_Id)
        {
            return swig::from(parm_tuple.evalAsJSONMaps());
        }

        return swig::from(parm_tuple.evalAsGeometries());
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalParmTupleAtFrame(HOM_ParmTuple &parm_tuple, double frame)
{
    switch (parm_tuple.parmDataTypeEnumId())
    {
    case HOM_parmData::Int_Id:
        return swig::from(parm_tuple.evalAsIntsAtFrame(frame));
    case HOM_parmData::Float_Id:
        return swig::from(parm_tuple.evalAsFloatsAtFrame(frame));
    case HOM_parmData::String_Id:
        return swig::from(parm_tuple.evalAsStringsAtFrame(frame));
    case HOM_parmData::Ramp_Id:
        return swig::from(parm_tuple.evalAsRampsAtFrame(frame));
    case HOM_parmData::Data_Id:
        if (parm_tuple.dataParmTypeEnumId() 
            == HOM_dataParmType::KeyValueDictionary_Id)
        {
            return swig::from(parm_tuple.evalAsJSONMapsAtFrame(frame));
        }

        return swig::from(parm_tuple.evalAsGeometriesAtFrame(frame));
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}

static InterpreterObject
HOMevalViewportVisualizerParm(HOM_ViewportVisualizer &visualizer, const char *parm_name)
{
    switch (visualizer.parmDataTypeEnumId(parm_name))
    {
    case HOM_parmData::Int_Id:
        return swig::from(hboost::any_cast<int64>(visualizer.evalParmAsInt(parm_name)));
    case HOM_parmData::Float_Id:
        return SWIG_From_double(visualizer.evalParmAsFloat(parm_name));
    case HOM_parmData::String_Id:
        return SWIG_From_std_string(visualizer.evalParmAsString(parm_name));
    case HOM_parmData::Ramp_Id:
        return SWIG_NewPointerObj(
            (void*)visualizer.evalParmAsRamp(parm_name), SWIGTYPE_p_HOM_Ramp, 
            SWIG_POINTER_OWN);
    }

    UT_ASSERT(!"Unknown parm data type");
    return SWIG_Py_Void();
}


//----------------------------------------------------------------------------

%}
#endif

#endif