atria-soft/zeus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] correct the Future::get that does not work anymore

Browse Source
This commit is contained in:
Edouard DUPIN 2017-06-05 00:21:39 +02:00
parent 826ac3c053
commit f15e8d450d
4 changed files with 142 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lutinMacro_zeus.py
View File

@ -573,17 +573,17 @@ class ServiceDefinition:
out += " }\n" out += " }\n"
out += " }\n" 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 += " ememory::SharedPtr<zeus::ObjectRemoteBase> out;\n"
out += " if ( m_promise == nullptr\n" out += " if ( _promise == nullptr\n"
out += " || m_promise->getRaw() == nullptr) {\n" out += " || _promise->getRaw() == nullptr) {\n"
out += " return zeus::ObjectRemote(out);\n" out += " return zeus::ObjectRemote(out);\n"
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 += " ZEUS_WARNING(\"No Return value ...\");\n"
out += " return zeus::ObjectRemote(out);\n" out += " return zeus::ObjectRemote(out);\n"
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 += " \n"
out += " return zeus::ObjectRemote(out);\n" out += " return zeus::ObjectRemote(out);\n"
out += " }\n" out += " }\n"

4
tools/cli-video/appl/main-tool-client-video.cpp
View File

@ -46,7 +46,7 @@ static std::string extractAndRemove(const std::string& _inputValue, const char _
return out; return out;
} }
bool progressCall(const std::string& _value) { bool progressCall(const std::string& _value) {
return false;
} }
void progressCallback(const std::string& _value) { 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 ... // TODO: Do it better ==> add the calback to know the push progression ...
auto sending = _srv.add(zeus::File::create(_path, storedSha512)); auto sending = _srv.add(zeus::File::create(_path, storedSha512));
sending.onProgress(progressCallback); sending.onSignal(progressCallback);
uint32_t mediaId = sending.waitFor(echrono::seconds(20000)).get(); uint32_t mediaId = sending.waitFor(echrono::seconds(20000)).get();
if (mediaId == 0) { if (mediaId == 0) {
APPL_ERROR("Get media ID = 0 With no error"); APPL_ERROR("Get media ID = 0 With no error");

260
zeus/Future.cpp
View File

@ -12,341 +12,341 @@
namespace zeus { namespace zeus {
template<> template<>
bool zeus::Future<bool>::get() { bool futureGetValue<bool>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return false; return false;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return false; 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<> template<>
int64_t zeus::Future<int64_t>::get() { int64_t futureGetValue<int64_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
int32_t zeus::Future<int32_t>::get() { int32_t futureGetValue<int32_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
int16_t zeus::Future<int16_t>::get() { int16_t futureGetValue<int16_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
int8_t zeus::Future<int8_t>::get() { int8_t futureGetValue<int8_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
uint64_t zeus::Future<uint64_t>::get() { uint64_t futureGetValue<uint64_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
uint32_t zeus::Future<uint32_t>::get() { uint32_t futureGetValue<uint32_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
uint16_t zeus::Future<uint16_t>::get() { uint16_t futureGetValue<uint16_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
uint8_t zeus::Future<uint8_t>::get() { uint8_t futureGetValue<uint8_t>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0; 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<> template<>
double zeus::Future<double>::get() { double futureGetValue<double>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0; return 0;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return 0.0; 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<> template<>
float zeus::Future<float>::get() { float futureGetValue<float>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return 0.0f; 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 ..."); ZEUS_WARNING("No Return value ...");
return 0.0f; 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<> template<>
std::string zeus::Future<std::string>::get() { std::string futureGetValue<std::string>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return ""; return "";
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return ""; 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<> 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; std::vector<int64_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<int32_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<int16_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<int8_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<uint64_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<uint32_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<uint16_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<uint8_t> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<double> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<float> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<std::string> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> 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; std::vector<bool> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
template<> template<>
zeus::Raw zeus::Future<zeus::Raw>::get() { zeus::Raw futureGetValue<zeus::Raw>(ememory::SharedPtr<zeus::Promise>& _promise) {
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return zeus::Raw(); 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 ..."); ZEUS_WARNING("No Return value ...");
return zeus::Raw(); 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<> 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; ememory::SharedPtr<zeus::ObjectRemoteBase> out;
if ( m_promise == nullptr if ( _promise == nullptr
|| m_promise->getRaw() == nullptr) { || _promise->getRaw() == nullptr) {
return out; return out;
} }
if (m_promise->getRaw()->getType() != zeus::message::type::answer) { if (_promise->getRaw()->getType() != zeus::message::type::answer) {
ZEUS_WARNING("No Return value ..."); ZEUS_WARNING("No Return value ...");
return out; 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; return out;
} }
} }

6
zeus/Future.hpp
View File

@ -11,6 +11,8 @@
namespace zeus { namespace zeus {
class void_tmp {}; 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 * @brief future template to cast type in a specific type
*/ */
@ -38,7 +40,9 @@ namespace zeus {
* @brief Get the value Requested with the type * @brief Get the value Requested with the type
* @return requested value * @return requested value
*/ */
ZEUS_RETURN get(); ZEUS_RETURN get() {
return zeus::futureGetValue<ZEUS_RETURN>(m_promise);
}
const Future<ZEUS_RETURN, ZEUS_EVENT>& wait() const { const Future<ZEUS_RETURN, ZEUS_EVENT>& wait() const {
zeus::FutureBase::wait(); zeus::FutureBase::wait();
return *this; return *this;