[DEV] separate template implementation

esignal/details/ISignal.cpp

@@ -0,0 +1,51 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+#include <esignal/details/ISignal.hxx>
+#include <etk/types.h>
+#include <etk/math/Vector2D.h>
+#include <etk/math/Vector3D.h>
+#include <etk/Color.h>
+
+#undef __class__
+#define __class__ "ISignal<void>"
+// void generic signal
+template class esignal::ISignal<>;
+// std generic signal
+template class esignal::ISignal<bool>;
+template class esignal::ISignal<std::string>;
+#if __CPP_VERSION__ >= 2011
+	template class esignal::ISignal<std::u32string>;
+#endif
+
+template class esignal::ISignal<int64_t>;
+template class esignal::ISignal<int32_t>;
+template class esignal::ISignal<int16_t>;
+template class esignal::ISignal<int8_t>;
+
+template class esignal::ISignal<uint64_t>;
+template class esignal::ISignal<uint32_t>;
+template class esignal::ISignal<uint16_t>;
+template class esignal::ISignal<uint8_t>;
+
+template class esignal::ISignal<float>;
+template class esignal::ISignal<double>;
+// etk generic vetor 2D
+template class esignal::ISignal<vec2>;
+template class esignal::ISignal<bvec2>;
+template class esignal::ISignal<ivec2>;
+template class esignal::ISignal<uivec2>;
+// etk generic vetor 3D
+template class esignal::ISignal<vec3>;
+template class esignal::ISignal<bvec3>;
+template class esignal::ISignal<ivec3>;
+template class esignal::ISignal<uivec3>;
+// etk generic color
+template class esignal::ISignal<etk::Color<unsigned char,4>>;
+template class esignal::ISignal<etk::Color<unsigned char,3>>;
+template class esignal::ISignal<etk::Color<float,4>>;
+template class esignal::ISignal<etk::Color<float,3>>;

esignal/details/ISignal.hxx

@@ -0,0 +1,39 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <esignal/ISignal.h>
+#include <esignal/details/Signal.hxx>
+
+template<class... Args>
+esignal::ISignal<Args...>::ISignal(esignal::Interface& _signalInterfaceLink,
+        const std::string& _name,
+        const std::string& _description):
+  m_signalInterfaceLink(_signalInterfaceLink),
+  m_name(_name),
+  m_description(_description) {
+	// add a reference on the current signal ...
+	m_signalInterfaceLink.signalAdd(this);
+}
+
+template<class... Args>
+esignal::ISignal<Args...>::~ISignal() {
+	m_signalInterfaceLink.signalRemove(this);
+}
+
+template<class... Args>
+const std::string& esignal::ISignal<Args...>::getName() const {
+	return m_name;
+}
+
+template<class... Args>
+const std::string& esignal::ISignal<Args...>::getDescription() const {
+	return m_description;
+}
+
+

esignal/details/LockSharedPtrRef.cpp

@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include <esignal/debug.h>
+#include <esignal/details/LockSharedPtrRef.hxx>
+#include <esignal/Base.h>
+
+// only one really needed ...
+template class esignal::LockSharedPtrRef<esignal::Base>;
+
+

esignal/details/LockSharedPtrRef.hxx

