SerializableAttribute.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
 
JPH_NAMESPACE_BEGIN
 
class RTTI;
class IObjectStreamIn;
class IObjectStreamOut;
 
enum class EOSDataType
{
    Declare,                                                                        
    Object,                                                                         
    Instance,                                                                       
    Pointer,                                                                        
    Array,                                                                          
        
    // Basic types (primitives)
    #define JPH_DECLARE_PRIMITIVE(name) T_##name,
 
    // This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
    #include <Jolt/ObjectStream/ObjectStreamTypes.h>
 
    // Error values for read functions
    Invalid,                                                                        
};
 
class SerializableAttribute
{
public:
    using pGetMemberPrimitiveType = const RTTI * (*)();
    using pIsType = bool (*)(int inArrayDepth, EOSDataType inDataType, const char *inClassName);
    using pReadData = bool (*)(IObjectStreamIn &ioStream, void *inObject);
    using pWriteData = void (*)(IObjectStreamOut &ioStream, const void *inObject);
    using pWriteDataType = void (*)(IObjectStreamOut &ioStream);
 
                                SerializableAttribute(const char *inName, uint inMemberOffset, pGetMemberPrimitiveType inGetMemberPrimitiveType, pIsType inIsType, pReadData inReadData, pWriteData inWriteData, pWriteDataType inWriteDataType) : mName(inName), mMemberOffset(inMemberOffset), mGetMemberPrimitiveType(inGetMemberPrimitiveType), mIsType(inIsType), mReadData(inReadData), mWriteData(inWriteData), mWriteDataType(inWriteDataType) { }
 
                                SerializableAttribute(const SerializableAttribute &inOther, int inBaseOffset) : mName(inOther.mName), mMemberOffset(inOther.mMemberOffset + inBaseOffset), mGetMemberPrimitiveType(inOther.mGetMemberPrimitiveType), mIsType(inOther.mIsType), mReadData(inOther.mReadData), mWriteData(inOther.mWriteData), mWriteDataType(inOther.mWriteDataType) { }
 
    void                        SetName(const char *inName)                         { mName = inName; }
    const char *                GetName() const                                     { return mName; }
 
    template <class T>
    inline T *                  GetMemberPointer(void *inObject) const              { return reinterpret_cast<T *>(reinterpret_cast<uint8 *>(inObject) + mMemberOffset); }
    template <class T>
    inline const T *            GetMemberPointer(const void *inObject) const        { return reinterpret_cast<const T *>(reinterpret_cast<const uint8 *>(inObject) + mMemberOffset); }
 
    const RTTI *                GetMemberPrimitiveType() const
    {
        return mGetMemberPrimitiveType();
    }
 
    bool                        IsType(int inArrayDepth, EOSDataType inDataType, const char *inClassName) const
    {
        return mIsType(inArrayDepth, inDataType, inClassName);
    }
 
    bool                        ReadData(IObjectStreamIn &ioStream, void *inObject) const
    {
        return mReadData(ioStream, GetMemberPointer<void>(inObject));
    }
 
    void                        WriteData(IObjectStreamOut &ioStream, const void *inObject) const
    {
        mWriteData(ioStream, GetMemberPointer<void>(inObject));
    }
 
    void                        WriteDataType(IObjectStreamOut &ioStream) const
    {
        mWriteDataType(ioStream);
    }
 
private:
    // Name of the attribute
    const char *                mName;
 
    // Offset of the member relative to the class
    uint                        mMemberOffset;
 
    // In case this attribute contains an RTTI type, return it (note that a Array<sometype> will return the rtti of sometype)
    pGetMemberPrimitiveType     mGetMemberPrimitiveType;
 
    // Serialization operations
    pIsType                     mIsType;
    pReadData                   mReadData;
    pWriteData                  mWriteData;
    pWriteDataType              mWriteDataType;
};
 
JPH_NAMESPACE_END