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_JSONWriter.h>
#include <UT/UT_SGuid.h>
#include <UT/UT_String.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringSet.h>
#include <UT/UT_StringView.h>
#include <UT/UT_WorkBuffer.h>
#include <UT/UT_Options.h>
#include <UT/UT_Url.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_StringRef>(UT_JSONWriter& writer, const UT_StringRef& obj)
{
    writer.jsonValue(obj);
    return true;
}

template <>
inline bool NETserialize<UT_StringRef>(const UT_JSONValue& data, UT_StringRef& obj)
{
    return false;
}

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 UT_SGuid
// -----------------------------------------------------------------------------

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

template <>
inline bool NETserialize<UT_SGuid>(const UT_JSONValue& data, UT_SGuid& id)
{
    UT_StringHolder str;
    if (!data.import(str))
        return false;

    return id.setString(str);
}

// -----------------------------------------------------------------------------
// 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.isArray())
        return false;
    exint size = data.count();
    items.setSize(size);
    for (auto&& [index, value] : data.enumerate())
    {
        NETserialize<T>(value, items[index]);
    }
    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 Sets
// -----------------------------------------------------------------------------

template <typename SetT>
inline bool NETserializeSet(UT_JSONWriter& writer, const SetT& items)
{
    using T = typename SetT::value_type;
    writer.jsonBeginArray();
    for (auto&& item : items)
        NETserialize<T>(writer, item);
    writer.jsonEndArray();
    return true;   
}

template <typename SetT>
inline bool NETserializeSet(const UT_JSONValue& data, SetT& items)
{
    using T = typename SetT::value_type;
    static_assert(
            std::is_default_constructible_v<T>,
            "Serialize of a set requires the type to be default constructibe");
    // To support some older clients that were sending empty strings in place
    // of empty arrays.
    if (data.getType() == UT_JSONValue::JSON_STRING)
    {
        UT_StringHolder str = data.getString();
        if (str.isEmpty())
            return true;
    }
    if (!data.isArray())
        return false;
    for (auto&& value : data)
    {
        T items_value;
        NETserialize<T>(value, items_value);
        items.emplace(items_value);
    }
    return true;
}

#define NET_DEFINE_SET_SERIALIZER(_SET_) \
template <typename T>   \
inline bool NETserialize(UT_JSONWriter& writer, const _SET_<typename T::value_type>& items)     \
{   \
    return NETserializeSet<T>(writer, items);    \
}   \
template <typename T>   \
inline bool NETserialize(const UT_JSONValue& data, _SET_<typename T::value_type>& items)   \
{   \
    return NETserializeSet<T>(data, items);     \
}
NET_DEFINE_SET_SERIALIZER(UT_Set)
#undef NET_DEFINE_SET_SERIALIZER

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

template <>
inline bool
NETserialize<UT_StringSet>(const UT_JSONValue& data, UT_StringSet& 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 NETserializeSet<UT_StringSet>(data, 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_Options
// -----------------------------------------------------------------------------

template <>
inline bool
NETserialize<UT_OptionsHolder>(
        UT_JSONWriter& writer,
        const UT_OptionsHolder& opts)
{
    return opts.options()->save(writer);
}

template <>
inline bool
NETserialize<UT_OptionsHolder>(const UT_JSONValue& value, UT_OptionsHolder& opts)
{
    if (!value.isMap())
        return false;
    const UT_JSONValueMap* m = value.getMap();
    UT_Options* o = opts.makeUnique();
    return o->load(*m, false);
}

// -----------------------------------------------------------------------------
// Serialize std::pair<>
// -----------------------------------------------------------------------------
template <typename T1, typename T2>
inline bool
NETserializePair(
        UT_JSONWriter &writer,
        const std::pair<T1, T2> &obj)
{
    writer.jsonBeginArray();
    NETserialize<T1>(writer, obj.first);
    NETserialize<T2>(writer, obj.second);
    writer.jsonEndArray();
    return true;
}

template <typename T1, typename T2>
inline bool
NETserializePair(
        const UT_JSONValue &data,
        std::pair<T1, T2> &obj)
{
    if (data.isArray() && data.count() == 2)
    {
        return NETserialize<T1>(data[0], obj.first)
               && NETserialize<T2>(data[1], obj.second);
    }
    return false;
}

template <typename T>
inline bool
NETserialize(
        UT_JSONWriter& writer,
        const std::pair<typename T::first_type, typename T::second_type>& p)
{
    return NETserializePair(writer, p);
}
template <typename T>
inline bool
NETserialize(
        const UT_JSONValue& data,
        std::pair<typename T::first_type, typename T::second_type>& p)
{
    return NETserializePair(data, p);
}

// -----------------------------------------------------------------------------
// UT_Url
// -----------------------------------------------------------------------------

template <>
inline bool
NETserialize<UT_Url>(UT_JSONWriter& writer, const UT_Url& url)
{
    return writer.jsonValue(url.toString());
}

template <>
inline bool
NETserialize<UT_Url>(const UT_JSONValue& data, UT_Url& url)
{
    if (data.getType() == UT_JSONValue::JSON_STRING)
    {
        url.parse(data.getString());
        return true;
    }
    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__