jsonserialization.h

Go to the documentation of this file.

/********************************************************************************************
 * Twitch Broadcasting SDK
 *
 * This software is supplied under the terms of a license agreement with Twitch Interactive, Inc. and
 * may not be copied or used except in accordance with the terms of that agreement
 * Copyright (c) 2012-2016 Twitch Interactive, Inc.
 *********************************************************************************************/

#pragma once

#include "twitchsdk/core/json/value.h"
#include "twitchsdk/core/json/reader.h"
#include "twitchsdk/core/json/writer.h"
#include "twitchsdk/core/json/corejsonutil.h"
#include "twitchsdk/core/types/coretypes.h"
#include "twitchsdk/core/stringutilities.h"

namespace ttv
{
    namespace json
    {
        template <typename ObjectType>
        bool ToJson(const ObjectType& object, ttv::json::Value& value);
        
        template <typename ObjectType>
        bool ToJsonString(const ObjectType& object, std::string& jsonString);
        
        template <typename ObjectType>
        bool ToObject(const ttv::json::Value& value, ObjectType& object);
        
        template <typename ObjectType>
        bool ToObject(const std::string& jsonString, ObjectType& object);
        
        template <typename ObjectType>
        bool ToObject(const char* jsonString, ObjectType& object);
        
        struct IntegerSchema;
        struct FloatingPointSchema;
        struct StringSchema;
        struct BooleanSchema;
        struct DateSchema;
        struct ColorSchema;
        
        template <typename ElementSchema, typename ElementType>
        struct ArraySchema;
        
        template <typename EnumDescription>
        struct EnumSchema;
        
        template <typename EnumType>
        class EnumMapping;
        
        template <typename EnumType>
        auto make_enum_mapping(const char* string, EnumType value);
        
        template <typename ObjectDescription>
        struct ObjectSchema;
        
        struct RequiredField;
        struct OptionalField;
        
        template <typename ValueType, typename RequiredType, typename SchemaType, size_t KeyPathSize>
        class JsonField;
        
        template <typename SchemaType, typename RequiredType, typename ObjectType>
        auto make_field(const char* key, ObjectType& field);
        
        template <typename SchemaType, typename RequiredType, typename ObjectType, size_t ArraySize>
        auto make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field);
        
        template <typename RequiredType, typename ObjectType>
        auto make_field(const char* key, ObjectType& field);
        
        template <typename RequiredType, typename ObjectType, size_t ArraySize>
        auto make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field);
        
        template <typename ObjectType>
        auto make_field(const char* key, ObjectType& field);
        
        template <typename ObjectType, size_t ArraySize>
        auto make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field);
        
        template <typename ObjectType, typename Enable = void>
        struct DefaultSchemaProvider;
        
        template <typename ObjectType>
        using DefaultSchema = typename DefaultSchemaProvider<ObjectType>::Type;
        
        template <typename ...Args>
        std::array<const char*, sizeof...(Args)> MakeKeyPath(Args... args);
    }
}


template <typename ObjectType>
bool ttv::json::ToJson(const ObjectType& object, ttv::json::Value& value)
{
    return DefaultSchema<std::decay_t<ObjectType>>::Emit(object, value);
}


template <typename ObjectType>
bool ttv::json::ToJsonString(const ObjectType& object, std::string& jsonString)
{
    ttv::json::Value value;
    if (ToJson(object, value))
    {
        ttv::json::FastWriter writer;
        jsonString = writer.write(value);
        return true;
    }
    else
    {
        return false;
    }
}


template <typename ObjectType>
bool ttv::json::ToObject(const ttv::json::Value& value, ObjectType& object)
{
    return DefaultSchema<std::decay_t<ObjectType>>::Parse(value, object);
}


template <typename ObjectType>
bool ttv::json::ToObject(const std::string& jsonString, ObjectType& object)
{
    ttv::json::Value value;
    ttv::json::Reader reader;
    if (reader.parse(jsonString, value))
    {
        return ToObject(value, object);
    }
    else
    {
        return false;
    }
}


template <typename ObjectType>
bool ttv::json::ToObject(const char* jsonString, ObjectType& object)
{
    return ToObject(std::string{jsonString}, object);
}


