moved ReflectionPtr serialization to use shared_ptrs

CamelotClient/TestingGround.cpp

@@ -15,7 +15,7 @@ void test()
 	FileSerializer fs;
 	fs.encode(dbgResource, "C:\\ResourceTest.res");
 
-	Resource* loadedResource = new Resource();
+	ResourcePtr loadedResource(new Resource());
 	fs.decode(loadedResource, "C:\\ResourceTest.res");
 
 	TexturePtr dbgTexture = TextureManager::instance().create(TEX_TYPE_2D, 128, 128, 1, PF_A8B8G8R8);
@@ -23,5 +23,5 @@ void test()
 	fs.encode(dbgTexture.get(), "C:\\DbgTexture.tex");
 
 	TexturePtr emptyTexture = TextureManager::instance().create(TEX_TYPE_2D, 512, 512, 1, PF_UNKNOWN);
-	fs.decode(emptyTexture.get(), "C:\\DbgTexture.tex");
+	fs.decode(emptyTexture, "C:\\DbgTexture.tex");
 }

CamelotRenderer/TODO.txt

@@ -45,6 +45,8 @@ TODO:
  - OpenGL too
 
 TOMORROW:
+ - I moved ReflectionPtr serialization to use shared_ptrs, but haven't tested it one bit
+ - When serializing, encode requires normal ptr, while decode required shared_ptr. Standardize that
  - How do I serialize derived classes, without rewriting all the base class serialization?
    - Unless something better dawns on me by Monday, just inherit from parents SerializableType and manually make sure no IDs overlap.
      - We can improve later if needed. I though about it too much for now.

CamelotUtility/Include/CmBinarySerializer.h

@@ -61,17 +61,17 @@ namespace CamelotEngine
 		 * @param [in]	data  	Binary data to decode.
 		 * @param	dataLength	Length of the data.
 		 */
-		void decode(IReflectable* object, UINT8* data, UINT32 dataLength);
+		void decode(std::shared_ptr<IReflectable> object, UINT8* data, UINT32 dataLength);
 
 	private:
 		struct ObjectToEncode
 		{
-			ObjectToEncode(UINT32 _objectId, IReflectable* _object)
+			ObjectToEncode(UINT32 _objectId, std::shared_ptr<IReflectable> _object)
 				:objectId(_objectId), object(_object)
 			{ }
 
 			UINT32 objectId;
-			IReflectable* object;
+			std::shared_ptr<IReflectable> object;
 		};
 
 		/**
@@ -84,17 +84,17 @@ namespace CamelotEngine
 				:field(nullptr), object(nullptr), id(0)
 			{ }
 
-			PtrToResolve(RTTIReflectablePtrFieldBase* _field, IReflectable* _object, UINT32 _id)
+			PtrToResolve(RTTIReflectablePtrFieldBase* _field, std::shared_ptr<IReflectable> _object, UINT32 _id)
 				:field(_field), object(_object), id(_id), arrIdx(0)
 			{ }
 
-			PtrToResolve(RTTIReflectablePtrFieldBase* _field, IReflectable* _object, UINT32 _id, UINT32 _arrIdx)
+			PtrToResolve(RTTIReflectablePtrFieldBase* _field, std::shared_ptr<IReflectable> _object, UINT32 _id, UINT32 _arrIdx)
 				:field(_field), object(_object), id(_id), arrIdx(_arrIdx)
 			{ }
 
 			RTTIReflectablePtrFieldBase* field;
 			UINT32 arrIdx;
-			IReflectable* object;
+			std::shared_ptr<IReflectable> object;
 			UINT32 id;
 		};
 
@@ -104,7 +104,7 @@ namespace CamelotEngine
 		int mTotalBytesWritten;
 
 		std::vector<PtrToResolve> mPtrsToResolve;
-		std::unordered_map<UINT32, IReflectable*> mDecodedObjects;
+		std::unordered_map<UINT32, std::shared_ptr<IReflectable>> mDecodedObjects;
 
 
 		UINT32 getObjectSize(IReflectable* object);
@@ -118,7 +118,7 @@ namespace CamelotEngine
 		/**
 		 * @brief	Decodes a single IReflectable object.
 		 */
