From f15e8d450d65747f2ac0b3ba81250b7a464f4160 Mon Sep 17 00:00:00 2001
From: Edouard DUPIN <yui.heero@gmail.com>
Date: Mon, 5 Jun 2017 00:21:39 +0200
Subject: [PATCH] [DEV] correct the Future::get that does not work anymore

---
 lutinMacro_zeus.py                            |  10 +-
 .../cli-video/appl/main-tool-client-video.cpp |   4 +-
 zeus/Future.cpp                               | 260 +++++++++---------
 zeus/Future.hpp                               |   6 +-
 4 files changed, 142 insertions(+), 138 deletions(-)

diff --git a/lutinMacro_zeus.py b/lutinMacro_zeus.py
index d8e3b3f..a6e3cbe 100644
--- a/lutinMacro_zeus.py
+++ b/lutinMacro_zeus.py
@@ -573,17 +573,17 @@ class ServiceDefinition:
 		out += "		}\n"
 		out += "	}\n"
 		out += "	\n"
-		out += "	template<> " + self.prop["name_class_proxy"] + " zeus::Future<" + self.prop["name_class_proxy"] + ">::get() {\n"
+		out += "	template<> " + self.prop["name_class_proxy"] + " futureGetValue<" + self.prop["name_class_proxy"] + ">(ememory::SharedPtr<zeus::Promise>& _promise) {\n"
 		out += "		ememory::SharedPtr<zeus::ObjectRemoteBase> out;\n"
-		out += "		if (    m_promise == nullptr\n"
-		out += "		     || m_promise->getRaw() == nullptr) {\n"
+		out += "		if (    _promise == nullptr\n"
+		out += "		     || _promise->getRaw() == nullptr) {\n"
 		out += "			return zeus::ObjectRemote(out);\n"
 		out += "		}\n"
-		out += "		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {\n"
+		out += "		if (_promise->getRaw()->getType() != zeus::message::type::answer) {\n"
 		out += "			ZEUS_WARNING(\"No Return value ...\");\n"
 		out += "			return zeus::ObjectRemote(out);\n"
 		out += "		}\n"
-		out += "		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>();\n"
+		out += "		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>();\n"
 		out += "		\n"
 		out += "		return zeus::ObjectRemote(out);\n"
 		out += "	}\n"
diff --git a/tools/cli-video/appl/main-tool-client-video.cpp b/tools/cli-video/appl/main-tool-client-video.cpp
index 6ec583a..04b316a 100644
--- a/tools/cli-video/appl/main-tool-client-video.cpp
+++ b/tools/cli-video/appl/main-tool-client-video.cpp
@@ -46,7 +46,7 @@ static std::string extractAndRemove(const std::string& _inputValue, const char _
 	return out;
 }
 bool progressCall(const std::string& _value) {
-	
+	return false;
 }
 
 void progressCallback(const std::string& _value) {
@@ -109,7 +109,7 @@ bool pushVideoFile(zeus::service::ProxyVideo& _srv, std::string _path, std::map<
 	}
 	// TODO: Do it better ==> add the calback to know the push progression ...
 	auto sending = _srv.add(zeus::File::create(_path, storedSha512));
-	sending.onProgress(progressCallback);
+	sending.onSignal(progressCallback);
 	uint32_t mediaId = sending.waitFor(echrono::seconds(20000)).get();
 	if (mediaId == 0) {
 		APPL_ERROR("Get media ID = 0 With no error");
diff --git a/zeus/Future.cpp b/zeus/Future.cpp
index dd6f03d..fdecbc8 100644
--- a/zeus/Future.cpp
+++ b/zeus/Future.cpp
@@ -12,341 +12,341 @@
 
 namespace zeus {
 	template<>
-	bool zeus::Future<bool>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	bool futureGetValue<bool>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return false;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return false;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<bool>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<bool>();
 	}
 	template<>
-	int64_t zeus::Future<int64_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	int64_t futureGetValue<int64_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<int64_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<int64_t>();
 	}
 	template<>
-	int32_t zeus::Future<int32_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	int32_t futureGetValue<int32_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<int32_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<int32_t>();
 	}
 	template<>
-	int16_t zeus::Future<int16_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	int16_t futureGetValue<int16_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<int16_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<int16_t>();
 	}
 	template<>
-	int8_t zeus::Future<int8_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	int8_t futureGetValue<int8_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<int8_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<int8_t>();
 	}
 	template<>
-	uint64_t zeus::Future<uint64_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	uint64_t futureGetValue<uint64_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<uint64_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<uint64_t>();
 	}
 	template<>
-	uint32_t zeus::Future<uint32_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	uint32_t futureGetValue<uint32_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<uint32_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<uint32_t>();
 	}
 	template<>
-	uint16_t zeus::Future<uint16_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	uint16_t futureGetValue<uint16_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<uint16_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<uint16_t>();
 	}
 	template<>
-	uint8_t zeus::Future<uint8_t>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	uint8_t futureGetValue<uint8_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<uint8_t>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<uint8_t>();
 	}
 	template<>
-	double zeus::Future<double>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	double futureGetValue<double>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0.0;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<double>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<double>();
 	}
 	template<>
-	float zeus::Future<float>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	float futureGetValue<float>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return 0.0f;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return 0.0f;
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<float>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<float>();
 	}
 	template<>
-	std::string zeus::Future<std::string>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	std::string futureGetValue<std::string>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return "";
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return "";
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::string>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::string>();
 	}
 	template<>
