PI_PythonResourceTypes.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:
 *
 * COMMENTS:
 *
 *      Various enums and types, etc... related to viewer states and 
 *      viewer handles.
 */

#ifndef PI_PythonResourceTypes_H
#define PI_PythonResourceTypes_H

#include "PI_API.h"
#include <UT/UT_PackageUtils.h>

namespace PI_PythonResource
{

using ActiveViewerPair = std::pair<UT_StringHolder,UT_StringHolder>;
using ActiveViewers = UT_Array<ActiveViewerPair>;
using ParmVariant = std::variant<int32, fpreal, UT_StringHolder>;

// Resource type 
enum class ResourceType : short 
{
    NoType = 0,
    ViewerState,
    ViewerHandle,
    Package
};

// Registration status
enum class RegisterStatus : short 
{
    Invalid = 0,
    Registered,
    Waiting
};

// Enum used to report registration/unregistration status
enum class Status : unsigned
{
    AlreadyRegistered = 0,
    InUse,
    NoError,
    NoFactory,
    NotRegistered,
    NotSelfInstalled,
    OpTypeNotSupported,
    RegisterError,
    ReloadError,
    Success,
    SyntaxError,
    UnknownError,
    UnregisterError
};

struct EventMessage
{
    // Callback event types. This enum is used for mapping user callbacks to
    // various viewer state and handle operations
    enum class Type : short
    {
        None = 0,
        OnEnter,
        OnExit,
        OnInterrupt,
        OnRegister,
        OnReload,
        OnResume,
        OnUnregister,
        OnRuntimeError,
        OnGenerate,
        OnPrintMessage,
        OnCustomEvent,
        OnPreEnter,
        OnActivate,
        OnDeactivate,
        OnLoad,
        OnUnload
    };

    enum class DeliveryMode : unsigned
    {
        Immediate = 0,
        Queue
    };

    struct Data
    {
        struct Elem
        {
            using Value = UT_Package::utils::Value;

            Elem() : myExprFlag(false), myDoubleQuoteFormat(false)
            {
            }

            Elem(char const * key, Value const & value, bool expr, bool double_quote)
            {
                myKey = key;
                myValue = value;
                myExprFlag = expr;
                myDoubleQuoteFormat = double_quote;
            }

            ~Elem() = default;

            UT_StringHolder myKey;
            Value           myValue;
            bool            myExprFlag;
            bool            myDoubleQuoteFormat;
        };

        using Array = UT_Array<Elem>;

        Data() : myDeliveryMode(EventMessage::DeliveryMode::Queue)
        {
        }

        ~Data() = default;

        void add(char const * key, Elem::Value const & value)
        {
            myDataArray.append(Elem(key,value,false,false)); 
        }

        void add(char const * key, char const * value, bool double_quote)
        {
            UT_String value_str(value);
            value_str.substitute("\\","\\\\");
            value_str.substitute("\n","\\n");
            value_str.substitute("\r","\\r");
            value_str.substitute("\"","\\\"");
            value_str.substitute("\'","\\\'");

            myDataArray.append(Elem(key,Elem::Value(value_str.c_str()),false,double_quote)); 
        }

        void addExpr(char const * key, char const * value)
        {
            myDataArray.append(Elem(key,Elem::Value(value),true,false)); 
        }

        void addStateType( char const * value, bool double_quote=false)
        {
            add("state_type", value, double_quote); 
        }

        void addStateLabel( char const * value, bool double_quote=false)
        {
            add("state_label", value, double_quote); 
        }

        void addHandleType( char const * value, bool double_quote=false)
        {
            add("handle_type", value, double_quote); 
        }

        void addHandleLabel( char const * value, bool double_quote=false)
        {
            add("handle_label", value, double_quote); 
        }

        void addPackageName( char const * value, bool double_quote=false)
        {
            add("package_name", value, double_quote); 
        }
        
        void addPackageFilepath( char const * value, bool double_quote=false)
        {
            add("package_filepath", value, double_quote); 
        }

        void addMessage( char const * value, bool double_quote=false)
        {
            add("event_message", value, double_quote);
            addExpr("event_message_type","hou.severityType.Message");
        }

        void addImportantMessage( char const * value, bool double_quote=false)
        {
            add("event_message", value, double_quote);
            addExpr("event_message_type","hou.severityType.ImportantMessage");
        }

        void addWarning( char const * value, bool double_quote=false)
        {
            add("event_message", value, double_quote);
            addExpr("event_message_type","hou.severityType.Warning"); 
        }

        void addError( char const * value, bool double_quote=false)
        {
            add("event_message", value, double_quote);
            addExpr("event_message_type","hou.severityType.Error"); 
        }

        void addFatal( char const * value, bool double_quote=false )
        {
            add("event_message", value, double_quote);
            addExpr("event_message_type","hou.severityType.Fatal"); 
        }

        void setDeliveryMode(EventMessage::DeliveryMode mode)
        {
            myDeliveryMode = mode;
        }

        DeliveryMode deliveryMode() const
        {
            return myDeliveryMode;
        }

        Array const & values() const
        {
            return myDataArray;
        }

        private:
        Array myDataArray;      
        EventMessage::DeliveryMode myDeliveryMode;
    };

    EventMessage(Type type) 
        : myType(type)
        , myKwargs("{}")
    {
    }

    EventMessage() 
        : myType(Type::None)
        , myKwargs("{}")
    {
    }
    ~EventMessage() = default;

    Type myType;
    UT_StringHolder myKwargs;
};

// Convert any to requested type
template <typename T> T
anyToType( hboost::any const & any)
{
    if (typeid(int) == any.type())
    {
        return static_cast<T>(hboost::any_cast<int>(any));
    }
    else if (typeid(double) == any.type())
    {
        return static_cast<T>(hboost::any_cast<double>(any));
    }
    else if (typeid(bool) == any.type())
    {
        return static_cast<T>(hboost::any_cast<bool>(any));
    }
    return T(0);
}

template <> inline std::string
anyToType( hboost::any const & any)
{
    if (typeid(std::string) == any.type())
    {
        return hboost::any_cast<std::string>(any);
    }
    else if (typeid(int) == any.type())
    {
        return std::to_string(hboost::any_cast<int>(any));
    }
    else if (typeid(double) == any.type())
    {
        return std::to_string(hboost::any_cast<double>(any));
    }
    else if (typeid(bool) == any.type())
    {
        return std::to_string(hboost::any_cast<bool>(any));
    }
    return std::string();
}

template <> inline int
anyToType(hboost::any const & any)
{
    if (typeid(int) == any.type())
    {
        return hboost::any_cast<int>(any);
    }
    else if (typeid(bool) == any.type())
    {
        return (int)hboost::any_cast<bool>(any);
    }
    return 0;
}

} // PI_PythonResource


#endif // PI_PythonResourceTypes_H