NET_ConvertToType.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:        NET_ConvertToType.h (LM Library, C++)
 *
 * COMMENTS: Convert a type to another type
 */

#ifndef __NET_ConvertToType_H__
#define __NET_ConvertToType_H__

#include "NET_API.h"

#include <UT/UT_IntArray.h>
#include <UT/UT_JSONValue.h>
#include <UT/UT_JSONValueArray.h>
#include <UT/UT_JSONValueMap.h>
#include <UT/UT_JSONWriter.h>
#include <UT/UT_String.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringView.h>
#include <UT/UT_Variant.h>
#include <UT/UT_WorkBuffer.h>

#include <type_traits>

#define NET_REQUIRE(_cond_) std::enable_if_t<_cond_>

// -----------------------------------------------------------------------------
// Serialize Object
// -----------------------------------------------------------------------------

template <typename T>
bool NETserialize(UT_JSONWriter& writer, const T& obj)
{
    return obj.serialize(writer);
}

template <typename T>
bool NETserialize(const UT_JSONValue& data, T& obj)
{
    return obj.serialize(data);
}

// -----------------------------------------------------------------------------
// Serialize Integers
// -----------------------------------------------------------------------------

#define NET_DEFINE_INT_SERIALIZER(_T_) \
    template <> \
    inline bool NETserialize<_T_>(UT_JSONWriter& writer, const _T_& obj)    \
{   \
    writer.jsonValue(obj);  \
    return true;    \
}   \
    template <> \
    inline bool NETserialize<_T_>(const UT_JSONValue& data, _T_& item)  \
{   \
    int64 v = 0; \
    bool res = data.import(v); \
    item = static_cast<_T_>(v); \
    return res;    \
}
NET_DEFINE_INT_SERIALIZER(int8);
NET_DEFINE_INT_SERIALIZER(int16);
NET_DEFINE_INT_SERIALIZER(int32);
#undef NET_DEFINE_INT_SERIALIZER

template <>
inline bool NETserialize<int64>(UT_JSONWriter& writer, const int64& obj)
{
    writer.jsonValue(obj);
    return true;
}

template <>
inline bool NETserialize<int64>(const UT_JSONValue& data, int64& obj)
{
    return data.import(obj);
}

template <>
inline bool NETserialize<uint32>(UT_JSONWriter& writer, const uint32& obj)
{
    writer.jsonValue(static_cast<int32>(obj));
    return true;
}

template <>
inline bool NETserialize<uint32>(const UT_JSONValue& data, uint32& obj)
{
    int64 tmp = 0;
    bool res = data.import(tmp);
    obj = static_cast<uint32>(tmp);
    return res;
}

// -----------------------------------------------------------------------------
// Serialize Bool
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<bool>(UT_JSONWriter& writer, const bool& obj)
{
    writer.jsonValue(obj);
    return true;
}

template <>
inline bool NETserialize<bool>(const UT_JSONValue& data, bool& item)
{
    return data.import(item);
}

// -----------------------------------------------------------------------------
// Serialize String Holder
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<UT_StringHolder>(UT_JSONWriter& writer, const UT_StringHolder& obj)
{
    writer.jsonValue(obj);
    return true;
}

template <>
inline bool NETserialize<UT_StringHolder>(const UT_JSONValue& data, UT_StringHolder& obj)
{
    return data.import(obj);
}

template <>
inline bool NETserialize<UT_String>(UT_JSONWriter& writer, const UT_String& obj)
{
    writer.jsonValue(obj);
    return true;
}
template <>
inline bool NETserialize<UT_String>(const UT_JSONValue& data, UT_String& obj)
{
    if (data.getType() != UT_JSONValue::JSON_STRING)
        return false;
    obj = data.getS();
    return true;
}

template <>
inline bool NETserialize<UT_StringLit>(UT_JSONWriter& writer, const UT_StringLit& obj)
{
    writer.jsonValue(obj.asRef());
    return true;
}

template <>
inline bool NETserialize<UT_StringLit>(const UT_JSONValue& data, UT_StringLit&) = delete;