struct ttv::json::IntegerSchema
{
    template <typename IntegralType>
    static bool Parse(const ttv::json::Value& value, IntegralType& output)
    {
        if (value.isNull())
        {
            return false;
        }
        else if (value.isString())
        {
            return ParseNum(value.asString(), output);
        }
        else if (value.isNumeric())
        {
            output = static_cast<IntegralType>(value.asUInt());
            return true;
        }
        else
        {
            return false;
        }
    }
    
    
    template <typename IntegralType>
    static bool Emit(IntegralType input, ttv::json::Value& value)
    {
        value = static_cast<ttv::json::Value::UInt>(input);
        return true;
    }
};


struct ttv::json::FloatingPointSchema
{
    template <typename FloatingPointType>
    static bool Parse(const ttv::json::Value& value, FloatingPointType& output)
    {
        if (value.isNull())
        {
            return false;
        }
        else if (value.isNumeric())
        {
            output = static_cast<FloatingPointType>(value.asDouble());
            return true;
        }
        else
        {
            return false;
        }
    }
    
    
    template <typename FloatingPointType>
    static bool Emit(FloatingPointType input, ttv::json::Value& value)
    {
        value = static_cast<double>(input);
        return true;
    }
};


struct ttv::json::StringSchema
{
    static bool Parse(const ttv::json::Value& value, std::string& output)
    {
        if (value.isNull() || !value.isString())
        {
            return false;
        }
        else
        {
            output = value.asString();
            return true;
        }
    }
    
    
    static bool Emit(const std::string& input, ttv::json::Value& value)
    {
        value = input;
        return true;
    }
};


struct ttv::json::BooleanSchema
{
    static bool Parse(const ttv::json::Value& value, bool& output)
    {
        if (value.isNull() || !value.isBool())
        {
            return false;
        }
        else
        {
            output = value.asBool();
            return true;
        }
    }
    
    
    static bool Emit(const bool& input, ttv::json::Value& value)
    {
        value = input;
        return true;
    }
};


struct ttv::json::DateSchema
{
    static bool Parse(const ttv::json::Value& value, ttv::Timestamp& output)
    {
        if (value.isNull())
        {
            return false;
        }
        else if (value.isNumeric())
        {
            output = static_cast<Timestamp>(value.asUInt());
            return true;
        }
        else if (value.isString())
        {
            return ttv::RFC3339TimeToUnixTimestamp(value.asString(), output);
        }
        else
        {
            return false;
        }
    }
    
    
    static bool Emit(ttv::Timestamp input, ttv::json::Value& value)
    {
        value = ttv::UnixTimestampToRFC3339String(input);
        return true;
    }
};


struct ttv::json::ColorSchema
{
    static bool Parse(const ttv::json::Value& value, ttv::Color& output)
    {
        output = 0xFF000000;

        if (value.isNull())
        {
            return false;
        }
        else if (value.isString())
        {
            return ParseColor(value.asString(), output);
        }
        else
        {
            return false;
        }
    }
    
    // Emit(ttv::Color, ttv::json::Value&) intentionally unimplemented
};


template <typename ElementSchema, typename ElementType>
struct ttv::json::ArraySchema
{
    template <typename ContainerType>
    static bool Parse(const ttv::json::Value& value, ContainerType& output)
    {
        if (value.isNull() || !value.isArray())
        {
            return false;
        }
        
        for (const auto& element : value)
        {
            output.emplace_back();
            if (!ElementSchema::Parse(element, output.back()))
            {
                output.clear();
                return false;
            }
        }
        
        return true;
    }
    
    
    template <typename ContainerType>
    static bool Emit(const ContainerType& input, ttv::json::Value& value)
    {
        for (const auto& element : input)
        {
            ttv::json::Value elementValue;
            if (ElementSchema::Emit(element, value))
            {
                value.append(elementValue);
            }
            else
            {
                value = ttv::json::nullValue;
                return false;
            }
        }
        return true;
    }
};