-		bool decodeInternal(IReflectable* object, UINT8* data, UINT32 dataLength, UINT32& bytesRead);
+		bool decodeInternal(std::shared_ptr<IReflectable> object, UINT8* data, UINT32 dataLength, UINT32& bytesRead);
 
 		/**
 		* @brief	Encodes data required for representing a serialized field, into 4 bytes.
@@ -158,7 +158,7 @@ namespace CamelotEngine
 		/**
 		 * @brief	Helper method for decoding a complex object from the provided data buffer.
 		 */
-		IReflectable* complexTypeFromBuffer(RTTIReflectableFieldBase* field, UINT8* data, int* complexTypeSize);
+		std::shared_ptr<IReflectable> complexTypeFromBuffer(RTTIReflectableFieldBase* field, UINT8* data, int* complexTypeSize);
 
 		/**
 		 * @brief	Finds an existing, or creates a unique unique identifier for the specified object. 
@@ -170,6 +170,6 @@ namespace CamelotEngine
 		 * 			And it adds the object to a list of objects that need to be encoded,
 		 * 			if it's not already there.
 		 */
-		UINT32 registerObjectPtr(IReflectable* object);
+		UINT32 registerObjectPtr(std::shared_ptr<IReflectable> object);
 	};
 }

CamelotUtility/Include/CmFileSerializer.h

@@ -13,7 +13,7 @@ namespace CamelotEngine
 		~FileSerializer();
 
 		void encode(IReflectable* object, std::string fileLocation);
-		void decode(IReflectable* object, std::string fileLocation);
+		void decode(std::shared_ptr<IReflectable> object, std::string fileLocation);
 
 	private:
 		std::ofstream mOutputStream;

CamelotUtility/Include/CmRTTIReflectablePtrField.h

@@ -8,13 +8,13 @@ namespace CamelotEngine
 {
 	struct RTTIReflectablePtrFieldBase : public RTTIField
 	{
-		virtual IReflectable* getValue(void* object) = 0;
-		virtual IReflectable* getArrayValue(void* object, UINT32 index) = 0;
+		virtual std::shared_ptr<IReflectable> getValue(void* object) = 0;
+		virtual std::shared_ptr<IReflectable> getArrayValue(void* object, UINT32 index) = 0;
 
-		virtual void setValue(void* object, IReflectable* value) = 0;
-		virtual void setArrayValue(void* object, UINT32 index, IReflectable* value) = 0;
+		virtual void setValue(void* object, std::shared_ptr<IReflectable> value) = 0;
+		virtual void setArrayValue(void* object, UINT32 index, std::shared_ptr<IReflectable> value) = 0;
 
-		virtual IReflectable* newObject() = 0;
+		virtual std::shared_ptr<IReflectable> newObject() = 0;
 
 		virtual bool hasDynamicSize() { return true; }
 	};
@@ -62,29 +62,29 @@ namespace CamelotEngine
 			return 0; // Complex types don't store size the conventional way
 		}
 
-		virtual IReflectable* getValue(void* object)
+		virtual std::shared_ptr<IReflectable> getValue(void* object)
 		{
 			checkIsArray(false);
 
 			ObjectType* castObjType = static_cast<ObjectType*>(object);
-			boost::function<DataType*(ObjectType*)> f = boost::any_cast<boost::function<DataType*(ObjectType*)>>(valueGetter);
-			IReflectable* castDataType = f(castObjType);
+			boost::function<std::shared_ptr<DataType>(ObjectType*)> f = boost::any_cast<boost::function<std::shared_ptr<DataType>(ObjectType*)>>(valueGetter);
+			std::shared_ptr<IReflectable> castDataType = f(castObjType);
 
 			return castDataType;
 		}
 
