remove id from dispatcher

include/sp/common/DataBuffer.h

@@ -204,8 +204,6 @@ class DataBuffer {
 		return m_Buffer == other.m_Buffer;
 	}
 
-	void insert(iterator a_DestBegin, const_iterator a_SrcBegin, const_iterator a_SrcEnd);
-
 	iterator begin();
 	iterator end();
 	const_iterator begin() const;

include/sp/common/DataBufferOperators.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <sp/common/DataBuffer.h>
 #include <boost/pfr.hpp>
+#include <sp/common/DataBuffer.h>
 
 namespace sp {
 
@@ -11,6 +11,74 @@ using is_default_serializable = std::bool_constant<(std::is_class_v<T> && std::i
 template <typename T>
 static constexpr bool is_default_serializable_v = is_default_serializable<T>::value;
 
+namespace details {
+
+template <typename T>
+void WriteRaw(DataBuffer& a_Buffer, T a_Data);
+
+template <typename T>
+void WriteFields(DataBuffer& a_Buffer, const T& a_Data);
+
+template <typename T>
+void WriteSharedPtr(DataBuffer& a_Buffer, const std::shared_ptr<T>& a_Data);
+
+template <typename T>
+void WriteUniquePtr(DataBuffer& a_Buffer, const std::unique_ptr<T>& a_Data);
+
+template <typename T>
+void WriteVector(DataBuffer& a_Buffer, const std::vector<T>& a_Data);
+
+template <typename T>
+void WriteList(DataBuffer& a_Buffer, const std::list<T>& a_Data);
+
+template <typename K, typename V>
+void WriteMap(DataBuffer& a_Buffer, const std::map<K, V>& a_Data);
+
+template <typename K, typename V>
+void WriteUnorderedMap(DataBuffer& a_Buffer, const std::unordered_map<K, V>& a_Data);
+
+template <typename K, typename V>
+void WritePair(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data);
+
+template <typename T, std::size_t S>
+void WriteArray(DataBuffer& a_Buffer, const std::array<T, S>& a_Data);
+
+
+
+template <typename T>
+void ReadRaw(DataBuffer& a_Buffer, T& a_Data);
+
+template <typename T>
+void ReadFields(DataBuffer& a_Buffer, T& a_Data);
+
+template <typename T>
+void ReadSharedPtr(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data);
+
+template <typename T>
+void ReadUniquePtr(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data);
+
+template <typename T>
+void ReadVector(DataBuffer& a_Buffer, std::vector<T>& a_Data);
+
+template <typename T>
+void ReadList(DataBuffer& a_Buffer, std::list<T>& a_Data);
+
+template <typename K, typename V>
+void ReadMap(DataBuffer& a_Buffer, std::map<K, V>& a_Data);
+
+template <typename K, typename V>
+void ReadUnorderedMap(DataBuffer& a_Buffer, std::unordered_map<K, V>& a_Data);
+
+template <typename K, typename V>
+void ReadPair(DataBuffer& a_Buffer, std::pair<K, V>& a_Data);
+
+template <typename T, std::size_t S>
+void ReadArray(DataBuffer& a_Buffer, std::array<T, S>& a_Data);
+
+}  // namespace details
+
+
+
 
 /**
  * \brief Append data to the buffer (converted to big endian)
@@ -18,10 +86,9 @@ static constexpr bool is_default_serializable_v = is_default_serializable<T>::va
 template <typename T, typename = typename std::enable_if_t<is_default_serializable_v<T>>>
 DataBuffer& operator<<(DataBuffer& a_Buffer, const T& a_Data) {
 	if constexpr (std::is_class_v<T>) {
-		boost::pfr::for_each_field(a_Data, [&a_Buffer](const auto& a_Field) { a_Buffer << a_Field; });
+		details::WriteFields(a_Buffer, a_Data);
 	} else {
-		a_Buffer.Append(a_Data);
+		details::WriteRaw(a_Buffer, a_Data);
-		SwapBytes(a_Buffer.data() + a_Buffer.GetReadOffset() - sizeof(T), a_Buffer.data() + a_Buffer.GetReadOffset());
 	}
 	return a_Buffer;
 }
@@ -43,8 +110,9 @@ std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);
  * \param data The data to append
  */
 template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::shared_ptr<T>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::shared_ptr<T>& a_Data) {
-	return a_Buffer << *data;
+	details::WriteSharedPtr(a_Buffer, a_Data);
+	return a_Buffer;
 }
 
 /**
@@ -52,8 +120,9 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::shared_ptr<T>& data) {
  * \param data The data to append
  */
 template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unique_ptr<T>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unique_ptr<T>& a_Data) {
-	return a_Buffer << *data;
+	details::WriteUniquePtr(a_Buffer, a_Data);
+	return a_Buffer;
 }
 
 /**
@@ -61,11 +130,8 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unique_ptr<T>& data) {
  * \param data The vector to append
  */
 template <typename T>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::vector<T>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::vector<T>& a_Data) {
-	a_Buffer << VarInt{data.size()};
+	details::WriteVector(a_Buffer, a_Data);
-	for (const auto& element : data) {
-		a_Buffer << element;
-	}
 	return a_Buffer;
 }
 
