ObjectStream.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/StaticArray.h>
#include <Jolt/Core/Reference.h>
#include <Jolt/Core/RTTI.h>
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/ObjectStream/SerializableAttribute.h>
 
#ifdef JPH_OBJECT_STREAM
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT ObjectStream : public NonCopyable
{
public:
    enum class EStreamType
    {
        Text,
        Binary,
    };
 
protected:
    virtual                         ~ObjectStream() = default;
 
    using Identifier = uint32;
 
    static constexpr int            sVersion = 1;
    static constexpr int            sRevision = 0;
    static constexpr Identifier     sNullIdentifier = 0;
};
 
class JPH_EXPORT IObjectStreamIn : public ObjectStream
{
public:
    virtual bool                ReadDataType(EOSDataType &outType) = 0;
    virtual bool                ReadName(String &outName) = 0;
    virtual bool                ReadIdentifier(Identifier &outIdentifier) = 0;
    virtual bool                ReadCount(uint32 &outCount) = 0;
 
    virtual bool                ReadPrimitiveData(uint8 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(uint16 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(int &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(uint32 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(uint64 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(float &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(double &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(bool &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(String &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Float3 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Float4 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Double3 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Vec3 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(DVec3 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Vec4 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(UVec4 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Quat &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(Mat44 &outPrimitive) = 0;
    virtual bool                ReadPrimitiveData(DMat44 &outPrimitive) = 0;
 
    virtual bool                ReadClassData(const char *inClassName, void *inInstance) = 0;
    virtual bool                ReadPointerData(const RTTI *inRTTI, void **inPointer, int inRefCountOffset = -1) = 0;
};
 
class JPH_EXPORT IObjectStreamOut : public ObjectStream
{
public:
    virtual void                WriteDataType(EOSDataType inType) = 0;
    virtual void                WriteName(const char *inName) = 0;
    virtual void                WriteIdentifier(Identifier inIdentifier) = 0;
    virtual void                WriteCount(uint32 inCount) = 0;
 
    virtual void                WritePrimitiveData(const uint8 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const uint16 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const int &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const uint32 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const uint64 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const float &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const double &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const bool &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const String &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Float3 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Float4 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Double3 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Vec3 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const DVec3 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Vec4 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const UVec4 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Quat &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const Mat44 &inPrimitive) = 0;
    virtual void                WritePrimitiveData(const DMat44 &inPrimitive) = 0;
 
    virtual void                WritePointerData(const RTTI *inRTTI, const void *inPointer) = 0;
    virtual void                WriteClassData(const RTTI *inRTTI, const void *inInstance) = 0;
 
    virtual void                HintNextItem()                                              { /* Default is do nothing */ }
    virtual void                HintIndentUp()                                              { /* Default is do nothing */ }
    virtual void                HintIndentDown()                                            { /* Default is do nothing */ }
};
 
// Define macro to declare functions for a specific primitive type
#define JPH_DECLARE_PRIMITIVE(name)                                                                         \
    JPH_EXPORT bool OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);    \
    JPH_EXPORT bool OSReadData(IObjectStreamIn &ioStream, name &outPrimitive);                              \
    JPH_EXPORT void OSWriteDataType(IObjectStreamOut &ioStream, name *);                                    \
    JPH_EXPORT void OSWriteData(IObjectStreamOut &ioStream, const name &inPrimitive);
 
// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
#include <Jolt/ObjectStream/ObjectStreamTypes.h>
 
// Define serialization templates
template <class T, class A>
bool OSIsType(Array<T, A> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
{
    return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
}
 
template <class T, uint N>
bool OSIsType(StaticArray<T, N> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
{
    return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
}
 
template <class T, uint N>
bool OSIsType(T (*)[N], int inArrayDepth, EOSDataType inDataType, const char *inClassName)
{
    return (inArrayDepth > 0 && OSIsType(static_cast<T *>(nullptr), inArrayDepth - 1, inDataType, inClassName));
}
 
template <class T>
bool OSIsType(Ref<T> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
{
    return OSIsType(static_cast<T *>(nullptr), inArrayDepth, inDataType, inClassName);
}
 
template <class T>
bool OSIsType(RefConst<T> *, int inArrayDepth, EOSDataType inDataType, const char *inClassName)
{
    return OSIsType(static_cast<T *>(nullptr), inArrayDepth, inDataType, inClassName);
}
 
template <class T, class A>
bool OSReadData(IObjectStreamIn &ioStream, Array<T, A> &inArray)
{
    bool continue_reading = true;
 
    // Read array length
    uint32 array_length;
    continue_reading = ioStream.ReadCount(array_length);
 
    // Read array items
    if (continue_reading)
    {
        inArray.clear();
        inArray.resize(array_length);
        for (uint32 el = 0; el < array_length && continue_reading; ++el)
            continue_reading = OSReadData(ioStream, inArray[el]);
    }
 
    return continue_reading;
}
 
template <class T, uint N>
bool OSReadData(IObjectStreamIn &ioStream, StaticArray<T, N> &inArray)
{
    bool continue_reading = true;
 
    // Read array length
    uint32 array_length;
    continue_reading = ioStream.ReadCount(array_length);
 
    // Check if we can fit this many elements
    if (array_length > N)
        return false;
 
    // Read array items
    if (continue_reading)
    {
        inArray.clear();
        inArray.resize(array_length);
        for (uint32 el = 0; el < array_length && continue_reading; ++el)
            continue_reading = OSReadData(ioStream, inArray[el]);
    }
 
    return continue_reading;
}
 
template <class T, uint N>
bool OSReadData(IObjectStreamIn &ioStream, T (&inArray)[N])
{
    bool continue_reading = true;
 
    // Read array length
    uint32 array_length;
    continue_reading = ioStream.ReadCount(array_length);
    if (array_length != N)
        return false;
 
    // Read array items
    for (uint32 el = 0; el < N && continue_reading; ++el)
        continue_reading = OSReadData(ioStream, inArray[el]);
 
    return continue_reading;
}
 
template <class T>
bool OSReadData(IObjectStreamIn &ioStream, Ref<T> &inRef)
{
    return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
}
 
template <class T>
bool OSReadData(IObjectStreamIn &ioStream, RefConst<T> &inRef)
{
    return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
}
 
// Define serialization templates for dynamic arrays
template <class T, class A>
void OSWriteDataType(IObjectStreamOut &ioStream, Array<T, A> *)
{
    ioStream.WriteDataType(EOSDataType::Array);
    OSWriteDataType(ioStream, static_cast<T *>(nullptr));
}
 
template <class T, class A>
void OSWriteData(IObjectStreamOut &ioStream, const Array<T, A> &inArray)
{
    // Write size of array
    ioStream.HintNextItem();
    ioStream.WriteCount(static_cast<uint32>(inArray.size()));
 
    // Write data in array
    ioStream.HintIndentUp();
    for (const T &v : inArray)
        OSWriteData(ioStream, v);
    ioStream.HintIndentDown();
}
 
template <class T, uint N>
void OSWriteDataType(IObjectStreamOut &ioStream, StaticArray<T, N> *)
{
    ioStream.WriteDataType(EOSDataType::Array);
    OSWriteDataType(ioStream, static_cast<T *>(nullptr));
}
 
template <class T, uint N>
void OSWriteData(IObjectStreamOut &ioStream, const StaticArray<T, N> &inArray)
{
    // Write size of array
    ioStream.HintNextItem();
    ioStream.WriteCount(inArray.size());
 
    // Write data in array
    ioStream.HintIndentUp();
    for (const typename StaticArray<T, N>::value_type &v : inArray)
        OSWriteData(ioStream, v);
    ioStream.HintIndentDown();
}
 
template <class T, uint N>
void OSWriteDataType(IObjectStreamOut &ioStream, T (*)[N])
{
    ioStream.WriteDataType(EOSDataType::Array);
    OSWriteDataType(ioStream, static_cast<T *>(nullptr));
}
 
template <class T, uint N>
void OSWriteData(IObjectStreamOut &ioStream, const T (&inArray)[N])
{
    // Write size of array
    ioStream.HintNextItem();
    ioStream.WriteCount(uint32(N));
 
    // Write data in array
    ioStream.HintIndentUp();
    for (const T &v : inArray)
        OSWriteData(ioStream, v);
    ioStream.HintIndentDown();
}
 
template <class T>
void OSWriteDataType(IObjectStreamOut &ioStream, Ref<T> *)
{
    OSWriteDataType(ioStream, static_cast<T *>(nullptr));
}
 
template <class T>
void OSWriteData(IObjectStreamOut &ioStream, const Ref<T> &inRef)
{
    if (inRef != nullptr)
        ioStream.WritePointerData(GetRTTI(inRef.GetPtr()), inRef.GetPtr());
    else
        ioStream.WritePointerData(nullptr, nullptr);
}
 
template <class T>
void OSWriteDataType(IObjectStreamOut &ioStream, RefConst<T> *)
{
    OSWriteDataType(ioStream, static_cast<T *>(nullptr));
}
 
template <class T>
void OSWriteData(IObjectStreamOut &ioStream, const RefConst<T> &inRef)
{
    if (inRef != nullptr)
        ioStream.WritePointerData(GetRTTI(inRef.GetPtr()), inRef.GetPtr());
    else
        ioStream.WritePointerData(nullptr, nullptr);
}
 
JPH_NAMESPACE_END
 
#endif // JPH_OBJECT_STREAM