Serializer.h

Go to the documentation of this file.

// Copyright(c) PixoVR, LLC. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Serialization/MemoryReader.h"
#include "Serialization/ObjectAndNameAsStringProxyArchive.h"
#include "Async/Async.h"
#include "Serialization/ArchiveLoadCompressedProxy.h"
#include "Serialization/ArchiveSaveCompressedProxy.h"
#include "Serializer.generated.h"
 
USTRUCT()
struct PIXOCORE_API FSerializedModel
{   
    GENERATED_BODY()
 
    UPROPERTY() UClass* Class;
    UPROPERTY() TArray<uint8> Data;
    UPROPERTY() bool bCompressed = false;
};
 
 
namespace
{
    namespace BinarySerializer
    {
 
        FSerializedModel Serialize(UObject* Object)
        {
            FSerializedModel Model;
            Model.Class = Object->GetClass();
            FMemoryWriter MemoryWriter(Model.Data, true);
            FObjectAndNameAsStringProxyArchive Ar(MemoryWriter, true);
            Object->Serialize(Ar);
 
            return Model;
        }
 
        FSerializedModel SerializeCompressed(UObject* Object)
        {
            FSerializedModel Model = Serialize(Object);
            TArray<uint8> SerializedData = MoveTemp(Model.Data);
            FArchiveSaveCompressedProxy Compressor(Model.Data, NAME_LZ4, COMPRESS_BiasSpeed);
            Compressor << SerializedData;
            Compressor.Flush();
            Model.bCompressed = true;
            
            return Model;
        }
 
        template<typename T, typename TCheck = typename std::enable_if<std::is_base_of<UObject, T>::value, void*>::type>
        T* Deserialize(const FSerializedModel& Model, UObject* Outer)
        {
            T* Instance = NewObject<T>(Outer, Model.Class);
            FMemoryReader MemoryReader(Model.Data, true);
            FObjectAndNameAsStringProxyArchive Ar(MemoryReader, true);
            Instance->Serialize(Ar);
            
            return Instance;
        }
 
        template<typename T, typename TCheck = typename std::enable_if<std::is_base_of<UObject, T>::value, void*>::type>
        T* DeserializeCompressed(const FSerializedModel& Model, UObject* Outer)
        {
            TArray<uint8> DecompressedData;
            FArchiveLoadCompressedProxy MemoryReader(Model.Data, NAME_LZ4);
            MemoryReader << DecompressedData;
            MemoryReader.Flush();
 
            const FSerializedModel DecompressedModel = { Model.Class, MoveTemp(DecompressedData) };
            
            return Deserialize<T>(DecompressedModel, Outer);
        }
        
        void SerializeAsync(UObject* Object, TFunction<void(FSerializedModel&)> Callback, bool Compress = false)
        {
            Async(EAsyncExecution::TaskGraph, [Object, Callback, Compress]()
            {
                FSerializedModel Model = Compress ? SerializeCompressed(Object) : Serialize(Object);
                Async(EAsyncExecution::TaskGraphMainThread,[Callback, Model = MoveTemp(Model)]() mutable
                {
                    Callback(Model);
                });
            });
        }
        
        template<typename T, typename TCheck = typename std::enable_if<std::is_base_of<UObject, T>::value, void*>::type>
        void DeserializeAsync(const FSerializedModel& Model, UObject* Outer, TFunction<void(T*)> Callback)
        {
            Async(EAsyncExecution::TaskGraph, [Model, Outer, Callback]()
            {
                T* Instance = Model.bCompressed ? DeserializeCompressed<T>(Model, Outer) : Deserialize<T>(Model, Outer);
                Async(EAsyncExecution::TaskGraphMainThread, [Callback, Instance]()
                {
                    Callback(Instance);
                    Instance->ClearInternalFlags(EInternalObjectFlags::Async);
                });
            });
        }
    };
};