+Unity Runtime codeHEADmaster

1 files changed, 290 insertions, 0 deletions

diff --git a/Runtime/Serialize/TransferFunctions/SafeBinaryRead.h b/Runtime/Serialize/TransferFunctions/SafeBinaryRead.h
new file mode 100644
index 0000000..e6cd5a3
--- /dev/null
+++ b/Runtime/Serialize/TransferFunctions/SafeBinaryRead.h
@@ -0,0 +1,290 @@
+#ifndef SAFEBINARYREAD_H
+#define SAFEBINARYREAD_H
+
+#include "Configuration/UnityConfigure.h"
+
+#if SUPPORT_SERIALIZED_TYPETREES
+
+#include "Runtime/Serialize/TransferFunctions/TransferBase.h"
+#include "Runtime/Serialize/CacheWrap.h"
+#include "Runtime/Serialize/SwapEndianBytes.h"
+
+#include <stack>
+class dynamic_bitset;
+class SafeBinaryRead;
+
+#define LOG_CONVERTING_VARIBALES 0
+#define LOG_MISSING_VARIBALES 0
+
+typedef bool ConversionFunction (void* inData, SafeBinaryRead& transfer);
+
+class EXPORT_COREMODULE SafeBinaryRead : public TransferBase
+{
+	CachedReader               m_Cache;
+	SInt32                  m_BaseBytePosition;
+	SInt32                  m_BaseByteSize;
+
+	const TypeTree*         m_OldBaseType;
+	#if UNITY_EDITOR
+	bool                    m_TypeTreeHasChanged;
+	#endif
+
+	enum { kNotFound = 0, kMatchesType = 1, kFastPathMatchesType = 2, kNeedConversion = -1 };
+
+	struct StackedInfo
+	{
+		const TypeTree* type; /// The type tree of the old type we are reading data from
+		const char*     currentTypeName; /// The name of the type we are currently reading (This is the new type name and not from the stored data)
+		int             bytePosition;/// byte position of that element
+		int             version; /// current version (This is the new version and not from the stored data)
+
+		int             cachedBytePosition; /// The cached byte position of the last visited child
+		TypeTree::const_iterator cachedIterator; /// The cached iterator of the last visited child
+		#if UNITY_EDITOR
+		int             lookupCount; // counts number of looks, used to determine if the typetree matches
+		#endif
+
+		#if !UNITY_RELEASE
+		std::string     currentTypeNameCheck;/// For debugging purposes in case someone changes the typename string while still reading!
+		#endif
+
+	};
+
+	StackedInfo*                   m_CurrentStackInfo;
+	SInt32*                           m_CurrentPositionInArray;
+	std::stack<StackedInfo> m_StackInfo;
+
+	struct ArrayPositionInfo
+	{
+		SInt32 arrayPosition;
+		SInt32 cachedBytePosition;
+		SInt32 cachedArrayPosition;
+	};
+
+	std::stack<ArrayPositionInfo>  m_PositionInArray;// position in an array
+
+	bool m_DidReadLastProperty;
+	
+	friend class MonoBehaviour;
+
+public:
+
+	CachedReader& Init (const TypeTree& oldBase, int bytePosition, int byteSize, int flags);
+	CachedReader& Init (SafeBinaryRead& transfer);
+	~SafeBinaryRead ();
+
+	void SetVersion (int version);
+	bool IsCurrentVersion ();
+	bool IsOldVersion (int version);
+	bool IsVersionSmallerOrEqual (int version);
+
+	bool IsReading ()                          { return true; }
+	bool IsReadingPPtr ()                      { return true; }
+	bool IsReadingBackwardsCompatible ()       { return true; }
+	bool NeedsInstanceIDRemapping ()                   { return m_Flags & kNeedsInstanceIDRemapping; }
+	bool ConvertEndianess ()                   { return m_Flags & kSwapEndianess; }
+
+	bool DidReadLastProperty ()                { return m_DidReadLastProperty; }
+	bool DidReadLastPPtrProperty ()            { return m_DidReadLastProperty; }
+
+	template<class T>
+	void Transfer (T& data, const char* name, TransferMetaFlags metaFlag = kNoTransferFlags);
+
+	template<class T>
+	void TransferWithTypeString (T& data, const char* name, const char* typeName, TransferMetaFlags metaFlag = kNoTransferFlags);
+
+	/// In order to transfer typeless data (Read: transfer data real fast)
+	/// Call TransferTypeless. You have to always do this. Even for a proxytransfer. Then when you want to access the datablock.
+	/// Call TransferTypelessData
+	/// On return:
+	/// When reading bytesize will contain the size of the data block that should be read,
+	/// when writing bytesize has to contain the size of the datablock.
+	/// MarkerID will contain an marker which you have to give TransferTypelessData when you want to start the actual transfer.
+	/// optional: A serializedFile will be seperated into two chunks. One is the normal object data. (It is assumed that they are all relatively small)
+	/// So caching them makes a lot of sense. Big datachunks will be stored in another part of the file.
+	/// They will not be cached but usually read directly into the allocated memory, probably reading them asynchronously
+	void TransferTypeless (unsigned* byteSize, const char* name, TransferMetaFlags metaFlag = kNoTransferFlags);
+	// markerID is the id that was given by TransferTypeless.
+	// byteStart is the bytestart relative to the beginning of the typeless data
+	// copyData is a pointer to where the data will be written or read from
+	/// optional: if metaFlag is kTransferBigData the data will be optimized into seperate blocks,
+	void TransferTypelessData (unsigned byteSize, void* copyData, int metaData = 0);
+
+	template<class T>
+	void TransferBasicData (T& data);
+
+	template<class T>
+	void TransferPtr (bool, ReduceCopyData*){}
+
+	template<class T>
+	void TransferSTLStyleArray (T& data, TransferMetaFlags metaFlag = kNoTransferFlags);
+
+	template<class T>
+	void TransferSTLStyleMap (T& data, TransferMetaFlags metaFlag = kNoTransferFlags);
+
+	bool GetTransferFileInfo(unsigned* position, const char** filePath) const;
+
+	const TypeTree& GetActiveOldTypeTree () 	{ return *m_CurrentStackInfo->type; }
+
+	static void RegisterConverter (const char* oldType, const char* newType, ConversionFunction* converter);
+	static void CleanupConverterTable ();
+
+	#if UNITY_EDITOR
+	/// Returns if the typetree is different from what was loaded in.
+	/// Currently this is incomplete. Arrays will always return true.
+	bool HasDifferentTypeTree ()
+	{
+		return m_TypeTreeHasChanged;
+	}
+	#endif
+
+private:
+
+	// BeginTransfer / EndTransfer
+	int BeginTransfer (const char* name, const char* typeString, ConversionFunction** converter);
+	bool BeginArrayTransfer (const char* name, const char* typeString, SInt32& size);
+
+	// Override the root type name, this is used by scripts that can only determine the class type name after the mono class has actually been loaded
+	void OverrideRootTypeName (const char* typeString);
+
+	void EndTransfer ();
+	void EndArrayTransfer ();
+
+	void Walk (const TypeTree& typeTree, SInt32* bytePosition);
+};
+
+template<class T>inline
+void SafeBinaryRead::TransferBasicData (T& data)
+{
+	m_Cache.Read (data, m_CurrentStackInfo->bytePosition);
+	if (ConvertEndianess())
+	{
+		SwapEndianBytes (data);
+	}
+}
+
+template<class T> inline
+void SafeBinaryRead::TransferSTLStyleArray (T& data, TransferMetaFlags)
+{
+	SInt32 size = data.size ();
+	if (!BeginArrayTransfer ("Array", "Array", size))
+		return;
+
+	SerializeTraits<T>::ResizeSTLStyleArray (data, size);
+
+	typename T::iterator i;
+	typename T::iterator end = data.end ();
+	if (size != 0)
+	{
+		int conversion = BeginTransfer ("data", SerializeTraits<typename T::value_type>::GetTypeString(&*data.begin()), NULL);
+		int elementSize = m_CurrentStackInfo->type->m_ByteSize;
+		*m_CurrentPositionInArray = 0;
+		// If the data types are matching and element size can be determined
+		// then we fast path the whole thing and skip all the duplicate stack walking
+		if (conversion == kFastPathMatchesType)
+		{
+			int basePosition = m_CurrentStackInfo->bytePosition;
+
+			for (i = data.begin ();i != end;++i)
+			{
+				int currentBytePosition = basePosition + (*m_CurrentPositionInArray) * elementSize;
+				m_CurrentStackInfo->cachedBytePosition = currentBytePosition;
+				m_CurrentStackInfo->bytePosition = currentBytePosition;
+				m_CurrentStackInfo->cachedIterator = m_CurrentStackInfo->type->begin();
+				(*m_CurrentPositionInArray)++;
+				SerializeTraits<typename T::value_type>::Transfer (*i, *this);
+			}
+			EndTransfer();
+		}
+		// Fall back to converting variables
+		else
+		{
+			EndTransfer();
+			for (i = data.begin ();i != end;++i)
+				Transfer (*i, "data");
+		}
+	}
+
+	EndArrayTransfer ();
+}
+
+template<class T> inline
+void SafeBinaryRead::TransferSTLStyleMap (T& data, TransferMetaFlags)
+{
+	SInt32 size = data.size ();
+	if (!BeginArrayTransfer ("Array", "Array", size))
+		return;
+
+	// maps value_type is: pair<const First, Second>
+	// So we have to write to maps non-const value type
+	typename NonConstContainerValueType<T>::value_type p;
+
+	data.clear ();
+	for (int i=0;i<size;i++)
+	{
+		Transfer (p, "data");
+		data.insert (p);
+	}
+	EndArrayTransfer ();
+}
+
+template<class T> inline
+void SafeBinaryRead::TransferWithTypeString (T& data, const char* name, const char* typeName, TransferMetaFlags)
+{
+	ConversionFunction* converter;
+	int conversion = BeginTransfer (name, typeName, &converter);
+	if (conversion == kNotFound)
+		return;
+
+	if (conversion >= kMatchesType)
+		SerializeTraits<T>::Transfer (data, *this);
+	// Try conversion
+	else
+	{
+		bool success = false;
+		if (converter != NULL)
+			success = converter (&data, *this);
+
+		#if LOG_CONVERTING_VARIBALES
+		{
+			string s ("Converting variable ");
+			if (success)
+				s += " succeeded ";
+			else
+				s += " failed ";
+
+			GetTypePath (m_OldType.top (), s);
+			s = s + " new type: ";
+			s = s + " new type: (" + SerializeTraits<T>::GetTypeString () + ")\n";
+			m_OldBaseType->DebugPrint (s);
+			AssertStringQuiet (s);
+		}
+		#endif
+	}
+	EndTransfer ();
+}
+
+template<class T> inline
+void SafeBinaryRead::Transfer (T& data, const char* name, TransferMetaFlags)
+{
+	TransferWithTypeString(data, name, SerializeTraits<T>::GetTypeString(&data), kNoTransferFlags);
+}
+
+#else
+
+namespace SafeBinaryReadManager
+{
+	inline void StaticInitialize(){};
+	inline void StaticDestroy(){};
+}
+
+class SafeBinaryRead
+{
+public:
+	static void RegisterAllowTypeNameConversion (const char* oldTypeName, const char* newTypeName) { }
+	static void RegisterAllowNameConversion (const char* type, const char* oldName, const char* newName) { }
+	static void CleanupConverterTable() { }
+};
+
+#endif
+#endif