-	std::vector<int64_t> zeus::Future<std::vector<int64_t>>::get() {
+	std::vector<int64_t> futureGetValue<std::vector<int64_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<int64_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<int64_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<int64_t>>();
 		return out;
 	}
 	template<>
-	std::vector<int32_t> zeus::Future<std::vector<int32_t>>::get() {
+	std::vector<int32_t> futureGetValue<std::vector<int32_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<int32_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<int32_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<int32_t>>();
 		return out;
 	}
 	template<>
-	std::vector<int16_t> zeus::Future<std::vector<int16_t>>::get() {
+	std::vector<int16_t> futureGetValue<std::vector<int16_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<int16_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<int16_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<int16_t>>();
 		return out;
 	}
 	template<>
-	std::vector<int8_t> zeus::Future<std::vector<int8_t>>::get() {
+	std::vector<int8_t> futureGetValue<std::vector<int8_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<int8_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<int8_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<int8_t>>();
 		return out;
 	}
 	template<>
-	std::vector<uint64_t> zeus::Future<std::vector<uint64_t>>::get() {
+	std::vector<uint64_t> futureGetValue<std::vector<uint64_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<uint64_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<uint64_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<uint64_t>>();
 		return out;
 	}
 	template<>
-	std::vector<uint32_t> zeus::Future<std::vector<uint32_t>>::get() {
+	std::vector<uint32_t> futureGetValue<std::vector<uint32_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<uint32_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<uint32_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<uint32_t>>();
 		return out;
 	}
 	template<>
-	std::vector<uint16_t> zeus::Future<std::vector<uint16_t>>::get() {
+	std::vector<uint16_t> futureGetValue<std::vector<uint16_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<uint16_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<uint16_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<uint16_t>>();
 		return out;
 	}
 	template<>
-	std::vector<uint8_t> zeus::Future<std::vector<uint8_t>>::get() {
+	std::vector<uint8_t> futureGetValue<std::vector<uint8_t>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<uint8_t> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<uint8_t>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<uint8_t>>();
 		return out;
 	}
 	template<>
-	std::vector<double> zeus::Future<std::vector<double>>::get() {
+	std::vector<double> futureGetValue<std::vector<double>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<double> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<double>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<double>>();
 		return out;
 	}
 	template<>
-	std::vector<float> zeus::Future<std::vector<float>>::get() {
+	std::vector<float> futureGetValue<std::vector<float>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<float> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<float>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<float>>();
 		return out;
 	}
 	template<>
-	std::vector<std::string> zeus::Future<std::vector<std::string>>::get() {
+	std::vector<std::string> futureGetValue<std::vector<std::string>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<std::string> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<std::string>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<std::string>>();
 		return out;
 	}
 	template<>
-	std::vector<bool> zeus::Future<std::vector<bool>>::get() {
+	std::vector<bool> futureGetValue<std::vector<bool>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		std::vector<bool> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<std::vector<bool>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<std::vector<bool>>();
 		return out;
 	}
 	template<>
-	zeus::Raw zeus::Future<zeus::Raw>::get() {
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+	zeus::Raw futureGetValue<zeus::Raw>(ememory::SharedPtr<zeus::Promise>& _promise) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return zeus::Raw();
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return zeus::Raw();
 		}
-		return static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<zeus::Raw>();
+		return static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<zeus::Raw>();
 	}
 	template<>
-	ememory::SharedPtr<zeus::ObjectRemoteBase> zeus::Future<ememory::SharedPtr<zeus::ObjectRemoteBase>>::get() {
+	ememory::SharedPtr<zeus::ObjectRemoteBase> futureGetValue<ememory::SharedPtr<zeus::ObjectRemoteBase>>(ememory::SharedPtr<zeus::Promise>& _promise) {
 		ememory::SharedPtr<zeus::ObjectRemoteBase> out;
-		if (    m_promise == nullptr
-		     || m_promise->getRaw() == nullptr) {
+		if (    _promise == nullptr
+		     || _promise->getRaw() == nullptr) {
 			return out;
 		}
-		if (m_promise->getRaw()->getType() != zeus::message::type::answer) {
+		if (_promise->getRaw()->getType() != zeus::message::type::answer) {
 			ZEUS_WARNING("No Return value ...");
 			return out;
 		}
-		out = static_cast<zeus::message::Answer*>(m_promise->getRaw().get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>();
+		out = static_cast<zeus::message::Answer*>(_promise->getRaw().get())->getAnswer<ememory::SharedPtr<zeus::ObjectRemoteBase>>();
 		return out;
 	}
 }
diff --git a/zeus/Future.hpp b/zeus/Future.hpp
index ab38f64..152862d 100644
--- a/zeus/Future.hpp
+++ b/zeus/Future.hpp
@@ -11,6 +11,8 @@
 
 namespace zeus {
 	class void_tmp {};
+	template <class ZEUS_RETURN>
+	ZEUS_RETURN futureGetValue(ememory::SharedPtr<zeus::Promise>& _promise);
 	/**
 	 * @brief future template to cast type in a specific type
 	 */
@@ -38,7 +40,9 @@ namespace zeus {
 			 * @brief Get the value Requested with the type
 			 * @return requested value
 			 */
-			ZEUS_RETURN get();
+			ZEUS_RETURN get() {
+				return zeus::futureGetValue<ZEUS_RETURN>(m_promise);
+			}
 			const Future<ZEUS_RETURN, ZEUS_EVENT>& wait() const {
 				zeus::FutureBase::wait();
 				return *this;