template <typename EnumDescription>
struct ttv::json::EnumSchema
{
    template <typename EnumType>
    static bool Parse(const ttv::json::Value& value, EnumType& output)
    {
        if (value.isNull() || !value.isString())
        {
            return false;
        }
        else
        {
            return FindEnumMatch(EnumDescription::EnumMap(), value, output);
        }
    }
    
    template <typename EnumType>
    static bool Emit(EnumType input, ttv::json::Value& value)
    {
        return FindStringMatch(EnumDescription::EnumMap(), input, value);
    }
    
private:
    template <typename MapTuple, typename EnumType>
    static bool FindEnumMatch(const MapTuple& tuple, const ttv::json::Value& value, EnumType& output)
    {
        return FindEnumMatchFromIndex<0>(tuple, value, output);
    }

    
    template <int index, typename MapTuple, typename EnumType>
    static std::enable_if_t<(index < std::tuple_size<MapTuple>::value), bool> FindEnumMatchFromIndex(const MapTuple& tuple, const ttv::json::Value& value, EnumType& output)
    {
        auto mapping = std::get<index>(tuple);
        if (mapping.Match(value))
        {
            output = mapping.GetValue();
            return true;
        }
        else
        {
            return FindEnumMatchFromIndex<index + 1>(tuple, value, output);
        }
    }
    
    
    template <int index, typename MapTuple, typename EnumType>
    static std::enable_if_t<(index >= std::tuple_size<MapTuple>::value), bool> FindEnumMatchFromIndex(const MapTuple& /*tuple*/, const ttv::json::Value& /*value*/, EnumType& output)
    {
        return ApplyDefault<EnumDescription>(output, 0);
    }
    
    
    template <typename Description, typename EnumType, typename = decltype(Description::GetFallbackValue())>
    static bool ApplyDefault(EnumType& output, int /*n*/)
    {
        // This overload will be selected if the description has defined the GetFallbackValue() static method.
        output = Description::GetFallbackValue();
        return true;
    }
    
    
    template <typename Description, typename EnumType>
    static bool ApplyDefault(EnumType& /*output*/, long /*n*/)
    {
        // This overload will be selected if the description has not defined the GetFallbackValue() static method.
        // The second argument type is of type long, so that when a numeric literal is passed in, it will prefer
        // to bind to the above method (with an int parameter), if it is available, instead of this one.
        return false;
    }
    
    
    template <typename MapTuple, typename EnumType>
    static bool FindStringMatch(const MapTuple& tuple, EnumType input, ttv::json::Value& value)
    {
        return FindStringMatchFromIndex<0>(tuple, input, value);
    }
    
    template <int index, typename MapTuple, typename EnumType>
    static std::enable_if_t<(index < std::tuple_size<MapTuple>::value), bool> FindStringMatchFromIndex(const MapTuple& tuple, EnumType input, ttv::json::Value& value)
    {
        auto mapping = std::get<index>(tuple);
        if (mapping.GetValue() == input)
        {
            value = mapping.GetString();
            return true;
        }
        else
        {
            return FindStringMatchFromIndex<index + 1>(tuple, input, value);
        }
    }
    
    template <int index, typename MapTuple, typename EnumType>
    static std::enable_if_t<(index >= std::tuple_size<MapTuple>::value), bool> FindStringMatchFromIndex(const MapTuple& /*tuple*/, EnumType /*input*/, ttv::json::Value& /*value*/)
    {
        return false;
    }
};


template <typename EnumType>
class ttv::json::EnumMapping
{
public:
    constexpr EnumMapping(const char* string, EnumType value)
    :   mString(string)
    ,   mValue(value)
    {
    }
    
    
    template <typename InputType>
    constexpr bool Match(const InputType& type) const
    {
        return type == mString;
    }
    
    
    constexpr EnumType GetValue() const
    {
        return mValue;
    }
    
    
    constexpr const char* GetString() const
    {
        return mString;
    }
    
private:
    const char* mString;
    EnumType mValue;
};