-		virtual IReflectable* getArrayValue(void* object, UINT32 index)
+		virtual std::shared_ptr<IReflectable> getArrayValue(void* object, UINT32 index)
 		{
 			checkIsArray(true);
 
 			ObjectType* castObjType = static_cast<ObjectType*>(object);
-			boost::function<DataType*(ObjectType*, UINT32)> f = boost::any_cast<boost::function<DataType*(ObjectType*, UINT32)>>(valueGetter);
+			boost::function<std::shared_ptr<DataType>(ObjectType*, UINT32)> f = boost::any_cast<boost::function<std::shared_ptr<DataType>(ObjectType*, UINT32)>>(valueGetter);
 
-			IReflectable* castDataType = f(castObjType, index);
+			std::shared_ptr<IReflectable> castDataType = f(castObjType, index);
 			return castDataType;
 		}
 
-		virtual void setValue(void* object, IReflectable* value)
+		virtual void setValue(void* object, std::shared_ptr<IReflectable> value)
 		{
 			checkIsArray(false);
 
@@ -95,12 +95,12 @@ namespace CamelotEngine
 			}
 
 			ObjectType* castObjType = static_cast<ObjectType*>(object);
-			DataType* castDataObj = static_cast<DataType*>(value);
-			boost::function<void(ObjectType*, DataType*)> f = boost::any_cast<boost::function<void(ObjectType*, DataType*)>>(valueSetter);
+			std::shared_ptr<DataType> castDataObj = std::static_pointer_cast<DataType>(value);
+			boost::function<void(ObjectType*, std::shared_ptr<DataType>)> f = boost::any_cast<boost::function<void(ObjectType*, std::shared_ptr<DataType>)>>(valueSetter);
 			f(castObjType, castDataObj);
 		}
 
-		virtual void setArrayValue(void* object, UINT32 index, IReflectable* value)
+		virtual void setArrayValue(void* object, UINT32 index, std::shared_ptr<IReflectable> value)
 		{
 			checkIsArray(true);
 
@@ -111,8 +111,8 @@ namespace CamelotEngine
 			}
 
 			ObjectType* castObjType = static_cast<ObjectType*>(object);
-			DataType* castDataObj = static_cast<DataType*>(value);
-			boost::function<void(ObjectType*, UINT32, DataType*)> f = boost::any_cast<boost::function<void(ObjectType*, UINT32, DataType*)>>(valueSetter);
+			std::shared_ptr<DataType> castDataObj = static_pointer_cast<DataType>(value);
+			boost::function<void(ObjectType*, UINT32, std::shared_ptr<DataType>)> f = boost::any_cast<boost::function<void(ObjectType*, UINT32, std::shared_ptr<DataType>)>>(valueSetter);
 			f(castObjType, index, castDataObj);
 		}
 
@@ -140,9 +140,9 @@ namespace CamelotEngine
 			f(castObject, size);
 		}
 
-		virtual IReflectable* newObject()
+		virtual std::shared_ptr<IReflectable> newObject()
 		{
-			return DataType::newObject();
+			return std::shared_ptr<IReflectable>(DataType::newObject());
 		}
 	};
 }

CamelotUtility/Include/CmRTTIType.h

@@ -102,7 +102,7 @@ namespace CamelotEngine
 
 
 		template <class ObjectType, class DataType>
-		void setReflectablePtrValue(ObjectType* object, const std::string& name, DataType* value)
+		void setReflectablePtrValue(ObjectType* object, const std::string& name, std::shared_ptr<DataType> value)
 		{
 			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
 				"Invalid data type for complex field. It needs to derive from CamelotEngine::IReflectable.");
@@ -115,7 +115,7 @@ namespace CamelotEngine
 		}
 
 		template <class ObjectType, class DataType>
-		void setReflectablePtrArrayValue(ObjectType* object, const std::string& name, UINT32 index, DataType* value)
+		void setReflectablePtrArrayValue(ObjectType* object, const std::string& name, UINT32 index, std::shared_ptr<DataType> value)
 		{
 			BOOST_STATIC_ASSERT_MSG((boost::is_base_of<CamelotEngine::IReflectable, DataType>::value), 
 				"Invalid data type for complex field. It needs to derive from CamelotEngine::IReflectable.");
@@ -178,7 +178,7 @@ namespace CamelotEngine
 		}
 
 		template <class ObjectType>