@@ -74,11 +140,8 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::vector<T>& data) {
  * \param data The list to append
  */
 template <typename T>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::list<T>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::list<T>& a_Data) {
-	a_Buffer << VarInt{data.size()};
+	details::WriteList(a_Buffer, a_Data);
-	for (const auto& element : data) {
-		a_Buffer << element;
-	}
 	return a_Buffer;
 }
 
@@ -87,11 +150,8 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::list<T>& data) {
  * \param data The map to append
  */
 template <typename K, typename V>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::map<K, V>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::map<K, V>& a_Data) {
-	a_Buffer << VarInt{data.size()};
+	details::WriteMap(a_Buffer, a_Data);
-	for (const auto& [key, value] : data) {
-		a_Buffer << key << value;
-	}
 	return a_Buffer;
 }
 
@@ -100,11 +160,8 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::map<K, V>& data) {
  * \param data The map to append
  */
 template <typename K, typename V>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unordered_map<K, V>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unordered_map<K, V>& a_Data) {
-	a_Buffer << VarInt{data.size()};
+	details::WriteUnorderedMap(a_Buffer, a_Data);
-	for (const auto& [key, value] : data) {
-		a_Buffer << key << value;
-	}
 	return a_Buffer;
 }
 
@@ -113,8 +170,9 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::unordered_map<K, V>& dat
  * \param data The pair to append
  */
 template <typename K, typename V>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::pair<K, V>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data) {
-	return a_Buffer << data.first << data.second;
+	details::WritePair(a_Buffer, a_Data);
+	return a_Buffer;
 }
 
 /**
@@ -122,10 +180,8 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::pair<K, V>& data) {
  * \param data The buffer to append
  */
 template <typename T, std::size_t Size>
-DataBuffer& operator<<(DataBuffer& a_Buffer, const std::array<T, Size>& data) {
+DataBuffer& operator<<(DataBuffer& a_Buffer, const std::array<T, Size>& a_Data) {
-	for (const auto& element : data) {
+	details::WriteArray(a_Buffer, a_Data);
-		a_Buffer << element;
-	}
 	return a_Buffer;
 }
 
@@ -139,10 +195,9 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::array<T, Size>& data) {
 template <typename T, typename = typename std::enable_if_t<is_default_serializable_v<T>>>
 DataBuffer& operator>>(DataBuffer& a_Buffer, T& a_Data) {
 	if constexpr (std::is_class_v<T>) {
-		boost::pfr::for_each_field(a_Data, [&a_Buffer](auto& a_Field) { a_Buffer >> a_Field; });
+		details::ReadFields(a_Buffer, a_Data);
 	} else {
-		a_Buffer.Read(a_Data);
+		details::ReadRaw(a_Buffer, a_Data);
-		SwapBytes(a_Data);
 	}
 	return a_Buffer;
 }
@@ -151,7 +206,7 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, T& a_Data) {
  * \brief Read some data from the buffer and assign to the new buffer
  * \param data The buffer to assign
  */
-DataBuffer& operator>>(DataBuffer& a_Buffer, DataBuffer& data);
+DataBuffer& operator>>(DataBuffer& a_Buffer, DataBuffer& a_Data);
 
 /**
  * \brief Read a string from the buffer
@@ -164,18 +219,18 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::string& str);
  * \brief Read a pointer
  */
 template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::shared_ptr<T>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data) {
-	data = std::make_shared<T>();
+	details::ReadSharedPtr(a_Buffer, a_Data);
-	return a_Buffer >> *data;
+	return a_Buffer;
 }
 
 /**
  * \brief Read a pointer
  */
 template <typename T, typename = typename std::enable_if_t<!std::is_abstract_v<T>>>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<T>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data) {
-	data = std::make_unique<T>();
+	details::ReadUniquePtr(a_Buffer, a_Data);
-	return a_Buffer >> *data;
+	return a_Buffer;
 }
 
 /**
@@ -183,14 +238,8 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::unique_ptr<T>& data) {
  * \pre The vector is assumed to be empty
  */
 template <typename T>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::vector<T>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::vector<T>& a_Data) {
-	VarInt arraySize;
+	details::ReadVector(a_Buffer, a_Data);
-	a_Buffer >> arraySize;
-	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
-		T newElement;
-		a_Buffer >> newElement;
-		data.push_back(newElement);
-	}
 	return a_Buffer;
 }
 