template <typename EnumType>
auto ttv::json::make_enum_mapping(const char* string, EnumType value)
{
    return EnumMapping<EnumType>{string, value};
}

    
template <typename ObjectDescription>
struct ttv::json::ObjectSchema
{
    template <typename OutputType>
    static bool Parse(const ttv::json::Value& value, OutputType& output)
    {
        if (value.isNull() || !value.isObject())
        {
            return false;
        }
        
        if (ParseValues(value, ObjectDescription::BindFields(output)))
        {
            return true;
        }
        else
        {
            output = {};
            return false;
        }
    }
    
    
    template <typename InputType>
    static bool Emit(const InputType& input, ttv::json::Value& value)
    {
        if (EmitValues(value, ObjectDescription::BindFields(input)))
        {
            return true;
        }
        else
        {
            value = ttv::json::nullValue;
            return false;
        }
    }
    
    
private:
    template <typename FieldsTuple>
    static bool ParseValues(const ttv::json::Value& value, FieldsTuple&& tuple)
    {
        return ParseValuesAtIndex<0>(value, std::forward<FieldsTuple>(tuple));
    }
    
    
    template <int index, typename FieldsTuple>
    static std::enable_if_t<(index < std::tuple_size<FieldsTuple>::value), bool> ParseValuesAtIndex(const ttv::json::Value& value, FieldsTuple&& tuple)
    {
        auto field = std::get<index>(tuple);
        if (!field.Parse(value) && decltype(field)::IsRequired)
        {
            return false;
        }
        else
        {
            return ParseValuesAtIndex<index + 1>(value, std::forward<FieldsTuple>(tuple));
        }
    }
    
    
    template <int index, typename FieldsTuple>
    static std::enable_if_t<(index >= std::tuple_size<FieldsTuple>::value), bool> ParseValuesAtIndex(const ttv::json::Value& /*value*/, FieldsTuple&& /*tuple*/)
    {
        return true;
    }
    
    
    template <typename FieldsTuple>
    static bool EmitValues(ttv::json::Value& value, FieldsTuple&& tuple)
    {
        return EmitValuesAtIndex<0>(value, std::forward<FieldsTuple&&>(tuple));
    }
    
    
    template <int index, typename FieldsTuple>
    static std::enable_if_t<(index < std::tuple_size<FieldsTuple>::value), bool> EmitValuesAtIndex(ttv::json::Value& value, FieldsTuple&& tuple)
    {
        auto field = std::get<index>(tuple);
        if (!field.Emit(value) && decltype(field)::IsRequired)
        {
            return false;
        }
        else
        {
            return EmitValuesAtIndex<index + 1>(value, std::forward<FieldsTuple>(tuple));
        }
    }
    
    
    template <int index, typename FieldsTuple>
    static std::enable_if_t<(index >= std::tuple_size<FieldsTuple>::value), bool> EmitValuesAtIndex(ttv::json::Value& /*value*/, FieldsTuple&& /*tuple*/)
    {
        return true;
    }
};


struct ttv::json::RequiredField
{
    static constexpr bool IsRequired = true;
};

struct ttv::json::OptionalField
{
    static constexpr bool IsRequired = false;
};


template <typename ValueType, typename RequiredType, typename SchemaType>
class ttv::json::JsonField<ValueType, RequiredType, SchemaType, 1>
{
public:
    static constexpr bool IsRequired = RequiredType::IsRequired;
    
    JsonField(const char* key, ValueType& object)
    :   mKey(key)
    ,   mValue(object)
    {
    }
    
    
    bool Parse(const ttv::json::Value& parent)
    {
        return SchemaType::Parse(parent[mKey], mValue);
    }
    
    
    bool Emit(ttv::json::Value& parent)
    {
        return SchemaType::Emit(mValue, parent[mKey]);
    }
    
    
private:
    const char* mKey;
    ValueType& mValue;
};


template <typename ValueType, typename RequiredType, typename SchemaType, size_t ArraySize>
class ttv::json::JsonField
{
    static_assert(ArraySize != 0, "Key path for JSON field must have at least one key.");

public:
    static constexpr bool IsRequired = RequiredType::IsRequired;
    