-		IReflectable* getReflectablePtrValue(ObjectType* object, const std::string& name)
+		std::shared_ptr<IReflectable> getReflectablePtrValue(ObjectType* object, const std::string& name)
 		{
 			RTTIField* genericField = findField(name);
 			genericField->checkIsComplexPtr(false);
@@ -188,7 +188,7 @@ namespace CamelotEngine
 		}
 
 		template <class ObjectType>
-		IReflectable* getReflectablePtrArrayValue(ObjectType* object, const std::string& name, UINT32 index)
+		std::shared_ptr<IReflectable> getReflectablePtrArrayValue(ObjectType* object, const std::string& name, UINT32 index)
 		{
 			RTTIField* genericField = findField(name);
 			genericField->checkIsComplexPtr(true);
@@ -277,11 +277,11 @@ namespace CamelotEngine
 		}
 
 		template<class ObjectType, class DataType>
-		void addReflectablePtrField(const std::string& name, UINT32 uniqueId, DataType* (ObjectType::*getter)(), void (ObjectType::*setter)(DataType*) = nullptr)
+		void addReflectablePtrField(const std::string& name, UINT32 uniqueId, std::shared_ptr<DataType> (ObjectType::*getter)(), void (ObjectType::*setter)(std::shared_ptr<DataType>) = nullptr)
 		{
 			addReflectablePtrField<ObjectType, DataType>(name, uniqueId, 
-				boost::function<DataType*(ObjectType*)>(getter), 
-				boost::function<void(ObjectType*, DataType*)>(setter));
+				boost::function<std::shared_ptr<DataType>(ObjectType*)>(getter), 
+				boost::function<void(ObjectType*, std::shared_ptr<DataType>)>(setter));
 		}
 
 		template<class ObjectType, class DataType>
@@ -307,13 +307,13 @@ namespace CamelotEngine
 		}
 
 		template<class ObjectType, class DataType>
-		void addReflectablePtrArrayField(const std::string& name, UINT32 uniqueId, DataType* (ObjectType::*getter)(UINT32), UINT32 (ObjectType::*getSize)(), 
-			void (ObjectType::*setter)(UINT32, DataType*) = nullptr, void(ObjectType::*setSize)(UINT32) = nullptr)
+		void addReflectablePtrArrayField(const std::string& name, UINT32 uniqueId, std::shared_ptr<DataType> (ObjectType::*getter)(UINT32), UINT32 (ObjectType::*getSize)(), 
+			void (ObjectType::*setter)(UINT32, std::shared_ptr<DataType>) = nullptr, void(ObjectType::*setSize)(UINT32) = nullptr)
 		{
 			addReflectablePtrArrayField<ObjectType, DataType>(name, uniqueId, 
-				boost::function<DataType*(ObjectType*, UINT32)>(getter), 
+				boost::function<std::shared_ptr<DataType>(ObjectType*, UINT32)>(getter), 
 				boost::function<UINT32(ObjectType*)>(getSize), 
-				boost::function<void(ObjectType*, UINT32, DataType*)>(setter), 
+				boost::function<void(ObjectType*, UINT32, std::shared_ptr<DataType>)>(setter), 
 				boost::function<void(ObjectType*, UINT32)>(setSize));
 		}
 
@@ -358,12 +358,12 @@ namespace CamelotEngine
 
 		template<class InterfaceType, class ObjectType, class DataType>
 		void addReflectablePtrField(const std::string& name, UINT32 uniqueId, 
-			DataType* (InterfaceType::*getter)(ObjectType*), 
-			void (InterfaceType::*setter)(ObjectType*, DataType*) = nullptr)
+			std::shared_ptr<DataType> (InterfaceType::*getter)(ObjectType*), 
+			void (InterfaceType::*setter)(ObjectType*, std::shared_ptr<DataType>) = nullptr)
 		{
 			addReflectablePtrField<ObjectType, DataType>(name, uniqueId, 
-				boost::function<DataType*(ObjectType*)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1)), 
-				boost::function<void(ObjectType*, DataType*)>(boost::bind(setter, static_cast<InterfaceType*>(this), _1, _2)));
+				boost::function<std::shared_ptr<DataType>(ObjectType*)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1)), 
+				boost::function<void(ObjectType*, std::shared_ptr<DataType>)>(boost::bind(setter, static_cast<InterfaceType*>(this), _1, _2)));
 		}
 
 		template<class InterfaceType, class ObjectType, class DataType>