// -----------------------------------------------------------------------------
// Serialize WorkBuffer
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<UT_WorkBuffer>(UT_JSONWriter& writer, const UT_WorkBuffer& obj)
{
    writer.jsonValue(obj);
    return true;
}

template <>
inline bool NETserialize<UT_WorkBuffer>(const UT_JSONValue& data, UT_WorkBuffer& obj)
{
    return data.import(obj);
}

// -----------------------------------------------------------------------------
// Serialize Arrays
// -----------------------------------------------------------------------------

template <typename T, template <typename> class ARRAY>
inline bool NETserializeArray(UT_JSONWriter& writer, const ARRAY<T>& items)
{
    writer.jsonBeginArray();
    for (auto&& item : items)
        NETserialize<T>(writer, item);
    writer.jsonEndArray();
    return true;   
}

template <typename T, template <typename> class ARRAY>
inline bool NETserializeArray(const UT_JSONValue& data, ARRAY<T>& items)
{
    // To support some older clients that were sending empty strings in place
    // of empty arrays.
    if (data.getType() == UT_JSONValue::JSON_STRING)
    {
        const UT_StringHolder* str = data.getStringHolder();
        if (str && str->isEmpty())
            return true;
    }
    if (data.getType() != UT_JSONValue::JSON_ARRAY)
        return false;
    UT_JSONValueArray* values = data.getArray();
    if (values == nullptr)
        return false;
    exint size = values->entries();
    items.setSize(size);
    for (exint i = 0; i < size; ++i)
    {
        UT_JSONValue* value = values->get(i);
        if (value == nullptr)
            continue;
        NETserialize<T>(*value, items[i]);
    }
    return true;
}

#define NET_DEFINE_ARRAY_SERIALIZER(_ARRAY_) \
template <typename T>   \
inline bool NETserialize(UT_JSONWriter& writer, const _ARRAY_<typename T::value_type>& items)   \
{   \
    return NETserializeArray<typename T::value_type, _ARRAY_>(writer, items);    \
}   \
template <typename T>   \
inline bool NETserialize(const UT_JSONValue& data, _ARRAY_<typename T::value_type>& items)   \
{   \
    return NETserializeArray<typename T::value_type, _ARRAY_>(data, items);     \
}
NET_DEFINE_ARRAY_SERIALIZER(UT_Array)
NET_DEFINE_ARRAY_SERIALIZER(UT_ValArray)
#undef NET_DEFINE_ARRAY_SERIALIZER

template <>
inline bool NETserialize<UT_StringArray>(UT_JSONWriter& writer, const UT_StringArray& items)
{
    return writer.jsonStringArray(items);
}

template <>
inline bool NETserialize<UT_StringArray>(const UT_JSONValue& data, UT_StringArray& items)
{
    // To support some older clients that were sending empty strings in place
    // of empty arrays.
    if (data.getType() == UT_JSONValue::JSON_STRING)
    {
        const UT_StringHolder* str = data.getStringHolder();
        if (str && str->isEmpty())
            return true;
    }
    return data.import(items);
}

// -----------------------------------------------------------------------------
// Serialize JSONValue
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<UT_JSONValue>(UT_JSONWriter& writer, const UT_JSONValue& value)
{
    writer.jsonValue(value);
    return false;
}

template <>
inline bool NETserialize<UT_JSONValue>(const UT_JSONValue& data, UT_JSONValue& item)
{
    item = data;
    return true;
}

// -----------------------------------------------------------------------------
// Serialize UT_Variant
// -----------------------------------------------------------------------------

// Forward declare so UT_VariantArray and UT_Variant can use each others serialize
// functions
template <>
bool NETserialize<UT_VariantArray>(UT_JSONWriter& writer, const UT_VariantArray& value);
template <>
bool NETserialize<UT_VariantArray>(const UT_JSONValue& data, UT_VariantArray& value);
template <>
bool NETserialize<UT_VariantMap>(UT_JSONWriter& writer, const UT_VariantMap& value);
template <>
bool NETserialize<UT_VariantMap>(const UT_JSONValue& data, UT_VariantMap& value);