@@ -199,14 +248,8 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::vector<T>& data) {
  * \pre The list is assumed to be empty
  */
 template <typename T>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::list<T>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::list<T>& a_Data) {
-	VarInt arraySize;
+	details::ReadList(a_Buffer, a_Data);
-	a_Buffer >> arraySize;
-	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
-		T newElement;
-		a_Buffer >> newElement;
-		data.push_back(newElement);
-	}
 	return a_Buffer;
 }
 
@@ -215,15 +258,8 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::list<T>& data) {
  * \pre The map is assumed to be empty
  */
 template <typename K, typename V>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::map<K, V>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::map<K, V>& a_Data) {
-	VarInt mapSize;
+	details::ReadMap(a_Buffer, a_Data);
-	a_Buffer >> mapSize;
-	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
-		K newKey;
-		V newValue;
-		a_Buffer >> newKey >> newValue;
-		data.emplace(newKey, newValue);
-	}
 	return a_Buffer;
 }
 
@@ -232,15 +268,8 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::map<K, V>& data) {
  * \pre The map is assumed to be empty
  */
 template <typename K, typename V>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::unordered_map<K, V>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::unordered_map<K, V>& a_Data) {
-	VarInt mapSize;
+	details::ReadUnorderedMap(a_Buffer, a_Data);
-	a_Buffer >> mapSize;
-	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
-		K newKey;
-		V newValue;
-		a_Buffer >> newKey >> newValue;
-		data.emplace(newKey, newValue);
-	}
 	return a_Buffer;
 }
 
@@ -248,21 +277,179 @@ DataBuffer& operator>>(DataBuffer& a_Buffer, std::unordered_map<K, V>& data) {
  * \brief Read a pair
  */
 template <typename K, typename V>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::pair<K, V>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::pair<K, V>& a_Data) {
-	return a_Buffer >> data.first >> data.second;
+	details::ReadPair(a_Buffer, a_Data);
+	return a_Buffer;
 }
 
 /**
  * \brief Read an array from the buffer
  */
 template <std::size_t Size, typename T>
