Split off ObjectStream classes to reduce compilation time of the library by approx 20% (#174)

Jolt/ObjectStream/ObjectStream.cpp

@@ -8,10 +8,23 @@
 JPH_NAMESPACE_BEGIN
 
 // Define macro to declare functions for a specific primitive type
-#define JPH_DECLARE_PRIMITIVE(name)														\
-	bool				OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName) \
-	{																					\
-		return inArrayDepth == 0 && inDataType == EOSDataType::T_##name;				\
+#define JPH_DECLARE_PRIMITIVE(name)																\
+	bool	OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName) \
+	{																							\
+		return inArrayDepth == 0 && inDataType == EOSDataType::T_##name;						\
+	}																							\
+	bool	OSReadData(IObjectStreamIn &ioStream, name &outPrimitive)							\
+	{																							\
+		return ioStream.ReadPrimitiveData(outPrimitive);										\
+	}																							\
+	void	OSWriteDataType(IObjectStreamOut &ioStream, name *)									\
+	{																							\
+		ioStream.WriteDataType(EOSDataType::T_##name);											\
+	}																							\
+	void	OSWriteData(IObjectStreamOut &ioStream, const name &inPrimitive)					\
+	{																							\
+		ioStream.HintNextItem();																\
+		ioStream.WritePrimitiveData(inPrimitive);												\
 	}
 
 // This file uses the JPH_DECLARE_PRIMITIVE macro to define all types

Jolt/ObjectStream/ObjectStream.h

@@ -6,6 +6,7 @@
 #include <Jolt/Core/StaticArray.h>
 #include <Jolt/Core/Reference.h>
 #include <Jolt/ObjectStream/SerializableAttribute.h>
+#include <Jolt/Core/RTTI.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -32,9 +33,77 @@ protected:
 	static constexpr Identifier		sNullIdentifier = 0;
 };
 
