JSON.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
// uLang JOSN support
#pragma once
 
#include "uLang/Common/Containers/Array.h"
#include "uLang/Common/Text/UTF8String.h"
#include "uLang/Common/Misc/Optional.h"
 
ULANG_THIRD_PARTY_INCLUDES_START
#include "rapidjson/document.h"
#include "rapidjson/prettywriter.h"
ULANG_THIRD_PARTY_INCLUDES_END
 
namespace uLang
{
 
//====================================================================================
// RapidJSON configuration
//====================================================================================
 
class JSONAllocator
{
public:
    static void* Malloc(size_t Size) 
    { 
        return GetSystemParams()._HeapMalloc(Size);
    }
    static void* Realloc(void* OriginalPtr, size_t OriginalSize, size_t NewSize)
    {
        return GetSystemParams()._HeapRealloc(OriginalPtr, NewSize);
    }
    static void Free(void* Ptr)
    {
        GetSystemParams()._HeapFree(Ptr);
    }
};
 
using JSONMemoryPoolAllocator = rapidjson::MemoryPoolAllocator<JSONAllocator>;
using JSONDocument = rapidjson::GenericDocument<rapidjson::UTF8<char>, JSONMemoryPoolAllocator, JSONAllocator>;
using JSONGenericMemberIterator = rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, JSONMemoryPoolAllocator>;
using JSONValue = JSONDocument::ValueType;
using JSONStringBuffer = rapidjson::StringBuffer;
using JSONStringWriter = rapidjson::PrettyWriter<JSONStringBuffer>;
using JSONStringRef = rapidjson::GenericStringRef<char>;
 
//====================================================================================
// Utility functions
//====================================================================================
 
ULANGJSON_API CUTF8String EscapeJSON(const CUTF8StringView& RawText);
 
ULANGJSON_API CUTF8String EscapeJSON(const UTF8Char Ch);
 
 
//====================================================================================
// JSON -> C++ conversion functions
// Overloads of the function FromJSON for various data types
// Supplement these by adding your own overloads for FromJSON
//====================================================================================
 
inline bool FromJSON(const JSONValue& JSON, bool* Value)
{
    if (JSON.IsBool())
    {
        *Value = JSON.GetBool();
        return true;
    }
    return false;
}
 
inline bool FromJSON(const JSONValue& JSON, int* Value)
{
    if (JSON.IsInt())
    {
        *Value = JSON.GetInt();
        return true;
    }
    return false;
}
 
inline bool FromJSON(const JSONValue& JSON, uint32_t* Value)
{
    if (JSON.IsUint())
    {
        *Value = JSON.GetUint();
        return true;
    }
    return false;
}
 
inline bool FromJSON(const JSONValue& JSON, uint64_t* Value)
{
    if (JSON.IsUint64())
    {
        *Value = JSON.GetUint64();
        return true;
    }
    return false;
}
 
inline bool FromJSON(const JSONValue& JSON, CUTF8String* Value)
{
    if (JSON.IsString())
    {
        *Value = CUTF8StringView(JSON.GetString(), JSON.GetStringLength());
        return true;
    }
    return false;
}
 
inline bool FromJSON(const JSONValue& JSON, CUTF8StringView* Value)
{
    if (JSON.IsString())
    {
        *Value = CUTF8StringView(JSON.GetString(), JSON.GetStringLength());
        return true;
    }
    return false;
}
 
template<class T>
bool FromJSON(const JSONValue& JSON, TOptional<T>* OptionalValue)
{
    if (JSON.IsNull())
    {
        *OptionalValue = EResult::Unspecified;
        return true;
    }
 
    T Value;
    if (FromJSON(JSON, &Value))
    {
        *OptionalValue = Value;
        return true;
    }
 
    return false;
}
 
template<class T>
bool FromJSON(const JSONValue& JSON, TArray<T>* ArrayValue)
{
    if (JSON.IsArray())
    {
        ArrayValue->SetNum(JSON.Size());
        for (uint32_t i = 0; i < JSON.Size(); ++i)
        {
            if (!FromJSON(JSON[i], &(*ArrayValue)[i]))
            {
                return false;
            }
        }
        return true;
    }
 
    return false;
}
 
template<class T>
bool FromJSON(const JSONValue& JSON, const char* MemberName, T* MemberValue, TOptional<bool> bRequired = EResult::Unspecified)
{
    if (!JSON.IsObject())
    {
        return false;
    }
 
    auto Member = JSON.FindMember(MemberName);
    if (Member != JSON.MemberEnd())
    {
        return FromJSON(Member->value, MemberValue);
    }
 
    // Fail if required or if T wasn't optional
    return bRequired ? !*bRequired : bool(TIsOptional<typename TRemovePointer<T>::Type>::Value);
}
 
inline bool ToJSON(bool Value, JSONValue* JSON, JSONMemoryPoolAllocator&)
{
    if (!JSON)
    {
        return false;
    }
 
    JSON->SetBool(Value);
    return true;
}
 
inline bool ToJSON(int Value, JSONValue* JSON, JSONMemoryPoolAllocator&)
{
    if (!JSON)
    {
        return false;
    }
 
    JSON->SetInt(Value);
    return true;
}
 
inline bool ToJSON(uint32_t Value, JSONValue* JSON, JSONMemoryPoolAllocator&)
{
    if (!JSON)
    {
        return false;
    }
 
    JSON->SetUint(Value);
    return true;
}
 
inline bool ToJSON(CUTF8StringView Value, JSONValue* JSON, JSONMemoryPoolAllocator& Allocator)
{
    if (!JSON)
    {
        return false;
    }
 
    JSON->SetString((const char*)Value._Begin, Value.ByteLen(), Allocator);
    return true;
}
 
template<class T>
bool ToJSON(const TOptional<T>& OptionalValue, JSONValue* JSON, JSONMemoryPoolAllocator& Allocator)
{
    if (!OptionalValue.IsSet())
    {
        return true;
    }
 
    if (ToJSON(*OptionalValue, JSON, Allocator))
    {
        return true;
    }
 
    return false;
}
 
template<class T>
bool ToJSON(const TArray<T>& ArrayValue, JSONValue* JSON, JSONMemoryPoolAllocator& Allocator)
{
    if (!JSON)
    {
        return false;
    }
 
    JSON->SetArray();
    JSON->Reserve(ArrayValue.Num(), Allocator);
 
    for (const T& i : ArrayValue)
    {
        JSONValue Elem;
        if (!ToJSON(i, &Elem, Allocator))
        {
            return false;
        }
 
        JSON->PushBack(Elem, Allocator);
    }
 
    return true;
}
 
template<class T>
bool ToJSON(const T& MemberValue, const char* MemberName, JSONValue* JSON, JSONMemoryPoolAllocator& Allocator)
{
    if (!JSON)
    {
        return false;
    }
 
    JSONValue Member;
    if (!ToJSON(MemberValue, &Member, Allocator))
    {
        return false;
    }
 
    JSON->AddMember(JSONStringRef(MemberName), Member, Allocator);
 
    return true;
}
 
template<class T>
bool ToJSON(const TOptional<T>& MemberValue, const char* MemberName, JSONValue* JSON, JSONMemoryPoolAllocator& Allocator)
{
    if (!JSON)
    {
        return false;
    }
 
    if (!MemberValue.IsSet())
    {
        return true;
    }
 
    return ToJSON(MemberValue.GetValue(), MemberName, JSON, Allocator);
}
 
} // namespace uLang