@@ -0,0 +1,91 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include <esignal/LockSharedPtrRef.h>
+
+template<class TYPE>
+esignal::LockSharedPtrRef<TYPE>::LockSharedPtrRef(TYPE* _pointer) :
+  m_counter(nullptr) {
+	if (_pointer != nullptr) {
+		m_counter = new RefCount<TYPE>(_pointer);
+		m_counter->inc();
+	}
+}
+
+template<class TYPE>
+esignal::LockSharedPtrRef<TYPE>::LockSharedPtrRef(const LockSharedPtrRef<TYPE>& _obj) :
+  m_counter(_obj.m_counter) {
+	if (m_counter == nullptr) {
+		return;
+	}
+	m_counter->inc();
+}
+
+template<class TYPE>
+esignal::LockSharedPtrRef<TYPE>& esignal::LockSharedPtrRef<TYPE>::operator=(const esignal::LockSharedPtrRef<TYPE>& _obj) {
+	if (&_obj == this) {
+		return *this;
+	}
+	if (m_counter != nullptr) {
+		m_counter->dec();
+		m_counter = nullptr;
+	}
+	m_counter = _obj.m_counter;
+	if (m_counter == nullptr) {
+		return *this;
+	}
+	m_counter->inc();
+	return *this;
+}
+
+template<class TYPE>
+esignal::LockSharedPtrRef<TYPE>::LockSharedPtrRef(LockSharedPtrRef<TYPE>&& _obj) :
+  m_counter(std::move(_obj.m_counter)) {
+	
+}
+
+template<class TYPE>
+esignal::LockSharedPtrRef<TYPE>::~LockSharedPtrRef() {
+	if (m_counter == nullptr) {
+		return;
+	}
+	int64_t count = m_counter->dec();
+	if (count > 0) {
+		return;
+	}
+	delete m_counter;
+	m_counter = nullptr;
+}
+
+template<class TYPE>
+void esignal::LockSharedPtrRef<TYPE>::removeData() {
+	if (m_counter != nullptr) {
+		m_counter->remove();
+	}
+}
+
+template<class TYPE>
+void esignal::LockSharedPtrRef<TYPE>::disconnect(std::size_t _uid) {
+	if (m_counter == nullptr) {
+		return;
+	}
+	m_counter->lock();
+	TYPE* val = m_counter->get();
+	if (val != nullptr) {
+		val->disconnect(_uid);
+	}
+	m_counter->unlock();
+}
+
+template<class TYPE>
+bool esignal::LockSharedPtrRef<TYPE>::isAlive() {
+	return m_counter != nullptr;
+}
+
+
+

esignal/details/RefCount.cpp

@@ -0,0 +1,16 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+
+#include <esignal/debug.h>
+#include <esignal/details/RefCount.hxx>
+#include <esignal/Base.h>
+
+// only one really needed ...
+template class esignal::RefCount<esignal::Base>;
+
+

esignal/details/RefCount.hxx

@@ -0,0 +1,66 @@
+/**
+ * @author Edouard DUPIN
+ * 
+ * @copyright 2016, Edouard DUPIN, all right reserved
+ * 
+ * @license APACHE v2.0 (see license file)
+ */
+#pragma once
+
+#include <esignal/RefCount.h>
+
+template<class TYPE>
+esignal::RefCount<TYPE>::RefCount(TYPE* _data) :
+  m_count(0),
+  m_data(_data) {
+	// nothing to do.
+}
+
+template<class TYPE>
+esignal::RefCount<TYPE>::~RefCount() {
+	m_data = nullptr;
+}
+
+template<class TYPE>
+void esignal::RefCount<TYPE>::lock() {
+	m_lock.lock();
+}
+
+template<class TYPE>
+void esignal::RefCount<TYPE>::unlock() {
+	m_lock.unlock();
+}
+
+template<class TYPE>
+void esignal::RefCount<TYPE>::inc() {
+	lock();
+	m_count++;
+	unlock();
+}
+
+template<class TYPE>
+int64_t esignal::RefCount<TYPE>::dec() {
+	int64_t val;
+	lock();
+	m_count--;
+	val = m_count;
+	unlock();
+	return val;
+}
+
+template<class TYPE>
+int64_t esignal::RefCount<TYPE>::getCount() const {
+	return m_count;
+}
+
+template<class TYPE>
+void esignal::RefCount<TYPE>::remove() {
+	lock();
+	m_data = nullptr;
+	unlock();
+}
+
+template<class TYPE>
+TYPE* esignal::RefCount<TYPE>::get() {
+	return m_data;
+}

esignal/details/Signal.cpp

@@ -11,8 +11,6 @@
 #include <etk/math/Vector3D.h>
 #include <etk/Color.h>
 
-size_t esignal::s_uid = 0;
-
 #undef __class__
 #define __class__ "Signal<void>"
 // void generic signal

esignal/details/Signal.hxx

@@ -8,13 +8,10 @@
 #pragma once
 
 #include <esignal/Signal.h>
-#include <functional>
-#include <memory>
 
 #undef __class__
 #define __class__ "Signal<T_ARGS>"
 
-
 template<typename... T_ARGS>
 esignal::Signal<T_ARGS...>::Signal():
   m_callInProgress(0) {