template <>
inline bool NETserialize<UT_Variant>(UT_JSONWriter& writer, const UT_Variant& v)
{
    if (v.type() == UT_Variant::Type::Int)
        writer.jsonValue(v.get<int64>());
    else if (v.type() == UT_Variant::Type::Float)
        writer.jsonValue(v.get<float>());
    else if (v.type() == UT_Variant::Type::String)
        writer.jsonValue(v.get<UT_StringHolder>());
    else if (v.type() == UT_Variant::Type::Bool)
        writer.jsonValue(v.get<bool>());
    else if (v.type() == UT_Variant::Type::Array)
    {
        UT_VariantArray values = v.get<UT_VariantArray>();
        return NETserialize(writer, values);
    }
    else if (v.type() == UT_Variant::Type::Map)
    {
        UT_VariantMap values = v.get<UT_VariantMap>();
        return NETserialize(writer, values);
    }
    else
    {
        return false;
    }

    return true;
}

template <>
inline bool NETserialize<UT_Variant>(const UT_JSONValue& data, UT_Variant& v)
{
    if (data.getType() == UT_JSONValue::JSON_INT)
        v = data.getI();
    else if (data.getType() == UT_JSONValue::JSON_REAL)
        v = data.getF();
    else if (data.getType() == UT_JSONValue::JSON_BOOL)
        v = data.getB();
    else if (data.getType() == UT_JSONValue::JSON_STRING)
        v = data.getStringHolder();
    else if (data.getType() == UT_JSONValue::JSON_ARRAY)
    {
        UT_VariantArray variants;
        if (!NETserialize(data, variants))
            return false;

        v = variants;
    }
    else if (data.getType() == UT_JSONValue::JSON_MAP)
    {
        UT_VariantMap variants;
        if (!NETserialize(data, variants))
            return false;

        v = variants;
    }
    else
    {
        return false;
    }

    return true;
}

// -----------------------------------------------------------------------------
// Serialize UT_VariantArray
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<UT_VariantArray>(UT_JSONWriter& writer, const UT_VariantArray& variants)
{
    writer.jsonBeginArray();

    for (auto&& k : variants)
    {
        if (!NETserialize(writer, k))
            return false;
    }

    writer.jsonEndArray();

    return true;
}

template <>
inline bool NETserialize<UT_VariantArray>(const UT_JSONValue& data, UT_VariantArray& variants)
{
    UT_JSONValueArray* arr = data.getArray();
    if (arr == nullptr)
        return false;

    for (int i = 0; i < arr->entries(); i++)
    {
        UT_JSONValue* json = arr->get(i);
        if (json == nullptr)
            return false;

        UT_Variant value;
        if (!NETserialize(*json, value))
            return false;

        variants.append(value);
    }

    return true;
}

// -----------------------------------------------------------------------------
// Serialize a UT_VariantMap
// -----------------------------------------------------------------------------

template <>
inline bool NETserialize<UT_VariantMap>(UT_JSONWriter& writer, const UT_VariantMap& variants)
{
    writer.jsonBeginMap();

    for (auto&& v : variants)
    {
        if (v.second.type() == UT_Variant::Type::Null)
            continue;

        writer.jsonKeyToken(v.first);
        if (!NETserialize(writer, v.second))
            return false;
    }

    writer.jsonEndMap();
    return true;
}

template <>
inline bool NETserialize<UT_VariantMap>(const UT_JSONValue& data, UT_VariantMap& variants)
{
    UT_JSONValueMap* json = data.getMap();
    if (json == nullptr)
        return false;

    for (auto&& v : *json)
    {
        if (v.second == nullptr)
            return false;

        UT_Variant value;
        if (!NETserialize(*v.second, value))
            return false;

        variants[v.first] = value;
    }

    return false;
}

// -----------------------------------------------------------------------------
// Helper for cases where you dont need to serialize something for whatever
// reason. Typically this would only ever be used when doing templated calls
// where theres little control over how to serialize something.
// For example, in some cases the parameter on an api function no longer means
// anything then it might make sense to just ignore it.
// -----------------------------------------------------------------------------
class NET_API NET_EmptySerializer
{
public:
};

