RapidJsonUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "RapidJsonIncludes.h"
#include "Misc/Optional.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "Templates/ValueOrError.h"
 
namespace UE::Json
{
namespace Private
{
    // TODO: Can remove this and just use rapidjson::CrtAllocator once RapidJsonIncludes.h starts overriding RAPIDJSON_MALLOC, etc
    class FAllocatorImpl
    {
    public:
        static const bool kNeedFree = true;
 
        void* Malloc(size_t Count)
        {
            return FMemory::Malloc(Count);
        }
 
        void* Realloc(void* Original, size_t, size_t Count)
        {
            if (Count == 0)
            {
                FMemory::Free(Original);
                return nullptr;
            }
            return FMemory::Realloc(Original, Count);
        }
 
        static void Free(void* Ptr)
        {
            FMemory::Free(Ptr);
        }
 
        bool operator==(const FAllocatorImpl&) const
        {
            return true;
        }
 
        bool operator!=(const FAllocatorImpl&) const
        {
            return false;
        }
    };
} // namespace UE::Json::Private
 
    // types that use TCHAR (common)
    using FEncoding = rapidjson::UTF16<TCHAR>;
    using FAllocator = Private::FAllocatorImpl;
    using FDocument = rapidjson::GenericDocument<FEncoding, FAllocator>;
    using FStringRef = FDocument::StringRefType;
    using FValue = FDocument::ValueType;
    using FMember = FValue::Member;
    
    // types that use TCHAR (for reading)
    using FConstObject = FValue::ConstObject;
    using FConstArray = FValue::ConstArray;
 
    // types that use TCHAR (for writing)
    using FObject = FValue::Object;
    using FArray = FValue::Array;
    using FStringBuffer = rapidjson::GenericStringBuffer<FEncoding, FAllocator>;
    using FStringWriter = rapidjson::Writer<FStringBuffer, FEncoding, FEncoding, FAllocator>;
    using FPrettyStringWriter = rapidjson::PrettyWriter<FStringBuffer, FEncoding, FEncoding, FAllocator>;
 
    inline FStringRef MakeStringRef(FStringView Str)
    {
        return FStringRef(Str.GetData(), Str.Len());
    }
 
    inline FValue MakeStringValue(FStringView Str, FAllocator& Allocator)
    {
        return FValue(Str.GetData(), Str.Len(), Allocator);
    }
 
    JSON_API TOptional<bool> GetBoolField(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<int32> GetInt32Field(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<uint32> GetUint32Field(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<int64> GetInt64Field(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<uint64> GetUint64Field(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<double> GetDoubleField(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<FStringView> GetStringField(FConstObject Object, const TCHAR* FieldName);
 
    template<typename TEnum>
    inline TOptional<TEnum> GetEnumField(FConstObject Object, const TCHAR* FieldName)
    {
        TEnum Value;
        TOptional<FStringView> StringView = GetStringField(Object, FieldName);
 
        if (StringView.IsSet() && LexTryParseString(Value, *StringView))
        {
            return Value;
        }
 
        return {};
    }
 
    JSON_API TOptional<FConstObject> GetObjectField(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<FConstArray> GetArrayField(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API bool HasNullField(FConstObject Object, const TCHAR* FieldName);
 
    JSON_API TOptional<FConstObject> GetRootObject(const FDocument& Document);
 
    struct FParseError
    {
        rapidjson::ParseErrorCode ErrorCode = rapidjson::kParseErrorNone;
        size_t Offset = 0;
 
        JSON_API FString CreateMessage(const FStringView JsonText) const;
    };
 
    JSON_API TValueOrError<FDocument, FParseError> Parse(const FStringView JsonText);
 
    JSON_API TValueOrError<FDocument, FParseError> ParseInPlace(TArrayView<TCHAR> JsonText);
 
    JSON_API FString WriteCompact(const FDocument& Document);
 
    JSON_API FString WritePretty(const FDocument& Document);
 
    JSON_API const TCHAR* GetValueTypeName(const FValue& Value);
 
} // namespace UE::Json