    JsonField(const std::array<const char*, ArraySize>& keyPath, ValueType& object)
    :   mKeyPath(keyPath)
    ,   mValue(object)
    {
    }
    
    
    bool Parse(const ttv::json::Value& parent)
    {
        return ParseHelper<0>(parent);
    }
    
    
    bool Emit(ttv::json::Value& parent)
    {
        return EmitHelper<0>(parent);
    }
    
    
private:
    template <int index>
    std::enable_if_t<(index < ArraySize - 1), bool> ParseHelper(const ttv::json::Value& parent)
    {
        const auto& jIntermediate = parent[mKeyPath[index]];
        
        if(jIntermediate.isNull() || !jIntermediate.isObject())
        {
            return false;
        }
        
        return ParseHelper<index + 1>(jIntermediate);
    }
    
    
    template <int index>
    std::enable_if_t<(index == ArraySize - 1), bool> ParseHelper(const ttv::json::Value& parent)
    {
        return SchemaType::Parse(parent[mKeyPath[index]], mValue);
    }
    
    
    template <int index>
    std::enable_if_t<(index < ArraySize - 1), bool> EmitHelper(ttv::json::Value& parent)
    {
        auto& jIntermediate = parent[mKeyPath[index]];
        
        return EmitHelper<index + 1>(jIntermediate);
    }
    
    
    template <int index>
    std::enable_if_t<(index == ArraySize - 1), bool> EmitHelper(ttv::json::Value& parent)
    {
        return SchemaType::Emit(mValue, parent[mKeyPath[index]]);
    }
    
    
    std::array<const char *, ArraySize> mKeyPath;
    ValueType& mValue;
};


template <typename SchemaType, typename RequiredType, typename ObjectType>
auto ttv::json::make_field(const char* key, ObjectType& field)
{
    return ttv::json::JsonField<ObjectType, RequiredType, SchemaType, 1>{key, field};
}


template <typename SchemaType, typename RequiredType, typename ObjectType, size_t ArraySize>
auto ttv::json::make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field)
{
    return ttv::json::JsonField<ObjectType, RequiredType, SchemaType, ArraySize>{keyPath, field};
}


template <typename RequiredType, typename ObjectType>
auto ttv::json::make_field(const char* key, ObjectType& field)
{
    return make_field<DefaultSchema<std::decay_t<ObjectType>>, RequiredType, ObjectType>(key, field);
}


template <typename RequiredType, typename ObjectType, size_t ArraySize>
auto ttv::json::make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field)
{
    return make_field<DefaultSchema<std::decay_t<ObjectType>>, RequiredType, ObjectType, ArraySize>(keyPath, field);
}


template <typename ObjectType>
auto ttv::json::make_field(const char* key, ObjectType& field)
{
    return make_field<DefaultSchema<std::decay_t<ObjectType>>, OptionalField, ObjectType>(key, field);
}


template <typename ObjectType, size_t ArraySize>
auto ttv::json::make_field(const std::array<const char*, ArraySize>& keyPath, ObjectType& field)
{
    return make_field<DefaultSchema<std::decay_t<ObjectType>>, OptionalField, ObjectType, ArraySize>(keyPath, field);
}


template <typename ObjectType, typename Enable>
struct ttv::json::DefaultSchemaProvider
{
    static_assert(sizeof(ObjectType) < 0, "Default schema not found for object.");
};


template <typename IntegralType>
struct ttv::json::DefaultSchemaProvider<IntegralType, std::enable_if_t<std::is_integral<IntegralType>::value>>
{
    using Type = IntegerSchema;
};


template <typename FloatingPointType>
struct ttv::json::DefaultSchemaProvider<FloatingPointType, std::enable_if_t<std::is_floating_point<FloatingPointType>::value>>
{
    using Type = FloatingPointSchema;
};


template <>
struct ttv::json::DefaultSchemaProvider<std::string>
{
    using Type = StringSchema;
};


template <>
struct ttv::json::DefaultSchemaProvider<bool>
{
    using Type = BooleanSchema;
};


template <typename ElementType>
struct ttv::json::DefaultSchemaProvider<std::vector<ElementType>>
{
    using Type = ArraySchema<DefaultSchema<ElementType>, ElementType>;
};


template <typename ...Args>
std::array<const char*, sizeof...(Args)> ttv::json::MakeKeyPath(Args... args)
{
    return std::array<const char*, sizeof...(Args)>{{args...}};
}