using NET_UnusedParameter = NET_EmptySerializer;

template <>
inline bool
NETserialize<NET_EmptySerializer>(
        UT_JSONWriter& writer,
        const NET_EmptySerializer&)
{
    return true;
}

template <>
inline bool
NETserialize<NET_EmptySerializer>(
        const UT_JSONValue& data,
        NET_EmptySerializer&)
{
    return true;
}

// =============================================================================
// Deprecated conversion type.
// =============================================================================

namespace NET_ConvertToType
{
// Remove const reference from type
template <class T>
struct NET_API NET_remove_cref
{
    typedef std::remove_const_t<std::remove_reference_t<T>> type;
};

template <class T>
using NET_remove_cref_t = typename NET_remove_cref<T>::type;

// C++ 17 will allow us to support more then just UT_StringHolder and combine
// some of this code as well.
template <typename Tto, typename Enable = void>
class convertImpl
{
public:
    static Tto cast(const UT_StringHolder& source)
    {
        UT_ASSERT(!"This code should never be entered. You have not setup a proper cast for this type.");
        return Tto{};
    }
};

template <typename Tto>
class convertImpl<Tto,
                  std::enable_if_t<std::is_same<UT_StringHolder,
                                                NET_remove_cref_t<Tto>>::value>>
{
public:
    static Tto cast(const UT_StringHolder &source) { return source; }
};

template <typename Tto>
class convertImpl<Tto,
                  std::enable_if_t<std::is_same<UT_StringArray,
                                                NET_remove_cref_t<Tto>>::value>>
{
public:
    static Tto cast(const UT_StringHolder &source)
    {
        // Try parsing it as a json string array first. If that fails then
        // try parsing it as a custom array string.
        UT_JSONValue value;
        if (value.parseValue(source))
        {
            UT_StringArray values;
            if (NETserialize(value, values))
                return values;
        }

        UT_StringView view_source(source.buffer());
        UT_StringViewArray values = view_source.split(",");
        UT_StringArray result;
        result.setCapacity(values.entries());
        for (auto &&value : values)
        {
            result.emplace_back(value);
        }

        return result;
    }
};

template <typename Tto>
class convertImpl<
    Tto,
    std::enable_if_t<std::is_same<UT_IntArray, NET_remove_cref_t<Tto>>::value>>
{
public:
    static Tto cast(const UT_StringHolder &source)
    {
        UT_StringView view_source(source.buffer());
        UT_StringViewArray values = view_source.split(",");
        UT_IntArray result;
        result.setCapacity(values.entries());
        for (auto &&value : values)
        {
            UT_String str(value);
            result.emplace_back(str.toInt());
        }

        return result;
    }
};

template <typename Tto>
class convertImpl<Tto,
                  std::enable_if_t<std::is_integral<Tto>::value &&
                                   !std::is_same<Tto, bool>::value>>
{
public:
    // Return integer
    static Tto cast(const UT_StringHolder &source)
    {
        UT_ASSERT(source.isInteger());
        return source.toInt();
    }
};

template <typename Tto>
class convertImpl<Tto, std::enable_if_t<std::is_floating_point<Tto>::value>>
{
public:
    // Return float
    static Tto cast(const UT_StringHolder &source)
    {
        UT_ASSERT(source.isFloat());
        return source.toFloat();
    }
};

template <typename Tto>
class convertImpl<Tto, std::enable_if_t<std::is_same<bool, Tto>::value>>
{
public:
    // Return bool
    static Tto cast(const UT_StringHolder &source)
    {
        if (source.isInteger())
            return source.toInt();

        UT_StringRef low_source = source.toLower();
        return low_source == "true";
    }
};

} // namespace NET_ConvertToType

template <typename Tto, typename Tfrom>
Tto
convert(const Tfrom &source)
{
    return NET_ConvertToType::convertImpl<Tto>::cast(source);
}

#endif // __NET_ConvertToType_H__