+Unity Runtime codeHEADmaster

1 files changed, 196 insertions, 0 deletions

diff --git a/Runtime/BaseClasses/MessageHandler.cpp b/Runtime/BaseClasses/MessageHandler.cpp
new file mode 100644
index 0000000..71ef06e
--- /dev/null
+++ b/Runtime/BaseClasses/MessageHandler.cpp
@@ -0,0 +1,196 @@
+#include "UnityPrefix.h"
+#include "MessageHandler.h"
+#include "Runtime/Utilities/LogAssert.h"
+#include <map>
+#include <list>
+
+using namespace std;
+
+MessageForwarder::MessageForwarder ()
+{
+	m_GeneralMessage = NULL;
+	m_CanHandleGeneralMessage = NULL;
+}
+
+void MessageForwarder::HandleMessage (void* receiver, int messageID, MessageData& messageData)
+{
+	MessageCallback messagePtr = m_GeneralMessage;
+	if (messageID < m_SupportedMessages.size () && m_SupportedMessages[messageID] != NULL)
+		messagePtr = m_SupportedMessages[messageID];
+
+	AssertIf (messagePtr == NULL);	
+	messagePtr (receiver, messageID, messageData);
+}
+
+bool MessageForwarder::HasMessageCallback (const MessageIdentifier& identifier)
+{
+	if (identifier.messageID < m_SupportedMessages.size () && m_SupportedMessages[identifier.messageID])
+		return true;
+	else
+		return m_GeneralMessage != NULL && (identifier.options & MessageIdentifier::kSendToScripts);
+}
+
+bool MessageForwarder::WillHandleMessage (void* receiver, const MessageIdentifier& identifier)
+{
+	if (identifier.messageID < m_SupportedMessages.size () && m_SupportedMessages[identifier.messageID])
+		return true;
+
+	if (m_GeneralMessage && (identifier.options & MessageIdentifier::kSendToScripts))
+	{
+		AssertIf (m_CanHandleGeneralMessage == NULL);
+		MessageData data;
+		return m_CanHandleGeneralMessage (receiver, identifier.messageID, data);
+	}
+	return false;	
+}
+
+int MessageForwarder::GetExpectedParameter (int messageID)
+{
+	if (messageID < m_SupportedMessages.size ())
+		return m_SupportedMessagesParameter[messageID];
+	else
+		return 0;
+}
+
+void MessageForwarder::RegisterMessageCallback (int messageID, MessageCallback message, int classId)
+{
+	AssertIf (messageID == -1);
+	if (messageID >= m_SupportedMessages.size ())
+	{
+		m_SupportedMessages.resize (messageID + 1, NULL);
+		m_SupportedMessagesParameter.resize (messageID + 1, 0);
+	}
+	m_SupportedMessages[messageID] = message;
+	m_SupportedMessagesParameter[messageID] = classId;
+}
+
+void MessageForwarder::RegisterAllMessagesCallback (MessageCallback message, CanHandleMessageCallback canHandle)
+{
+	m_GeneralMessage = message;
+	m_CanHandleGeneralMessage = canHandle;
+}
+
+void MessageForwarder::AddBaseMessages (const MessageForwarder& baseClass)
+{
+	int maxsize = max (m_SupportedMessages.size (), baseClass.m_SupportedMessages.size ());
+	m_SupportedMessages.resize (maxsize, NULL);
+	m_SupportedMessagesParameter.resize (maxsize, 0);
+	for (int i=0;i<m_SupportedMessages.size ();i++)
+	{
+		if (m_SupportedMessages[i] == NULL && i < baseClass.m_SupportedMessages.size ())
+		{
+			m_SupportedMessages[i] = baseClass.m_SupportedMessages[i];
+			m_SupportedMessagesParameter[i] = baseClass.m_SupportedMessagesParameter[i];
+		}
+	}
+
+	if (m_GeneralMessage == NULL)
+		m_GeneralMessage = baseClass.m_GeneralMessage;
+}
+
+void MessageHandler::InitializeMessageIdentifiers ()
+{
+	MessageIdentifier::RegisteredMessages& identifiers = MessageIdentifier::GetRegisteredMessages ();
+	MessageIdentifier::SortedMessages sortedMessages = MessageIdentifier::GetSortedMessages(false);
+	
+	m_MessageIDToIdentifier.clear ();
+	m_MessageNameToIndex.clear ();
+	
+	// Build m_MessageIDToName and m_MessageNameToIndex
+	// by copying the data from the sorted messages map
+	m_MessageIDToIdentifier.resize (sortedMessages.size ());
+	int index = 0; 
+	MessageIdentifier::SortedMessages::iterator i;
+	for (i = sortedMessages.begin ();i != sortedMessages.end ();i++)
+	{
+		m_MessageNameToIndex[i->first] = index;
+		m_MessageIDToIdentifier[index] = i->second;
+		m_MessageIDToIdentifier[index].messageID = index;
+		index++;
+	}
+	
+	
+	// Setup the messageIDs of all registered message Identifiers
+	MessageIdentifier::RegisteredMessages::iterator j;
+	for (j = identifiers.begin ();j != identifiers.end ();j++)
+	{
+		AssertIf (*j == NULL);
+		MessageIdentifier& identifier = **j;
+		if (m_MessageNameToIndex.count (identifier.messageName))
+		{
+			identifier.messageID = m_MessageNameToIndex[identifier.messageName];
+		}
+	}
+}
+
+void MessageHandler::Initialize (const MessageForwarders& receivers)
+{
+	m_Forwarder = receivers;
+	m_MessageCount = m_MessageNameToIndex.size ();
+	m_ClassCount = receivers.size ();
+	
+	// Precalculate supported messages
+	m_SupportedMessages.resize (m_ClassCount * m_MessageCount);
+	for (int c=0;c<m_ClassCount;c++)
+	{
+		for (int m=0;m<m_MessageCount;m++)
+		{
+			bool hasCallback = m_Forwarder[c].HasMessageCallback (m_MessageIDToIdentifier[m]);
+			if (hasCallback)
+			{
+				// Check if the parameter is correct and print an error if they dont match
+				int wantedParameter = m_Forwarder[c].GetExpectedParameter (m);
+				int messageParameter = m_MessageIDToIdentifier[m].parameterClassId;
+				if (wantedParameter != 0 && messageParameter != wantedParameter)
+				{
+					char buffy[4096];
+					char const format[] = "The message: %s in the class with "
+										  "classID: %d uses a parameter type "
+										  "that is different from the "
+										  "message's parameter type: %d != %d.";
+					sprintf (buffy, format, m_MessageIDToIdentifier[m].messageName,
+							 c, wantedParameter, messageParameter);
+					ErrorString (buffy);
+					hasCallback = false;
+				}
+			}
+			m_SupportedMessages[m * m_ClassCount + c] = hasCallback;
+		}
+	}
+}
+
+bool MessageHandler::WillHandleMessage (void* receiver, int classID, int messageID)
+{
+	AssertIf (!HasMessageCallback (classID, messageID));
+	return m_Forwarder[classID].WillHandleMessage (receiver, m_MessageIDToIdentifier[messageID]);
+}
+
+int MessageHandler::MessageNameToID (const string& name)
+{
+	MessageNameToIndex::iterator i = m_MessageNameToIndex.find (name);
+	if (i == m_MessageNameToIndex.end ())
+		return -1;
+	else
+		return i->second;
+}
+
+const char* MessageHandler::MessageIDToName (int messageID)
+{
+	AssertIf (messageID < 0);
+	AssertIf (messageID >= m_MessageIDToIdentifier.size ());
+	return m_MessageIDToIdentifier[messageID].messageName;
+}
+
+int MessageHandler::MessageIDToParameter (int messageID)
+{
+	AssertIf (messageID < 0);
+	AssertIf (messageID >= m_MessageIDToIdentifier.size ());
+	return m_MessageIDToIdentifier[messageID].parameterClassId;
+}
+
+MessageIdentifier MessageHandler::MessageIDToMessageIdentifier (int messageID)
+{
+	AssertIf (messageID < 0);
+	AssertIf (messageID >= m_MessageIDToIdentifier.size ());
+	return m_MessageIDToIdentifier[messageID];
+}