-DataBuffer& operator>>(DataBuffer& a_Buffer, std::array<T, Size>& data) {
+DataBuffer& operator>>(DataBuffer& a_Buffer, std::array<T, Size>& a_Data) {
-	for (std::size_t i = 0; i < Size; i++) {
+	details::ReadArray(a_Buffer, a_Data);
-		T newElement;
-		a_Buffer >> newElement;
-		data[i] = newElement;
-	}
 	return a_Buffer;
 }
 
+
+
+
+
+namespace details {
+
+template <typename T>
+void WriteRaw(DataBuffer& a_Buffer, T a_Data) {
+	SwapBytes(a_Data);
+	a_Buffer.Append(a_Data);
+}
+
+template <typename T>
+void WriteFields(DataBuffer& a_Buffer, const T& a_Data) {
+	boost::pfr::for_each_field(a_Data, [&a_Buffer](const auto& a_Field) { a_Buffer << a_Field; });
+}
+
+template <typename T>
+void WriteSharedPtr(DataBuffer& a_Buffer, const std::shared_ptr<T>& a_Data) {
+	a_Buffer << *a_Data;
+}
+
+template <typename T>
+void WriteUniquePtr(DataBuffer& a_Buffer, const std::unique_ptr<T>& a_Data) {
+	a_Buffer << *a_Data;
+}
+
+template <typename T>
+void WriteVector(DataBuffer& a_Buffer, const std::vector<T>& a_Data) {
+	a_Buffer << VarInt{a_Data.size()};
+	for (const auto& element : a_Data) {
+		a_Buffer << element;
+	}
+}
+
+template <typename T>
+void WriteList(DataBuffer& a_Buffer, const std::list<T>& a_Data) {
+	a_Buffer << VarInt{a_Data.size()};
+	for (const auto& element : a_Data) {
+		a_Buffer << element;
+	}
+}
+
+template <typename K, typename V>
+void WriteMap(DataBuffer& a_Buffer, const std::map<K, V>& a_Data) {
+	a_Buffer << VarInt{a_Data.size()};
+	for (const auto& [key, value] : a_Data) {
+		a_Buffer << key << value;
+	}
+}
+
+template <typename K, typename V>
+void WriteUnorderedMap(DataBuffer& a_Buffer, const std::unordered_map<K, V>& a_Data) {
+	a_Buffer << VarInt{a_Data.size()};
+	for (const auto& [key, value] : a_Data) {
+		a_Buffer << key << value;
+	}
+}
+
+template <typename K, typename V>
+void WritePair(DataBuffer& a_Buffer, const std::pair<K, V>& a_Data) {
+	a_Buffer << a_Data.first << a_Data.second;
+}
+
+template <typename T, std::size_t S>
+void WriteArray(DataBuffer& a_Buffer, const std::array<T, S>& a_Data) {
+	for (const auto& element : a_Data) {
+		a_Buffer << element;
+	}
+}
+
+
+
+
+
+template <typename T>
+void ReadRaw(DataBuffer& a_Buffer, T& a_Data) {
+	a_Buffer.Read(a_Data);
+	SwapBytes(a_Data);
+}
+
+template <typename T>
+void ReadFields(DataBuffer& a_Buffer, T& a_Data) {
+	boost::pfr::for_each_field(a_Data, [&a_Buffer](auto& a_Field) { a_Buffer >> a_Field; });
+}
+
+template <typename T>
+void ReadSharedPtr(DataBuffer& a_Buffer, std::shared_ptr<T>& a_Data) {
+	a_Data = std::make_shared<T>();
+	a_Buffer >> *a_Data;
+}
+
+template <typename T>
+void ReadUniquePtr(DataBuffer& a_Buffer, std::unique_ptr<T>& a_Data) {
+	a_Data = std::make_unique<T>();
+	a_Buffer >> *a_Data;
+}
+
+template <typename T>
+void ReadVector(DataBuffer& a_Buffer, std::vector<T>& a_Data) {
+	VarInt arraySize;
+	a_Buffer >> arraySize;
+	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
+		T newElement;
+		a_Buffer >> newElement;
+		a_Data.push_back(newElement);
+	}
+}
+
+template <typename T>
+void ReadList(DataBuffer& a_Buffer, std::list<T>& a_Data) {
+	VarInt arraySize;
+	a_Buffer >> arraySize;
+	for (std::size_t i = 0; i < arraySize.GetValue(); i++) {
+		T newElement;
+		a_Buffer >> newElement;
+		a_Data.push_back(newElement);
+	}
+}
+
+template <typename K, typename V>
+void ReadMap(DataBuffer& a_Buffer, std::map<K, V>& a_Data) {
+	VarInt mapSize;
+	a_Buffer >> mapSize;
+	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
+		K newKey;
+		V newValue;
+		a_Buffer >> newKey >> newValue;
+		a_Data.emplace(newKey, newValue);
+	}
+}
+
+template <typename K, typename V>
+void ReadUnorderedMap(DataBuffer& a_Buffer, std::unordered_map<K, V>& a_Data) {
+	VarInt mapSize;
+	a_Buffer >> mapSize;
+	for (std::size_t i = 0; i < mapSize.GetValue(); i++) {
+		K newKey;
+		V newValue;
+		a_Buffer >> newKey >> newValue;
+		a_Data.emplace(newKey, newValue);
+	}
+}
+
+template <typename K, typename V>
+void ReadPair(DataBuffer& a_Buffer, std::pair<K, V>& a_Data) {
+	a_Buffer >> a_Data.first >> a_Data.a_Data;
+}
+
+template <typename T, std::size_t S>
+void ReadArray(DataBuffer& a_Buffer, std::array<T, S>& a_Data) {
+	for (std::size_t i = 0; i < S; i++) {
+		T newElement;
+		a_Buffer >> newElement;
+		a_Data[i] = newElement;
+	}
+}
+
+
+}  // namespace details
+
 }  // namespace sp

include/sp/protocol/MessageDispatcher.h

