Add generic handlers

Former-commit-id: 8fc343d3a056de8031cf453748b8801d50d3710e

include/Nazara/Core/ObjectHandle.inl

@@ -0,0 +1,280 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/ObjectHandle.hpp>
+#include <Nazara/Core/StringStream.hpp>
+#include <functional>
+#include <limits>
+
+namespace Nz
+{
+	template<typename T>
+	ObjectHandle<T>::ObjectHandle() :
+	m_object(nullptr)
+	{
+	}
+
+	template<typename T>
+	ObjectHandle<T>::ObjectHandle(T* object) :
+	ObjectHandle()
+	{
+		Reset(object);
+	}
+
+	template<typename T>
+	ObjectHandle<T>::ObjectHandle(const ObjectHandle<T>& handle) :
+		ObjectHandle()
+	{
+		Reset(handle);
+	}
+
+	template<typename T>
+	ObjectHandle<T>::~ObjectHandle()
+	{
+		Reset(nullptr);
+	}
+
+	template<typename T>
+	T* ObjectHandle<T>::GetObject() const
+	{
+		return m_object;
+	}
+
+	template<typename T>
+	bool ObjectHandle<T>::IsValid() const
+	{
+		return m_object != nullptr;
+	}
+
+	template<typename T>
+	void ObjectHandle<T>::Reset(T* object)
+	{
+		// Si nous avions déjà une entité, nous devons l'informer que nous ne pointons plus sur elle
+		if (m_object)
+			m_object->UnregisterHandle(this);
+
+		m_object = object;
+		if (m_object)
+			// On informe la nouvelle entité que nous pointons sur elle
+			m_object->RegisterHandle(this);
+	}
+
+	template<typename T>
+	void ObjectHandle<T>::Reset(const ObjectHandle<T>& handle)
+	{
+		Reset(handle.GetObject());
+	}
+
+	template<typename T>
+	ObjectHandle<T>& ObjectHandle<T>::Swap(ObjectHandle<T>& handle)
+	{
+		// Comme nous inversons les handles, nous devons prévenir les entités
+		// La version par défaut de swap (à base de move) aurait fonctionné,
+		// mais en enregistrant les handles une fois de plus que nécessaire (à cause de la copie temporaire).
+		if (m_object)
+		{
+			m_object->UnregisterHandle(this);
+			m_object->RegisterHandle(&handle);
+		}
+
+		if (handle.m_object)
+		{
+			handle.m_object->UnregisterHandle(&handle);
+			handle.m_object->RegisterHandle(this);
+		}
+
+		// On effectue l'échange
+		std::swap(m_object, handle.m_object);
+		return *this;
+	}
+
+	template<typename T>
+	Nz::String ObjectHandle<T>::ToString() const
+	{
+		Nz::StringStream ss;
+		ss << "ObjectHandle(";
+		if (IsValid())
+			ss << m_object->ToString();
+		else
+			ss << "Null";
+
+		ss << ')';
+
+		return ss;
+	}
+
+	template<typename T>
+	ObjectHandle<T>::operator bool() const
+	{
+		return IsValid();
+	}
+
+	template<typename T>
+	ObjectHandle<T>::operator T*() const
+	{
+		return m_object;
+	}
+
+	template<typename T>
+	T* ObjectHandle<T>::operator->() const
+	{
+		return m_object;
+	}
+
+	template<typename T>
+	ObjectHandle<T>& ObjectHandle<T>::operator=(T* entity)
+	{
+		Reset(entity);
+
+		return *this;
+	}
+
+	template<typename T>
+	ObjectHandle<T>& ObjectHandle<T>::operator=(const ObjectHandle<T>& handle)
+	{
+		Reset(handle);
+
+		return *this;
+	}
+
+	template<typename T>
+	void ObjectHandle<T>::OnObjectDestroyed()
+	{
+		// Shortcut
+		m_object = nullptr;
+	}
+
+	template<typename T>
+	void ObjectHandle<T>::OnObjectMoved(T* newObject)
+	{
+		// The object has been moved, update our pointer
+		m_object = newObject;
+	}
+
+	template<typename T>
+	std::ostream& operator<<(std::ostream& out, const ObjectHandle<T>& handle)
+	{
+		return handle.ToString();
+	}
+
+	template<typename T>
+	bool operator==(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return lhs.GetObject() == rhs.GetObject();
+	}
+
+	template<typename T>
+	bool operator==(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return &lhs == rhs.GetObject();
+	}
+
+	template<typename T>
+	bool operator==(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return lhs.GetObject() == &rhs;
+	}
+
+	template<typename T>
+	bool operator!=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	template<typename T>
+	bool operator!=(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	template<typename T>
+	bool operator!=(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	template<typename T>
+	bool operator<(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return lhs.m_object < rhs.m_object;
+	}
+
+	template<typename T>
+	bool operator<(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return &lhs < rhs.m_object;
+	}
+
+	template<typename T>
+	bool operator<(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return lhs.m_object < &rhs;
+	}
+
+	template<typename T>
+	bool operator<=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs > rhs);
+	}
+
+	template<typename T>
+	bool operator<=(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs > rhs);
+	}
+
+	template<typename T>
+	bool operator<=(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return !(lhs > rhs);
+	}
+
+	template<typename T>
+	bool operator>(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return rhs < lhs;
+	}
+
+	template<typename T>
+	bool operator>(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return rhs < lhs;
+	}
+
+	template<typename T>
+	bool operator>(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return rhs < lhs;
+	}
+
+	template<typename T>
+	bool operator>=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs < rhs);
+	}
+
+	template<typename T>
+	bool operator>=(const T& lhs, const ObjectHandle<T>& rhs)
+	{
+		return !(lhs < rhs);
+	}
+
+	template<typename T>
+	bool operator>=(const ObjectHandle<T>& lhs, const T& rhs)
+	{
+		return !(lhs < rhs);
+	}
+
+	template<typename T>
+	const ObjectHandle<T> ObjectHandle<T>::InvalidHandle;
+}
+
+namespace std
+{
+	template<typename T>
+	void swap(Nz::ObjectHandle<T>& lhs, Nz::ObjectHandle<T>& rhs)
+	{
+		lhs.Swap(rhs);
+	}
+}