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 += " 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"

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;
}
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");

260
zeus/Future.cpp
View File

@ -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;
}
}

6
zeus/Future.hpp
View File

@ -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;