@@ -19,7 +19,6 @@ template <typename MessageBase>
 class MessageDispatcher {
   public:
 	using MessageBaseType = MessageBase;
-	using MessageIdType = typename MessageBase::MessageIdType;
 	using MessageHandler = typename MessageBase::HandlerType;
 
 	/**
@@ -38,23 +37,16 @@ class MessageDispatcher {
 	 * \param type The packet type
 	 * \param handler The packet handler
 	 */
-	void RegisterHandler(MessageIdType a_MessageType, MessageHandler* a_Handler);
+	void RegisterHandler(const std::shared_ptr<MessageHandler>& a_Handler);
-
-	/**
-	 * \brief Unregister a packet handler
-	 * \param type The packet type
-	 * \param handler The packet handler
-	 */
-	void UnregisterHandler(MessageIdType a_MessageType, MessageHandler* a_Handler);
 
 	/**
 	 * \brief Unregister a packet handler
 	 * \param handler The packet handler
 	 */
-	void UnregisterHandler(MessageHandler* a_Handler);
+	void UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler);
 
   private:
-	std::map<MessageIdType, std::vector<MessageHandler*>> m_Handlers;
+	std::vector<std::weak_ptr<MessageHandler>> m_Handlers;
 };
 
 }  // namespace sp

include/sp/protocol/MessageDispatcherImpl.inl

@@ -6,37 +6,22 @@
 namespace sp {
 
 template <typename MessageBase>
-void MessageDispatcher<MessageBase>::RegisterHandler(MessageIdType a_MessageType, MessageHandler* a_Handler) {
+void MessageDispatcher<MessageBase>::RegisterHandler(const std::shared_ptr<MessageHandler>& a_Handler) {
 	assert(a_Handler);
-	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+	m_Handlers.push_back(a_Handler);
-	if (found == m_Handlers[a_MessageType].end())
-		m_Handlers[a_MessageType].push_back(a_Handler);
 }
 
 template <typename MessageBase>
-void MessageDispatcher<MessageBase>::UnregisterHandler(MessageIdType a_MessageType, MessageHandler* a_Handler) {
+void MessageDispatcher<MessageBase>::UnregisterHandler(const std::shared_ptr<MessageHandler>& a_Handler) {
-	auto found = std::find(m_Handlers[a_MessageType].begin(), m_Handlers[a_MessageType].end(), a_Handler);
+	auto found = std::find(m_Handlers.begin(), m_Handlers.end(), a_Handler);
-	if (found != m_Handlers[a_MessageType].end())
+	if (found != m_Handlers.end())
-		m_Handlers[a_MessageType].erase(found);
+		m_Handlers.erase(found);
-}
-
-template <typename MessageBase>
-void MessageDispatcher<MessageBase>::UnregisterHandler(MessageHandler* a_Handler) {
-	for (auto& pair : m_Handlers) {
-		if (pair.second.empty())
-			continue;
-
-		MessageIdType type = pair.first;
-
-		pair.second.erase(std::remove(pair.second.begin(), pair.second.end(), a_Handler), pair.second.end());
-	}
 }
 
 template <typename MessageBase>
 void MessageDispatcher<MessageBase>::Dispatch(const MessageBase& a_Message) {
-	MessageIdType type = a_Message.GetId();
+	for (auto& handler : m_Handlers) {
-	for (auto& handler : m_Handlers[type]) {
+		a_Message.Dispatch(*handler.lock());
-		a_Message.Dispatch(*handler);
 	}
 }
 

src/sp/common/DataBuffer.cpp

@@ -29,7 +29,9 @@ DataBuffer& operator<<(DataBuffer& a_Buffer, const std::string& str) {
 }
 
 DataBuffer& operator<<(DataBuffer& a_Buffer, const DataBuffer& data) {
-	a_Buffer.insert(a_Buffer.end(), data.begin(), data.end());
+	std::size_t end = a_Buffer.GetSize();
+	a_Buffer.Resize(a_Buffer.GetSize() + data.GetSize());
+	std::copy(data.begin(), data.end(), a_Buffer.begin() + end);
 	return a_Buffer;
 }
 
@@ -147,8 +149,4 @@ void DataBuffer::WriteFile(const std::string& fileName) const {
 	file.flush();
 }
 
-void DataBuffer::insert(iterator a_DestBegin, const_iterator a_SrcBegin, const_iterator a_SrcEnd) {
-	m_Buffer.insert(a_DestBegin, a_SrcBegin, a_SrcEnd);
-}
-
 }  // namespace sp

test/test_message.cpp

@@ -61,10 +61,9 @@ int main() {
 
 	// dispatch tests
 
-	MyHandler h;
+	auto h = std::make_shared<MyHandler>();
 	PacketDispatcher d;
-	d.RegisterHandler(PacketID::KeepAlive, &h);
+	d.RegisterHandler(h);
-	d.RegisterHandler(PacketID::MDC, &h);
 	d.Dispatch(m);
 	PacketFactory f;
 	auto message = f.CreateMessage(PacketID::KeepAlive);