@@ -396,15 +396,15 @@ namespace CamelotEngine
 
 		template<class InterfaceType, class ObjectType, class DataType>
 		void addReflectablePtrArrayField(const std::string& name, UINT32 uniqueId, 
-			DataType* (InterfaceType::*getter)(ObjectType*, UINT32), 
+			std::shared_ptr<DataType> (InterfaceType::*getter)(ObjectType*, UINT32), 
 			UINT32 (InterfaceType::*getSize)(ObjectType*), 
-			void (InterfaceType::*setter)(ObjectType*, UINT32, DataType*) = nullptr, 
+			void (InterfaceType::*setter)(ObjectType*, UINT32, std::shared_ptr<DataType>) = nullptr, 
 			void(InterfaceType::*setSize)(ObjectType*, UINT32) = nullptr)
 		{
 			addReflectablePtrArrayField<ObjectType, DataType>(name, uniqueId, 
-				boost::function<DataType*(ObjectType*, UINT32)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1, _2)), 
+				boost::function<std::shared_ptr<DataType>(ObjectType*, UINT32)>(boost::bind(getter, static_cast<InterfaceType*>(this), _1, _2)), 
 				boost::function<UINT32(ObjectType*)>(boost::bind(getSize, static_cast<InterfaceType*>(this), _1)), 
-				boost::function<void(ObjectType*, UINT32, DataType*)>(boost::bind(setter, static_cast<InterfaceType*>(this), _1, _2, _3)), 
+				boost::function<void(ObjectType*, UINT32, std::shared_ptr<DataType>)>(boost::bind(setter, static_cast<InterfaceType*>(this), _1, _2, _3)), 
 				boost::function<void(ObjectType*, UINT32)>(boost::bind(setSize, static_cast<InterfaceType*>(this), _1, _2)));
 		}
 

CamelotUtility/Source/CmBinarySerializer.cpp

@@ -73,8 +73,8 @@ namespace CamelotEngine
 				if(foundExisting != serializedObjects.end())
 					continue; // Already processed
 
-				IReflectable* curObject = iter->object;
-				buffer = encodeInternal(curObject, iter->objectId, buffer, bufferLength, bytesWritten, flushBufferCallback);
+				std::shared_ptr<IReflectable> curObject = iter->object;
+				buffer = encodeInternal(curObject.get(), iter->objectId, buffer, bufferLength, bytesWritten, flushBufferCallback);
 				if(buffer == nullptr)
 				{
 					CM_EXCEPT(InternalErrorException, 
@@ -101,7 +101,7 @@ namespace CamelotEngine
 		*bytesWritten = mTotalBytesWritten;
 	}
 
-	void BinarySerializer::decode(IReflectable* object, UINT8* data, UINT32 dataLength)
+	void BinarySerializer::decode(std::shared_ptr<IReflectable> object, UINT8* data, UINT32 dataLength)
 	{
 		mPtrsToResolve.clear();
 		mDecodedObjects.clear();
@@ -142,7 +142,7 @@ namespace CamelotEngine
 
 		for(auto iter = mPtrsToResolve.begin(); iter != mPtrsToResolve.end(); ++iter)
 		{
-			IReflectable* resolvedObject = nullptr;
+			std::shared_ptr<IReflectable> resolvedObject = nullptr;
 
 			PtrToResolve curPtr = *iter;
 			if(curPtr.id != 0)
@@ -153,9 +153,9 @@ namespace CamelotEngine
 			}
 
 			if(curPtr.field->mIsVectorType)
-				curPtr.field->setArrayValue(curPtr.object, curPtr.arrIdx, resolvedObject);
+				curPtr.field->setArrayValue(curPtr.object.get(), curPtr.arrIdx, resolvedObject);
 			else
-				curPtr.field->setValue(curPtr.object, resolvedObject);
+				curPtr.field->setValue(curPtr.object.get(), resolvedObject);
 		}
 	}
 