+/// Interface class for reading from an object stream
+class IObjectStreamIn : public ObjectStream
+{
+public:
+	///@name Input type specific operations
+	virtual bool				ReadDataType(EOSDataType &outType) = 0;
+	virtual bool				ReadName(string &outName) = 0;
+	virtual bool				ReadIdentifier(Identifier &outIdentifier) = 0;
+	virtual bool				ReadCount(uint32 &outCount) = 0;
+
+	///@name Read primitives
+	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(bool &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(string &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Float3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Vec3 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Vec4 &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Quat &outPrimitive) = 0;
+	virtual bool				ReadPrimitiveData(Mat44 &outPrimitive) = 0;
+
+	///@name Read compounds
+	virtual bool				ReadClassData(const char *inClassName, void *inInstance) = 0;
+	virtual bool				ReadPointerData(const RTTI *inRTTI, void **inPointer, int inRefCountOffset = -1) = 0;
+};
+
+/// Interface class for writing to an object stream
+class IObjectStreamOut : public ObjectStream
+{
+public:
+	///@name Output type specific operations
+	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;
+
+	///@name Write primitives
+	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 bool &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const string &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Float3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Vec3 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Vec4 &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Quat &inPrimitive) = 0;
+	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) = 0;
+
+	///@name Write compounds
+	virtual void				WritePointerData(const RTTI *inRTTI, const void *inPointer) = 0;
+	virtual void				WriteClassData(const RTTI *inRTTI, const void *inInstance) = 0;
+
+	///@name Layout hints (for text output)
+	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)													\
-	bool						OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);
+#define JPH_DECLARE_PRIMITIVE(name)																	\
+	bool	OSIsType(name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
+	bool	OSReadData(IObjectStreamIn &ioStream, name &outPrimitive);								\
+	void	OSWriteDataType(IObjectStreamOut &ioStream, name *);									\
+	void	OSWriteData(IObjectStreamOut &ioStream, const name &inPrimitive);
 
 // This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
 #include <Jolt/ObjectStream/ObjectStreamTypes.h>
@@ -70,4 +139,179 @@ bool OSIsType(RefConst<T> *, int inArrayDepth, EOSDataType inDataType, const cha
 	return OSIsType((T *)nullptr, inArrayDepth, inDataType, inClassName);
 }
 
+/// Define serialization templates for dynamic arrays
+template <class T>
+bool OSReadData(IObjectStreamIn &ioStream, vector<T> &inArray)
+{
+	bool continue_reading = true;
+
+	// Read array length
+	uint32 array_length;
+	continue_reading = ioStream.ReadCount(array_length);
+
+	// Read array items
+	if (continue_reading) 
+	{
+		inArray.resize(array_length);
+		for (uint32 el = 0; el < array_length && continue_reading; ++el) 
+			continue_reading = OSReadData(ioStream, inArray[el]);
+	}
+
+	return continue_reading;
+}
+
+/// Define serialization templates for static arrays
+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.resize(array_length);
+		for (uint32 el = 0; el < array_length && continue_reading; ++el) 
+			continue_reading = OSReadData(ioStream, inArray[el]);
+	}
+
+	return continue_reading;
+}
+
+/// Define serialization templates for C style arrays
+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;
+}
+
+/// Define serialization templates for references
+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>
+void OSWriteDataType(IObjectStreamOut &ioStream, vector<T> *)		
+{ 
+	ioStream.WriteDataType(EOSDataType::Array); 
+	OSWriteDataType(ioStream, (T *)nullptr); 
+}
+
+template <class T>
+void OSWriteData(IObjectStreamOut &ioStream, const vector<T> &inArray)
+{
+	// Write size of array
+	ioStream.HintNextItem();
+	ioStream.WriteCount((uint32)inArray.size());
+
+	// Write data in array
+	ioStream.HintIndentUp();	
+	for (const T &v : inArray)
+		OSWriteData(ioStream, v);
+	ioStream.HintIndentDown();
+}
+
+/// Define serialization templates for static arrays
+template <class T, uint N>
+void OSWriteDataType(IObjectStreamOut &ioStream, StaticArray<T, N> *)		
+{ 
+	ioStream.WriteDataType(EOSDataType::Array); 
+	OSWriteDataType(ioStream, (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();
+}
+
+/// Define serialization templates for C style arrays
+template <class T, uint N>
+void OSWriteDataType(IObjectStreamOut &ioStream, T (*)[N])		
+{ 
+	ioStream.WriteDataType(EOSDataType::Array); 
+	OSWriteDataType(ioStream, (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();
+}
+
+/// Define serialization templates for references
+template <class T>
+void OSWriteDataType(IObjectStreamOut &ioStream, Ref<T> *)
+{
+	OSWriteDataType(ioStream, (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, (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

Jolt/ObjectStream/ObjectStreamIn.cpp

@@ -546,14 +546,4 @@ bool ObjectStreamIn::SkipAttributeData(int inArrayDepth, EOSDataType inDataType,
 	return continue_reading;
 }
 
-// Define macro to declare functions for a specific primitive type
-#define JPH_DECLARE_PRIMITIVE(name)														\
-	bool	OSReadData(ObjectStreamIn &ioStream, name &outPrimitive)					\
-	{																					\
-		return ioStream.ReadPrimitiveData(outPrimitive);								\
-	}
-
-// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
-#include <Jolt/ObjectStream/ObjectStreamTypes.h>
-
 JPH_NAMESPACE_END

Jolt/ObjectStream/ObjectStreamIn.h

@@ -16,7 +16,7 @@ JPH_NAMESPACE_BEGIN
 
 /// ObjectStreamIn contains all logic for reading an object from disk. It is the base
 /// class for the text and binary input streams (ObjectStreamTextIn and ObjectStreamBinaryIn).
-class ObjectStreamIn : public ObjectStream
+class ObjectStreamIn : public IObjectStreamIn
 {
 private:
 	struct ClassDescription;
@@ -78,31 +78,11 @@ public:
 	void *						Read(const RTTI *inRTTI);
 	void *						ReadObject(const RTTI *& outRTTI);
 	bool						ReadRTTI();
-	bool						ReadClassData(const char *inClassName, void *inInstance);
+	virtual bool				ReadClassData(const char *inClassName, void *inInstance) override;
 	bool						ReadClassData(const ClassDescription &inClassDesc, void *inInstance);
-	bool						ReadPointerData(const RTTI *inRTTI, void **inPointer, int inRefCountOffset = -1);
+	virtual bool				ReadPointerData(const RTTI *inRTTI, void **inPointer, int inRefCountOffset = -1) override;
 	bool						SkipAttributeData(int inArrayDepth, EOSDataType inDataType, const char *inClassName);
 
-	///@name Input type specific operations
-	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(bool &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(string &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(Float3 &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(Vec3 &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(Vec4 &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(Quat &outPrimitive) = 0;
-	virtual bool				ReadPrimitiveData(Mat44 &outPrimitive) = 0;
-
 protected:
 	/// Constructor
 	explicit 					ObjectStreamIn(istream &inStream);
@@ -159,89 +139,4 @@ private:
 	vector<Link>				mUnresolvedLinks;										///< All pointers (links) are resolved after reading the entire file, e.g. when all object exist
 };
 
-// Define macro to declare functions for a specific primitive type
-#define JPH_DECLARE_PRIMITIVE(name)														\
-	bool	OSReadData(ObjectStreamIn &ioStream, name &outPrimitive);
-
-// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
-#include <Jolt/ObjectStream/ObjectStreamTypes.h>
-
-/// Define serialization templates for dynamic arrays
-template <class T>
-bool OSReadData(ObjectStreamIn &ioStream, vector<T> &inArray)
-{
-	bool continue_reading = true;
-
-	// Read array length
-	uint32 array_length;
-	continue_reading = ioStream.ReadCount(array_length);
-
-	// Read array items
-	if (continue_reading) 
-	{
-		inArray.resize(array_length);
-		for (uint32 el = 0; el < array_length && continue_reading; ++el) 
-			continue_reading = OSReadData(ioStream, inArray[el]);
-	}
-
-	return continue_reading;
-}
-
-/// Define serialization templates for static arrays
-template <class T, uint N>
-bool OSReadData(ObjectStreamIn &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.resize(array_length);
-		for (uint32 el = 0; el < array_length && continue_reading; ++el) 
-			continue_reading = OSReadData(ioStream, inArray[el]);
-	}
-
-	return continue_reading;
-}
-
-/// Define serialization templates for C style arrays
-template <class T, uint N>
-bool OSReadData(ObjectStreamIn &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;
-}
-
-/// Define serialization templates for references
-template <class T>
-bool OSReadData(ObjectStreamIn &ioStream, Ref<T> &inRef)
-{
-	return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
-}
-
-template <class T>
-bool OSReadData(ObjectStreamIn &ioStream, RefConst<T> &inRef)
-{
-	return ioStream.ReadPointerData(JPH_RTTI(T), inRef.InternalGetPointer(), T::sInternalGetRefCountOffset());
-}
-
 JPH_NAMESPACE_END

Jolt/ObjectStream/ObjectStreamOut.cpp

@@ -160,19 +160,4 @@ void ObjectStreamOut::WritePointerData(const RTTI *inRTTI, const void *inPointer
 	WriteIdentifier(identifier);
 }
 
-// Define macro to declare functions for a specific primitive type
-#define JPH_DECLARE_PRIMITIVE(name)															\
-	void	OSWriteDataType(ObjectStreamOut &ioStream, name *)								\
-	{																						\
-		ioStream.WriteDataType(EOSDataType::T_##name);										\
-	}																						\
-	void	OSWriteData(ObjectStreamOut &ioStream, const name &inPrimitive)					\
-	{																						\
-		ioStream.HintNextItem();															\
-		ioStream.WritePrimitiveData(inPrimitive);											\
-	}
-
-// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
-#include <Jolt/ObjectStream/ObjectStreamTypes.h>
-
 JPH_NAMESPACE_END

Jolt/ObjectStream/ObjectStreamOut.h

@@ -17,7 +17,7 @@ JPH_NAMESPACE_BEGIN
 
 /// ObjectStreamOut contains all logic for writing an object to disk. It is the base 
 /// class for the text and binary output streams (ObjectStreamTextOut and ObjectStreamBinaryOut).
-class ObjectStreamOut : public ObjectStream
+class ObjectStreamOut : public IObjectStreamOut
 {
 private:
 	struct ObjectInfo;
@@ -60,33 +60,8 @@ public:
 	void						WriteObject(const void *inObject);
 	void						QueueRTTI(const RTTI *inRTTI);
 	void						WriteRTTI(const RTTI *inRTTI);
-	void						WriteClassData(const RTTI *inRTTI, const void *inInstance);
-	void						WritePointerData(const RTTI *inRTTI, const void *inPointer);
-
-	///@name Output type specific operations
-	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 bool &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const string &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const Float3 &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const Vec3 &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const Vec4 &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const Quat &inPrimitive) = 0;
-	virtual void				WritePrimitiveData(const Mat44 &inPrimitive) = 0;
-
-	///@name Layout hints (for text output)
-	virtual void				HintNextItem()												{ /* Default is do nothing */ }
-	virtual void				HintIndentUp()												{ /* Default is do nothing */ }
-	virtual void				HintIndentDown()											{ /* Default is do nothing */ }
+	virtual void				WriteClassData(const RTTI *inRTTI, const void *inInstance) override;
+	virtual void				WritePointerData(const RTTI *inRTTI, const void *inPointer) override;
 
 protected:
 	/// Static constructor
@@ -119,109 +94,4 @@ private:
 	ClassQueue					mClassQueue;												///< List of classes waiting to be written
 };	
 
-// Define macro to declare functions for a specific primitive type
-#define JPH_DECLARE_PRIMITIVE(name)															\
-	void	OSWriteDataType(ObjectStreamOut &ioStream, name *);								\
-	void	OSWriteData(ObjectStreamOut &ioStream, const name &inPrimitive);
-
-// This file uses the JPH_DECLARE_PRIMITIVE macro to define all types
-#include <Jolt/ObjectStream/ObjectStreamTypes.h>
-
-// Define serialization templates for dynamic arrays
-template <class T>
-void OSWriteDataType(ObjectStreamOut &ioStream, vector<T> *)		
-{ 
-	ioStream.WriteDataType(EOSDataType::Array); 
-	OSWriteDataType(ioStream, (T *)nullptr); 
-}
-
-template <class T>
-void OSWriteData(ObjectStreamOut &ioStream, const vector<T> &inArray)
-{
-	// Write size of array
-	ioStream.HintNextItem();
-	ioStream.WriteCount((uint32)inArray.size());
-
-	// Write data in array
-	ioStream.HintIndentUp();	
-	for (const T &v : inArray)
-		OSWriteData(ioStream, v);
-	ioStream.HintIndentDown();
-}
-
-/// Define serialization templates for static arrays
-template <class T, uint N>
-void OSWriteDataType(ObjectStreamOut &ioStream, StaticArray<T, N> *)		
-{ 
-	ioStream.WriteDataType(EOSDataType::Array); 
-	OSWriteDataType(ioStream, (T *)nullptr); 
-}
-
-template <class T, uint N>
-void OSWriteData(ObjectStreamOut &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();
-}
-
-/// Define serialization templates for C style arrays
-template <class T, uint N>
-void OSWriteDataType(ObjectStreamOut &ioStream, T (*)[N])		
-{ 
-	ioStream.WriteDataType(EOSDataType::Array); 
-	OSWriteDataType(ioStream, (T *)nullptr); 
-}
-
-template <class T, uint N>
-void OSWriteData(ObjectStreamOut &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();
-}
-
-/// Define serialization templates for references
-template <class T>
-void OSWriteDataType(ObjectStreamOut &ioStream, Ref<T> *)
-{
-	OSWriteDataType(ioStream, (T *)nullptr);
-}
-
-template <class T>
-void OSWriteData(ObjectStreamOut &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(ObjectStreamOut &ioStream, RefConst<T> *)
-{
-	OSWriteDataType(ioStream, (T *)nullptr);
-}
-
-template <class T>
-void OSWriteData(ObjectStreamOut &ioStream, const RefConst<T> &inRef)
-{
-	if (inRef != nullptr)
-		ioStream.WritePointerData(GetRTTI(inRef.GetPtr()), inRef.GetPtr());
-	else
-		ioStream.WritePointerData(nullptr, nullptr);
-}
-
 JPH_NAMESPACE_END

Jolt/ObjectStream/SerializableAttribute.h

@@ -6,8 +6,8 @@
 JPH_NAMESPACE_BEGIN
 
 class RTTI;
-class ObjectStreamIn;
-class ObjectStreamOut;
+class IObjectStreamIn;
+class IObjectStreamOut;
 
 /// Data type
 enum class EOSDataType
@@ -36,9 +36,9 @@ public:
 	///@ Serialization functions
 	using pGetMemberPrimitiveType = const RTTI * (*)();
 	using pIsType = bool (*)(int inArrayDepth, EOSDataType inDataType, const char *inClassName);
-	using pReadData = bool (*)(ObjectStreamIn &ioStream, void *inObject);
-	using pWriteData = void (*)(ObjectStreamOut &ioStream, const void *inObject);
-	using pWriteDataType = void (*)(ObjectStreamOut &ioStream);
+	using pReadData = bool (*)(IObjectStreamIn &ioStream, void *inObject);
+	using pWriteData = void (*)(IObjectStreamOut &ioStream, const void *inObject);
+	using pWriteDataType = void (*)(IObjectStreamOut &ioStream);
 
 	/// Constructor
 								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) { }
@@ -63,19 +63,19 @@ public:
 	}
 
 	/// Read the data for this attribute into attribute containing class inObject
-	bool						ReadData(ObjectStreamIn &ioStream, void *inObject) const
+	bool						ReadData(IObjectStreamIn &ioStream, void *inObject) const
 	{
 		return mReadData(ioStream, reinterpret_cast<uint8 *>(inObject) + mMemberOffset);
 	}
 
 	/// Write the data for this attribute from attribute containing class inObject
-	void						WriteData(ObjectStreamOut &ioStream, const void *inObject) const
+	void						WriteData(IObjectStreamOut &ioStream, const void *inObject) const
 	{
 		mWriteData(ioStream, reinterpret_cast<const uint8 *>(inObject) + mMemberOffset);
 	}
 
 	/// Write the data type of this attribute to a stream
-	void						WriteDataType(ObjectStreamOut &ioStream) const
+	void						WriteDataType(IObjectStreamOut &ioStream) const
 	{
 		mWriteDataType(ioStream);
 	}

Jolt/ObjectStream/SerializableAttributeEnum.h

@@ -4,8 +4,7 @@
 #pragma once
 
 #include <Jolt/ObjectStream/SerializableAttribute.h>
-#include <Jolt/ObjectStream/ObjectStreamIn.h>
-#include <Jolt/ObjectStream/ObjectStreamOut.h>
+#include <Jolt/ObjectStream/ObjectStream.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -25,7 +24,7 @@ inline void AddSerializableAttributeEnum(RTTI &inRTTI, uint inOffset, const char
 		{
 			return inArrayDepth == 0 && inDataType == EOSDataType::T_uint32;
 		},
-		[](ObjectStreamIn &ioStream, void *inObject)
+		[](IObjectStreamIn &ioStream, void *inObject)
 		{
 			uint32 temporary;
 			if (OSReadData(ioStream, temporary)) 
@@ -35,13 +34,13 @@ inline void AddSerializableAttributeEnum(RTTI &inRTTI, uint inOffset, const char
 			}
 			return false;
 		},
-		[](ObjectStreamOut &ioStream, const void *inObject)
+		[](IObjectStreamOut &ioStream, const void *inObject)
 		{
 			static_assert(sizeof(MemberType) <= sizeof(uint32));
 			uint32 temporary = uint32(*reinterpret_cast<const MemberType *>(inObject));
 			OSWriteData(ioStream, temporary);
 		},
-		[](ObjectStreamOut &ioStream)
+		[](IObjectStreamOut &ioStream)
 		{
 			ioStream.WriteDataType(EOSDataType::T_uint32);
 		}));

Jolt/ObjectStream/SerializableAttributeTyped.h

@@ -5,8 +5,7 @@
 
 #include <Jolt/ObjectStream/SerializableAttribute.h>
 #include <Jolt/ObjectStream/GetPrimitiveTypeOfType.h>
-#include <Jolt/ObjectStream/ObjectStreamIn.h>
-#include <Jolt/ObjectStream/ObjectStreamOut.h>
+#include <Jolt/ObjectStream/ObjectStream.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -26,15 +25,15 @@ inline void AddSerializableAttributeTyped(RTTI &inRTTI, uint inOffset, const cha
 		{
 			return OSIsType((MemberType *)nullptr, inArrayDepth, inDataType, inClassName);
 		},
-		[](ObjectStreamIn &ioStream, void *inObject)
+		[](IObjectStreamIn &ioStream, void *inObject)
 		{
 			return OSReadData(ioStream, *reinterpret_cast<MemberType *>(inObject));
 		},
-		[](ObjectStreamOut &ioStream, const void *inObject)
+		[](IObjectStreamOut &ioStream, const void *inObject)
 		{
 			OSWriteData(ioStream, *reinterpret_cast<const MemberType *>(inObject));
 		},
-		[](ObjectStreamOut &ioStream)
+		[](IObjectStreamOut &ioStream)
 		{
 			OSWriteDataType(ioStream, (MemberType *)nullptr);
 		}));

Jolt/ObjectStream/SerializableObject.h

@@ -3,8 +3,7 @@
 
 #pragma once
 
-#include <Jolt/ObjectStream/ObjectStreamIn.h>
-#include <Jolt/ObjectStream/ObjectStreamOut.h>
+#include <Jolt/ObjectStream/ObjectStream.h>
 
 JPH_NAMESPACE_BEGIN
 
@@ -14,22 +13,22 @@ JPH_NAMESPACE_BEGIN
 
 // JPH_DECLARE_SERIALIZATION_FUNCTIONS
 #define JPH_DECLARE_SERIALIZATION_FUNCTIONS(prefix, class_name)														\
-	prefix bool			OSReadData(ObjectStreamIn &ioStream, class_name &inInstance);								\
-	prefix bool			OSReadData(ObjectStreamIn &ioStream, class_name *&inPointer);								\
+	prefix bool			OSReadData(IObjectStreamIn &ioStream, class_name &inInstance);								\
+	prefix bool			OSReadData(IObjectStreamIn &ioStream, class_name *&inPointer);								\
 	prefix bool			OSIsType(class_name *, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
 	prefix bool			OSIsType(class_name **, int inArrayDepth, EOSDataType inDataType, const char *inClassName);	\
-	prefix void			OSWriteData(ObjectStreamOut &ioStream, const class_name &inInstance);						\
-	prefix void			OSWriteData(ObjectStreamOut &ioStream, class_name *const &inPointer);						\
-	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name *);									\
-	prefix void			OSWriteDataType(ObjectStreamOut &ioStream, class_name **);
+	prefix void			OSWriteData(IObjectStreamOut &ioStream, const class_name &inInstance);						\
+	prefix void			OSWriteData(IObjectStreamOut &ioStream, class_name *const &inPointer);						\
+	prefix void			OSWriteDataType(IObjectStreamOut &ioStream, class_name *);									\
+	prefix void			OSWriteDataType(IObjectStreamOut &ioStream, class_name **);
 
 // JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS
 #define JPH_IMPLEMENT_SERIALIZATION_FUNCTIONS(class_name)															\
-	bool				OSReadData(ObjectStreamIn &ioStream, class_name &inInstance)								\
+	bool				OSReadData(IObjectStreamIn &ioStream, class_name &inInstance)								\
 	{																												\
 		return ioStream.ReadClassData(#class_name, (void *)&inInstance);											\
 	}																												\
-	bool				OSReadData(ObjectStreamIn &ioStream, class_name *&inPointer)								\
+	bool				OSReadData(IObjectStreamIn &ioStream, class_name *&inPointer)								\
 	{																												\
 		return ioStream.ReadPointerData(JPH_RTTI(class_name), (void **)&inPointer);									\
 	}																												\
@@ -41,23 +40,23 @@ JPH_NAMESPACE_BEGIN
 	{																												\
 		return inArrayDepth == 0 && inDataType == EOSDataType::Pointer && strcmp(inClassName, #class_name) == 0;	\
 	}																												\
-	void				OSWriteData(ObjectStreamOut &ioStream, const class_name &inInstance)						\
+	void				OSWriteData(IObjectStreamOut &ioStream, const class_name &inInstance)						\
 	{																												\
 		ioStream.WriteClassData(JPH_RTTI(class_name), (void *)&inInstance);											\
 	}																												\
-	void				OSWriteData(ObjectStreamOut &ioStream, class_name *const &inPointer)						\
+	void				OSWriteData(IObjectStreamOut &ioStream, class_name *const &inPointer)						\
 	{																												\
 		if (inPointer)																								\
 			ioStream.WritePointerData(GetRTTI(inPointer), (void *)inPointer);										\
 		else 																										\
 			ioStream.WritePointerData(nullptr, nullptr);															\
 	}																												\
-	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name *)									\
+	void				OSWriteDataType(IObjectStreamOut &ioStream, class_name *)									\
 	{																												\
 		ioStream.WriteDataType(EOSDataType::Instance);																\
 		ioStream.WriteName(#class_name);																			\
 	}																												\
-	void				OSWriteDataType(ObjectStreamOut &ioStream, class_name **)									\
+	void				OSWriteDataType(IObjectStreamOut &ioStream, class_name **)									\
 	{																												\
 		ioStream.WriteDataType(EOSDataType::Pointer);																\
 		ioStream.WriteName(#class_name);																			\

Jolt/Physics/Collision/Shape/Shape.h

@@ -14,6 +14,11 @@
 #include <Jolt/Core/NonCopyable.h>
 #include <Jolt/ObjectStream/SerializableObject.h>
 
+JPH_SUPPRESS_WARNINGS_STD_BEGIN
+#include <unordered_map>
+#include <unordered_set>
+JPH_SUPPRESS_WARNINGS_STD_END
+
 JPH_NAMESPACE_BEGIN
 
 struct RayCast;

PerformanceTest/RagdollScene.h

@@ -8,6 +8,7 @@
 #include <Jolt/Physics/PhysicsScene.h>
 #include <Jolt/Physics/Collision/CastResult.h>
 #include <Jolt/Physics/Collision/RayCast.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 
 // Local includes
 #include "PerformanceTestScene.h"

Samples/SamplesApp.cpp

@@ -37,6 +37,7 @@
 #include <Utils/Log.h>
 #include <Utils/ShapeCreator.h>
 #include <Renderer/DebugRendererImp.h>
+#include <fstream>
 
 //-----------------------------------------------------------------------------
 // RTTI definitions

Samples/Tests/Character/CharacterBaseTest.cpp

@@ -9,6 +9,7 @@
 #include <Jolt/Physics/Collision/Shape/RotatedTranslatedShape.h>
 #include <Jolt/Physics/Collision/Shape/BoxShape.h>
 #include <Jolt/Core/StringTools.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Application/DebugUI.h>
 #include <Layers.h>
 #include <Utils/Log.h>

Samples/Tests/ConvexCollision/ConvexHullShrinkTest.cpp

@@ -8,6 +8,7 @@
 #include <Jolt/Geometry/ConvexSupport.h>
 #include <Jolt/Physics/Collision/Shape/ConvexHullShape.h>
 #include <Renderer/DebugRendererImp.h>
+#include <fstream>
 
 JPH_IMPLEMENT_RTTI_VIRTUAL(ConvexHullShrinkTest) 
 { 

Samples/Tests/ConvexCollision/ConvexHullTest.cpp

@@ -7,6 +7,7 @@
 #include <Jolt/Geometry/ConvexHullBuilder.h>
 #include <Utils/Log.h>
 #include <Renderer/DebugRendererImp.h>
+#include <fstream>
 
 JPH_IMPLEMENT_RTTI_VIRTUAL(ConvexHullTest) 
 { 

Samples/Tests/General/MultithreadedTest.cpp

@@ -8,11 +8,12 @@
 #include <Jolt/Physics/Collision/RayCast.h>
 #include <Jolt/Physics/Collision/CastResult.h>
 #include <Jolt/Physics/Body/BodyCreationSettings.h>
-#include <Layers.h>
 #include <Jolt/Skeleton/Skeleton.h>
 #include <Jolt/Skeleton/SkeletalAnimation.h>
 #include <Jolt/Skeleton/SkeletonPose.h>
 #include <Jolt/Physics/Ragdoll/Ragdoll.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
+#include <Layers.h>
 #include <Utils/RagdollLoader.h>
 #include <Utils/Log.h>
 #include <Renderer/DebugRendererImp.h>

Samples/Tests/General/SensorTest.cpp

@@ -7,6 +7,7 @@
 #include <Jolt/Physics/Collision/Shape/BoxShape.h>
 #include <Jolt/Physics/Collision/Shape/SphereShape.h>
 #include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Utils/RagdollLoader.h>
 #include <Utils/Log.h>
 #include <Layers.h>

Samples/Tests/Rig/KinematicRigTest.cpp

@@ -6,6 +6,7 @@
 #include <Tests/Rig/KinematicRigTest.h>
 #include <Jolt/Physics/Collision/Shape/BoxShape.h>
 #include <Jolt/Physics/StateRecorder.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Application/DebugUI.h>
 #include <Layers.h>
 #include <Utils/Log.h>

Samples/Tests/Rig/PoweredRigTest.cpp

@@ -5,6 +5,7 @@
 
 #include <Tests/Rig/PoweredRigTest.h>
 #include <Jolt/Physics/StateRecorder.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Application/DebugUI.h>
 #include <Utils/RagdollLoader.h>
 #include <Utils/Log.h>

Samples/Tests/Rig/RigPileTest.cpp

@@ -10,8 +10,9 @@
 #include <Jolt/Skeleton/Skeleton.h>
 #include <Jolt/Skeleton/SkeletalAnimation.h>
 #include <Jolt/Skeleton/SkeletonPose.h>
-#include <Utils/RagdollLoader.h>
 #include <Jolt/Core/StringTools.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
+#include <Utils/RagdollLoader.h>
 #include <Application/DebugUI.h>
 #include <Layers.h>
 #include <Utils/Log.h>

Samples/Tests/Tools/LoadSnapshotTest.cpp

@@ -9,6 +9,7 @@
 #include <Application/DebugUI.h>
 #include <Utils/Log.h>
 #include <Layers.h>
+#include <fstream>
 
 JPH_IMPLEMENT_RTTI_VIRTUAL(LoadSnapshotTest) 
 { 

Samples/Tests/Vehicle/VehicleTest.cpp

@@ -9,6 +9,7 @@
 #include <Jolt/Physics/Collision/GroupFilterTable.h>
 #include <Jolt/Physics/Body/BodyCreationSettings.h>
 #include <Jolt/Physics/PhysicsScene.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Layers.h>
 #include <Application/DebugUI.h>
 #include <Utils/Log.h>

Samples/Utils/RagdollLoader.cpp

@@ -11,6 +11,7 @@
 #include <Jolt/Physics/Constraints/SliderConstraint.h>
 #include <Jolt/Physics/Constraints/ConeConstraint.h>
 #include <Jolt/Physics/Constraints/SwingTwistConstraint.h>
+#include <Jolt/ObjectStream/ObjectStreamIn.h>
 #include <Jolt/ObjectStream/ObjectStreamOut.h>
 #include <Layers.h>
 #include <Utils/Log.h>