@@ -196,7 +196,7 @@ namespace CamelotEngine
 
 						for(UINT32 arrIdx = 0; arrIdx < arrayNumElems; arrIdx++)
 						{
-							IReflectable* childObject = curField->getArrayValue(object, arrIdx); 
+							std::shared_ptr<IReflectable> childObject = curField->getArrayValue(object, arrIdx); 
 
 							UINT32 objId = registerObjectPtr(childObject);
 							COPY_TO_BUFFER(&objId, sizeof(UINT32))
@@ -259,7 +259,7 @@ namespace CamelotEngine
 				case SerializableFT_ReflectablePtr:
 					{
 						RTTIReflectablePtrFieldBase* curField = static_cast<RTTIReflectablePtrFieldBase*>(curGenericField);
-						IReflectable* childObject = curField->getValue(object); 
+						std::shared_ptr<IReflectable> childObject = curField->getValue(object); 
 
 						UINT32 objId = registerObjectPtr(childObject);
 						COPY_TO_BUFFER(&objId, sizeof(UINT32))
@@ -351,7 +351,7 @@ namespace CamelotEngine
 		return buffer;
 	}
 
-	bool BinarySerializer::decodeInternal(IReflectable* object, UINT8* data, UINT32 dataLength, UINT32& bytesRead)
+	bool BinarySerializer::decodeInternal(std::shared_ptr<IReflectable> object, UINT8* data, UINT32 dataLength, UINT32& bytesRead)
 	{
 		static const int META_SIZE = 4; // Meta field size
 		static const int NUM_ELEM_FIELD_SIZE = 4; // Size of the field storing number of array elements
@@ -451,7 +451,7 @@ namespace CamelotEngine
 				bytesRead += NUM_ELEM_FIELD_SIZE;
 
 				if(curGenericField != nullptr)
-					curGenericField->setArraySize(object, arrayNumElems);
+					curGenericField->setArraySize(object.get(), arrayNumElems);
 
 				switch(fieldType)
 				{
@@ -493,9 +493,8 @@ namespace CamelotEngine
 							int complexTypeSize = COMPLEX_TYPE_FIELD_SIZE;
 							if(curField != nullptr)
 							{
-								IReflectable* complexType = complexTypeFromBuffer(curField, data, &complexTypeSize);
-								curField->setArrayValue(object, i, *complexType);
-								delete complexType;
+								std::shared_ptr<IReflectable> complexType = complexTypeFromBuffer(curField, data, &complexTypeSize);
+								curField->setArrayValue(object.get(), i, *complexType);
 							}
 
 							data += complexTypeSize;
@@ -514,7 +513,7 @@ namespace CamelotEngine
 								memcpy(&typeSize, data, sizeof(UINT32));
 
 							if(curField != nullptr)
-								curField->arrayElemFromBuffer(object, i, data);
+								curField->arrayElemFromBuffer(object.get(), i, data);
 
 							data += typeSize;
 							bytesRead += typeSize;
@@ -564,9 +563,8 @@ namespace CamelotEngine
 						int complexTypeSize = COMPLEX_TYPE_FIELD_SIZE;
 						if(curField != nullptr)
 						{
-							IReflectable* complexType = complexTypeFromBuffer(curField, data, &complexTypeSize);
-							curField->setValue(object, *complexType);
-							delete complexType;
+							std::shared_ptr<IReflectable> complexType = complexTypeFromBuffer(curField, data, &complexTypeSize);
+							curField->setValue(object.get(), *complexType);
 						}
 
 						data += complexTypeSize;
@@ -583,7 +581,7 @@ namespace CamelotEngine
 							memcpy(&typeSize, data, sizeof(UINT32));
 
 						if(curField != nullptr)
-							curField->fromBuffer(object, data);
+							curField->fromBuffer(object.get(), data);
 
 						data += typeSize;
 						bytesRead += typeSize;
@@ -618,7 +616,7 @@ namespace CamelotEngine
 							memcpy(dataCopy, data, dataBlockSize);		//    can just pass the buffer pointer directly without copying (possibly large amounts of data)
 
 							ManagedDataBlock value(dataCopy, dataBlockSize, false); // Not managed because I assume the owner class will decide whether to delete the data or keep it
-							curField->setValue(object, value);
+							curField->setValue(object.get(), value);
 						}
 
 						data += dataBlockSize;
@@ -812,7 +810,8 @@ namespace CamelotEngine
 		return ((encodedData & 0x01) != 0);
 	}
 
-	UINT8* BinarySerializer::complexTypeToBuffer(IReflectable* object, UINT8* buffer, UINT32& bufferLength, int* bytesWritten, boost::function<UINT8*(UINT8*, int, UINT32&)> flushBufferCallback)
+	UINT8* BinarySerializer::complexTypeToBuffer(IReflectable* object, UINT8* buffer, UINT32& bufferLength, 
+		int* bytesWritten, boost::function<UINT8*(UINT8*, int, UINT32&)> flushBufferCallback)
 	{
 		static const UINT32 COMPLEX_TYPE_FIELD_SIZE = 4; // Size of the field storing the size of a child complex type
 
@@ -828,17 +827,17 @@ namespace CamelotEngine
 		return buffer;
 	}
 
-	IReflectable* BinarySerializer::complexTypeFromBuffer(RTTIReflectableFieldBase* field, UINT8* data, int* complexTypeSize)
+	std::shared_ptr<IReflectable> BinarySerializer::complexTypeFromBuffer(RTTIReflectableFieldBase* field, UINT8* data, int* complexTypeSize)
 	{
 		static const int COMPLEX_TYPE_FIELD_SIZE = 4; // Size of the field storing the size of a child complex type
 
 		memcpy(complexTypeSize, data, COMPLEX_TYPE_FIELD_SIZE);
 		data += COMPLEX_TYPE_FIELD_SIZE;
 
-		IReflectable* emptyObject = nullptr;
+		std::shared_ptr<IReflectable> emptyObject = nullptr;
 		if(*complexTypeSize > 0)
 		{
-			emptyObject = field->newObject();
+			emptyObject = std::shared_ptr<IReflectable>(field->newObject());
 			UINT32 dummy = 0;
 			decodeInternal(emptyObject, data, *complexTypeSize, dummy);
 		}
@@ -862,17 +861,17 @@ namespace CamelotEngine
 		return objId;
 	}
 
-	UINT32 BinarySerializer::registerObjectPtr(IReflectable* object)
+	UINT32 BinarySerializer::registerObjectPtr(std::shared_ptr<IReflectable> object)
 	{
 		if(object == nullptr)
 			return 0;
 
-		UINT32 ptrAddress = (UINT32)object;
+		UINT32 ptrAddress = (UINT32)object.get();
 
 		auto iterFind = mObjectAddrToId.find(ptrAddress);
 		if(iterFind == mObjectAddrToId.end())
 		{
-			UINT32 objId = findOrCreatePersistentId(object);
+			UINT32 objId = findOrCreatePersistentId(object.get());
 
 			mObjectsToEncode.push_back(ObjectToEncode(objId, object));
 			mObjectAddrToId.insert(std::make_pair(ptrAddress, objId));

CamelotUtility/Source/CmFileSerializer.cpp

@@ -31,7 +31,7 @@ namespace CamelotEngine
 		mOutputStream.clear();
 	}
 
-	void FileSerializer::decode(IReflectable* object, std::string fileLocation)
+	void FileSerializer::decode(std::shared_ptr<IReflectable> object, std::string fileLocation)
 	{
 		mInputStream.open(fileLocation.c_str(), std::ios::in | std::ios::ate | std::ios::binary);