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

[DEV] continue thinking about signal and progression

Browse Source
This commit is contained in:
Edouard DUPIN 2017-06-02 00:26:00 +02:00
parent 7840f2231e
commit cc7493c079
16 changed files with 172 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
lutinMacro_zeus.py
View File

@ -36,7 +36,7 @@ list_of_known_type = [
["stream", "zeus::Stream"],
["json", "ejson::Object"],
["raw", "zeus::Raw"],
["ActionNotif", "zeus::ActionNotification"],
["ActionNotif", "zeus::ActionNotification<std::string>"],
]
@ -184,12 +184,14 @@ class FunctionDefinition:
def __init__(self):
self.name = ""
self.brief = ""
self.action_type = "void_tmp"
self.return_type = ""
self.return_brief = ""
self.parameters = []
self.is_action = False
def set_action(self):
def set_action(self, type):
self.action_type = remove_start_stop_spacer(type)
self.is_action = True
def set_function_name(self, name):
@ -238,7 +240,10 @@ class FunctionDefinition:
debug.info(" " + self.return_type + " " + self.name + "(")
for elem in self.parameters:
debug.info(" " + elem["type"] + " " + elem["name"] + ", # " + elem["brief"])
debug.info(" )")
if action_type == "void":
debug.info(" )")
else:
debug.info(" ) action/event type = '" + action_type + "'")
def generate_doxy(self, space):
# generate doxygen comment:
@ -275,7 +280,7 @@ class FunctionDefinition:
param_data = ""
id_parameter = 0
if self.is_action == True:
param_data += "zeus::ActionNotification& _notifs"
param_data += "zeus::ActionNotification<" + convert_type_in_cpp(self.action_type, False, True) + ">& _notifs"
id_parameter += 1
for elem in self.parameters:
id_parameter += 1
@ -297,7 +302,10 @@ class FunctionDefinition:
def generate_hpp_proxy(self, space):
out = "";
out += self.generate_doxy(space)
out += space + "virtual zeus::Future<" + convert_type_in_cpp(self.return_type, True, False) + "> " + self.name + "("
out += space + "virtual zeus::Future<" + convert_type_in_cpp(self.return_type, True, False)
if self.action_type != "void_tmp":
out += "," + convert_type_in_cpp(self.action_type, True, False)
out += "> " + self.name + "("
param_data = ""
id_parameter = 0
for elem in self.parameters:
@ -310,11 +318,14 @@ class FunctionDefinition:
else:
param_data += elem["name"]
out += param_data
out += ") const;\n"
out += ");\n"
return out;
def generate_cpp_proxy(self, space, class_name):
out = "";
out += space + "zeus::Future<" + convert_type_in_cpp(self.return_type, True, False) + "> " + class_name + "::" + self.name + "("
out += space + "zeus::Future<" + convert_type_in_cpp(self.return_type, True, False)
if self.action_type != "void_tmp":
out += "," + convert_type_in_cpp(self.action_type, True, False)
out += "> " + class_name + "::" + self.name + "("
param_data = ""
id_parameter = 0
for elem in self.parameters:
@ -327,7 +338,7 @@ class FunctionDefinition:
else:
param_data += elem["name"]
out += param_data
out += ") const {\n"
out += ") {\n"
space += " "
if self.is_action == True:
out += space + 'return m_obj.callAction("' + self.name + '"'
@ -933,9 +944,17 @@ def tool_generate_idl(target, module, data_option):
if line[:10] == "[function]":
type_function = "function"
line = line[10:]
if line[:8] == "[action]":
if line[:8] == "[action ":
type_function = "action"
line = line[8:]
type_event = "";
for elem in line:
if elem == "]":
break
type_event += elem
line = line[len(type_event)+1:]
if validate_type(type_event) == False:
debug.error("line " + str(id_line) + " action type unknow : '" + type_event + "' not in " + str(get_list_type()))
# remove wihte space
while len(line)>0 \
@ -987,7 +1006,7 @@ def tool_generate_idl(target, module, data_option):
if type_function == "function":
service_def.add_function(current_def)
elif type_function == "action":
current_def.set_action()
current_def.set_action(type_event)
service_def.add_function(current_def)
elif type_function == "factory":
service_def.add_factory(current_def)

2
tools/service-video/appl/zeus-service-video.srv.zeus.idl
View File

@ -33,7 +33,7 @@ obj:zeus-Media get(uint32)
#param:data:A file reference on the media (transmission is async)
#return:Local personal ID of the media
//#notification:Send progression in json
[action] uint32 add(obj:zeus-File)
[action string] uint32 add(obj:zeus-File)
#brief:Remove a media in the service (no trash)
#param:mediaId:Id of the media

30
zeus/AbstractFunctionTypeClass.hpp
View File

@ -20,16 +20,16 @@ namespace zeus {
* @param[in] _pointer Pointer on the class to call
* @param[in] _func pointer on the function to call
*/
template <class ZEUS_CLASS_TYPE, class ZEUS_RETURN, class... ZEUS_TYPES>
template <class ZEUS_CLASS_TYPE, class ZEUS_RETURN, class ZEUS_EVENT, class... ZEUS_TYPES>
void executeClassCall(ememory::SharedPtr<zeus::WebServer> _interfaceClient,
ememory::SharedPtr<zeus::message::Parameter> _obj,
ZEUS_CLASS_TYPE* _pointer,
ZEUS_RETURN (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification& _notifs, ZEUS_TYPES...)) {
ZEUS_RETURN (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification<ZEUS_EVENT>& _notifs, ZEUS_TYPES...)) {
if (_obj == nullptr) {
return;
}
ZEUS_RETURN ret;
zeus::ActionNotification notifs(_interfaceClient, _obj->getTransactionId(), _obj->getDestination(), _obj->getSource());
zeus::ActionNotification<ZEUS_EVENT> notifs(_interfaceClient, _obj->getTransactionId(), _obj->getDestination(), _obj->getSource());
if (zeus::checkOrderFunctionParameter() == true) {
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
@ -89,15 +89,15 @@ namespace zeus {
* @param[in] _pointer Pointer on the class to call
* @param[in] _func pointer on the function to call
*/
template <class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
template <class ZEUS_CLASS_TYPE, class ZEUS_EVENT, class... ZEUS_TYPES>
void executeClassCall(ememory::SharedPtr<zeus::WebServer> _interfaceClient,
ememory::SharedPtr<zeus::message::Parameter> _obj,
ZEUS_CLASS_TYPE* _pointer,
void (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification& _notifs, ZEUS_TYPES...)) {
void (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification<ZEUS_EVENT>& _notifs, ZEUS_TYPES...)) {
if (_obj == nullptr) {
return;
}
zeus::ActionNotification notifs(_interfaceClient, _obj->getTransactionId(), _obj->getDestination(), _obj->getSource());
zeus::ActionNotification<ZEUS_EVENT> notifs(_interfaceClient, _obj->getTransactionId(), _obj->getDestination(), _obj->getSource());
if (zeus::checkOrderFunctionParameter() == true) {
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
@ -152,13 +152,13 @@ namespace zeus {
/**
* @brief Chass that permit to declare a function that call intanced element or a class element
*/
template <class ZEUS_RETURN, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
template <class ZEUS_RETURN, class ZEUS_EVENT, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
class AbstractActionTypeClass: public zeus::AbstractFunction {
protected:
static const zeus::message::ParamType m_returnType;
static const zeus::message::ParamType m_paramType[sizeof...(ZEUS_TYPES)];
public:
using functionType = ZEUS_RETURN (ZEUS_CLASS_TYPE::*)(zeus::ActionNotification& _notifs, ZEUS_TYPES...);
using functionType = ZEUS_RETURN (ZEUS_CLASS_TYPE::*)(zeus::ActionNotification<ZEUS_EVENT>& _notifs, ZEUS_TYPES...);
functionType m_function;
/**
* @brief Constructor
@ -418,11 +418,11 @@ namespace zeus {
}
};
// specialization
template <class ZEUS_RETURN, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
const zeus::message::ParamType AbstractActionTypeClass<ZEUS_RETURN, ZEUS_CLASS_TYPE, ZEUS_TYPES...>::m_returnType = zeus::message::createType<ZEUS_RETURN>();
template <class ZEUS_RETURN, class ZEUS_EVENT, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
const zeus::message::ParamType AbstractActionTypeClass<ZEUS_RETURN, ZEUS_EVENT, ZEUS_CLASS_TYPE, ZEUS_TYPES...>::m_returnType = zeus::message::createType<ZEUS_RETURN>();
// specialization
template <class ZEUS_RETURN, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
const zeus::message::ParamType AbstractActionTypeClass<ZEUS_RETURN, ZEUS_CLASS_TYPE, ZEUS_TYPES...>::m_paramType[sizeof...(ZEUS_TYPES)] = {zeus::message::createType<ZEUS_TYPES>()...};
template <class ZEUS_RETURN, class ZEUS_EVENT, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
const zeus::message::ParamType AbstractActionTypeClass<ZEUS_RETURN, ZEUS_EVENT, ZEUS_CLASS_TYPE, ZEUS_TYPES...>::m_paramType[sizeof...(ZEUS_TYPES)] = {zeus::message::createType<ZEUS_TYPES>()...};
// specialization
template <class ZEUS_RETURN, class ZEUS_CLASS_TYPE, class... ZEUS_TYPES>
const zeus::message::ParamType AbstractFunctionTypeClass<ZEUS_RETURN, ZEUS_CLASS_TYPE, ZEUS_TYPES...>::m_returnType = zeus::message::createType<ZEUS_RETURN>();
@ -435,9 +435,9 @@ namespace zeus {
* @param[in] _fffp Pointer of the function
* @return Abstract type of the function
*/
template <typename ZEUS_RETURN, class ZEUS_CLASS_TYPE, typename... ZEUS_TYPES>
AbstractFunction* createAbstractFunctionClass(const std::string& _name, ZEUS_RETURN (ZEUS_CLASS_TYPE::*_fffp)(zeus::ActionNotification& _notifs, ZEUS_TYPES...)) {
return new AbstractActionTypeClass<ZEUS_RETURN, ZEUS_CLASS_TYPE, ZEUS_TYPES...>(_name, _fffp);
template <typename ZEUS_RETURN, class ZEUS_EVENT, class ZEUS_CLASS_TYPE, typename... ZEUS_TYPES>
AbstractFunction* createAbstractFunctionClass(const std::string& _name, ZEUS_RETURN (ZEUS_CLASS_TYPE::*_fffp)(zeus::ActionNotification<ZEUS_EVENT>& _notifs, ZEUS_TYPES...)) {
return new AbstractActionTypeClass<ZEUS_RETURN, ZEUS_EVENT, ZEUS_CLASS_TYPE, ZEUS_TYPES...>(_name, _fffp);
}
/**
* @brief Create a function information with the function type

13
zeus/ActionNotification.hpp
View File

@ -10,6 +10,7 @@
namespace zeus {
template<class ZEUS_TYPE_EVENT>
class ActionNotification {
private:
ememory::SharedPtr<zeus::WebServer> m_interface;
@ -25,11 +26,15 @@ namespace zeus {
m_transactionId(_transactionId),
m_source(_source),
m_destination(_destination) {}
void notify(const std::string& _value) {
if (m_interface != nullptr) {
m_interface->progressNotify(m_transactionId, m_source, m_destination, _value);
// TODO: Deprecated ...
void notify(const ZEUS_TYPE_EVENT& _value) {
emit(_value);
}
void emit(const ZEUS_TYPE_EVENT& _value) {
if (m_interface == nullptr) {
return;
}
m_interface->eventValue(m_transactionId, m_source, m_destination, _value);
}
};
}

2
zeus/Client.cpp
View File

@ -121,6 +121,7 @@ void zeus::Client::onClientData(ememory::SharedPtr<zeus::Message> _value) {
}
answerProtocolError(transactionId, "interact with client, musty only call: link/unlink/movelink");
return;
/*
} else if (_value->getType() == zeus::message::type::event) {
ememory::SharedPtr<zeus::message::Event> eventObj = ememory::staticPointerCast<zeus::message::Event>(_value);
std::string callFunction = eventObj->getCall();
@ -131,6 +132,7 @@ void zeus::Client::onClientData(ememory::SharedPtr<zeus::Message> _value) {
}
answerProtocolError(transactionId, "interact with client, musty only call: removeInterface");
return;
*/
}
m_interfaceWeb->answerError(transactionId, _value->getDestination(), _value->getSource(), "UNKNOW-ACTION");
return;

35
zeus/Future.hpp
View File

@ -10,10 +10,11 @@
// TODO : When do a cast of the type on the future ==> do a wait ...
namespace zeus {
class void_tmp {};
/**
* @brief future template to cast type in a specific type
*/
template<class ZEUS_RETURN, class ZEUS_EVENT=void>
template<class ZEUS_RETURN, class ZEUS_EVENT=void_tmp>
class Future : public zeus::FutureBase {
public:
/**
@ -123,35 +124,29 @@ namespace zeus {
* @param[in] _callback Handle on the function to call in progress information
*/
// TODO: this is deprecated ...
Future<ZEUS_RETURN>& onProgress(Promise::ObserverProgress _callback) {
zeus::FutureBase::onProgress(_callback);
Future<ZEUS_RETURN>& onProgress(Promise::ObserverEvent _callback) {
zeus::FutureBase::onEvent(_callback);
return *this;
}
//template<typename = std::enable_if<std::is_void<ZEUS_EVENT>::value, false>>
Future<ZEUS_RETURN>& onSignal(std::function<void(const ZEUS_EVENT&)> _callback) {
zeus::FutureBase::onSignal(
[=](ememory::SharedPtr<zeus::Message> _msg) {
zeus::FutureBase::onEvent(
[=](ememory::SharedPtr<zeus::message::Event> _msg) {
if (_msg == nullptr) {
return;
}
if (_msg->getType() != zeus::message::type::progress) {
ZEUS_WARNING("No Return value ...");
return;
}
return _callback(static_cast<zeus::message::Progress*>(_msg.get())->getAnswer<ZEUS_EVENT>());
_callback(_msg->getEvent<ZEUS_EVENT>());
});
return *this;
}
//template<typename = std::enable_if<std::is_void<ZEUS_EVENT>::value, false>>
Future<ZEUS_RETURN>& onSignal(std::function<void(ZEUS_EVENT)> _callback) {
zeus::FutureBase::onSignal(
[=](ememory::SharedPtr<zeus::Message> _msg) {
zeus::FutureBase::onEvent(
[=](ememory::SharedPtr<zeus::message::Event> _msg) {
if (_msg == nullptr) {
return;
}
if (_msg->getType() != zeus::message::type::progress) {
ZEUS_WARNING("No Return value ...");
return;
}
return _callback(std::move(static_cast<zeus::message::Progress*>(_msg.get())->getAnswer<ZEUS_EVENT>()));
_callback(std::move(_msg->getEvent<ZEUS_EVENT>()));
});
return *this;
}
@ -160,7 +155,7 @@ namespace zeus {
* @brief future template to cast type in a void methode (fallback)
*/
template<>
class Future<void,void> : public zeus::FutureBase {
class Future<void> : public zeus::FutureBase {
public:
/**
* @brief contructor of the Future with the basic FutureBase
@ -241,8 +236,8 @@ namespace zeus {
* @brief Attach callback on activity of the action if user set some return information
* @param[in] _callback Handle on the function to call in progress information
*/
Future<void>& onProgress(Promise::ObserverProgress _callback) {
zeus::FutureBase::onProgress(_callback);
Future<void>& onEvent(Promise::ObserverEvent _callback) {
zeus::FutureBase::onEvent(_callback);
return *this;
}
};

4
zeus/FutureBase.cpp
View File

@ -71,11 +71,11 @@ void zeus::FutureBase::andElse(zeus::Promise::Observer _callback) {
m_promise->andElse(_callback);
}
void zeus::FutureBase::onProgress(zeus::Promise::ObserverProgress _callback) {
void zeus::FutureBase::onEvent(zeus::Promise::ObserverEvent _callback) {
if (m_promise == nullptr) {
return;
}
m_promise->onProgress(_callback);
m_promise->onEvent(_callback);
}
echrono::Duration zeus::FutureBase::getTransmitionTime() const {

6
zeus/FutureBase.hpp
View File

@ -44,7 +44,7 @@ namespace zeus {
*/
FutureBase(uint32_t _transactionId, ememory::SharedPtr<zeus::Message> _returnData, uint32_t _source=0);
/**
* @brief set the call is an action an then it can receive remote data ==> the authorize the onProgress Callback ..
* @brief set the call is an action an then it can receive remote data ==> the authorize the onEvent Callback ..
* @note system use only ==> user have never to call this function...
*/
void setAction();
@ -65,9 +65,9 @@ namespace zeus {
void andElse(zeus::Promise::Observer _callback);
/**
* @brief Attach callback on activity of the action if user set some return information
* @param[in] _callback Handle on the function to call in progress information
* @param[in] _callback Handle on the function to call in event information
*/
void onProgress(zeus::Promise::ObserverProgress _callback);
void onEvent(zeus::Promise::ObserverEvent _callback);
/*
/ **
* @brief Attach callback on a specific return action (ABORT)

3
zeus/Object.hpp
View File

@ -117,10 +117,11 @@ namespace zeus {
* @note: this is for ACTION function call not normal function call
*/
template<class ZEUS_RETURN_VALUE,
class ZEUS_ACTION_TYPE,
class ZEUS_CLASS_TYPE,
class... ZEUS_FUNC_ARGS_TYPE>
zeus::AbstractFunction* advertise(const std::string& _name,
ZEUS_RETURN_VALUE (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification& _notifs, ZEUS_FUNC_ARGS_TYPE... _args)) {
ZEUS_RETURN_VALUE (ZEUS_CLASS_TYPE::*_func)(zeus::ActionNotification<ZEUS_ACTION_TYPE>& _notifs, ZEUS_FUNC_ARGS_TYPE... _args)) {
if (etk::start_with(_name, "srv.") == true) {
ZEUS_ERROR("Advertise function start with 'srv.' is not permited ==> only allow for internal service: '" << _name << "'");
return nullptr;

21
zeus/Promise.cpp
View File

@ -6,7 +6,7 @@
#include <zeus/Promise.hpp>
#include <zeus/FutureBase.hpp>
#include <zeus/message/Answer.hpp>
#include <zeus/message/Progress.hpp>
#include <zeus/message/Event.hpp>
#include <zeus/debug.hpp>
#include <zeus/WebServer.hpp>
@ -106,12 +106,12 @@ void zeus::Promise::andElse(zeus::Promise::Observer _callback) {
m_callbackElse(zeus::FutureBase(sharedFromThis()));
}
void zeus::Promise::onProgress(zeus::Promise::ObserverProgress _callback) {
void zeus::Promise::onEvent(zeus::Promise::ObserverEvent _callback) {
std::unique_lock<std::mutex> lock(m_mutex);
if (m_isAction == false) {
ZEUS_ERROR("Request a progress calback on a simple function call");
ZEUS_ERROR("Request a Event calback on a simple function call");
}
m_callbackProgress = _callback;
m_callbackEvent = _callback;
}
echrono::Duration zeus::Promise::getTransmitionTime() const {
@ -127,11 +127,18 @@ bool zeus::Promise::setMessage(ememory::SharedPtr<zeus::Message> _value) {
std::unique_lock<std::mutex> lock(m_mutex);
m_receiveTime = echrono::Steady::now();
}
if (_value->getType() != zeus::message::type::progress) {
if (_value->getType() != zeus::message::type::event) {
std::unique_lock<std::mutex> lock(m_mutex);
// notification of a progresion ...
if (m_callbackProgress != nullptr) {
m_callbackProgress(static_cast<const zeus::message::Progress*>(m_message.get())->getData());
if (m_callbackEvent != nullptr) {
if (_value == nullptr) {
return true;
}
if (_value->getType() != zeus::message::type::event) {
ZEUS_WARNING("No Return value ...");
return true;
}
m_callbackEvent(ememory::staticPointerCast<zeus::message::Event>(_value));
return false; // no error
}
return false;

11
zeus/Promise.hpp
View File

@ -7,6 +7,7 @@
#include <etk/types.hpp>
#include <zeus/message/Message.hpp>
#include <zeus/message/Event.hpp>
#include <functional>
#include <ememory/memory.hpp>
#include <echrono/Steady.hpp>
@ -21,7 +22,7 @@ namespace zeus {
class Promise : public ememory::EnableSharedFromThis<zeus::Promise> {
public:
using Observer = std::function<bool(zeus::FutureBase)>; //!< Define an Observer: function pointer
using ObserverProgress = std::function<void(const std::string&)>; //!< Define the observer on activity of the action (note that is a string, but it can contain json or other ...)
using ObserverEvent = std::function<void(ememory::SharedPtr<zeus::message::Event>)>; //!< Define the observer on activity of the action (note that is a string, but it can contain json or other ...)
private:
mutable std::mutex m_mutex; //!< local prevention of multiple acess
uint32_t m_transactionId; //!< waiting answer data
@ -29,7 +30,7 @@ namespace zeus {
ememory::SharedPtr<zeus::Message> m_message; //!< all buffer concatenate or last buffer if synchronous
Observer m_callbackThen; //!< observer callback When data arrive and NO error appear
Observer m_callbackElse; //!< observer callback When data arrive and AN error appear
ObserverProgress m_callbackProgress; //!< observer callback When progress is sended from the remote object called
ObserverEvent m_callbackEvent; //!< observer callback when event is sended from the remote object called
//Observer m_callbackAbort; //!< observer callback When Action is abort by user
echrono::Steady m_sendTime; //!< time when the future has been sended request
echrono::Steady m_receiveTime; //!< time when the future has receve answer
@ -51,7 +52,7 @@ namespace zeus {
*/
Promise(uint32_t _transactionId, ememory::SharedPtr<zeus::Message> _returnData, uint32_t _source=0);
/**
* @brief set the call is an action an then it can receive remote data ==> the authorize the onProgress Callback ..
* @brief set the call is an action an then it can receive remote data ==> the authorize the onEvent Callback ..
* @note system use only ==> user have never to call this function...
*/
void setAction();
@ -72,9 +73,9 @@ namespace zeus {
void andElse(zeus::Promise::Observer _callback);
/**
* @brief Attach callback on activity of the action if user set some return information
* @param[in] _callback Handle on the function to call in progress information
* @param[in] _callback Handle on the function to call in event information
*/
void onProgress(zeus::Promise::ObserverProgress _callback);
void onEvent(zeus::Promise::ObserverEvent _callback);
/*
/ **
* @brief Attach callback on a specific return action (ABORT)

22
zeus/WebServer.cpp
View File

@ -11,18 +11,13 @@
#include <zeus/message/Data.hpp>
ememory::SharedPtr<zeus::message::Call> zeus::createBaseCall(bool _isEvent,
const ememory::SharedPtr<zeus::WebServer>& _iface,
ememory::SharedPtr<zeus::message::Call> zeus::createBaseCall(const ememory::SharedPtr<zeus::WebServer>& _iface,
uint64_t _transactionId,
const uint32_t& _source,
const uint32_t& _destination,
const std::string& _functionName) {
ememory::SharedPtr<zeus::message::Call> obj;
if (_isEvent == false) {
obj = zeus::message::Call::create(_iface);
} else {
obj = zeus::message::Event::create(_iface);
}
obj = zeus::message::Call::create(_iface);
if (obj == nullptr) {
return nullptr;
}
@ -664,16 +659,3 @@ void zeus::WebServer::answerVoid(uint32_t _clientTransactionId, uint32_t _source
answer->addParameter();
writeBinary(answer);
}
void zeus::WebServer::progressNotify(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, const std::string& _value) {
auto answer = zeus::message::Progress::create(sharedFromThis());
if (answer == nullptr) {
return;
}
answer->setTransactionId(_clientTransactionId);
answer->setSource(_source);
answer->setDestination(_destination);
answer->setData(_value);
writeBinary(answer);
}

33
zeus/WebServer.hpp
View File

@ -34,8 +34,7 @@ namespace zeus {
* @param[in]
* @return
*/
ememory::SharedPtr<zeus::message::Call> createBaseCall(bool _isEvent,
const ememory::SharedPtr<zeus::WebServer>& _iface,
ememory::SharedPtr<zeus::message::Call> createBaseCall(const ememory::SharedPtr<zeus::WebServer>& _iface,
uint64_t _transactionId,
const uint32_t& _source,
const uint32_t& _destination,
@ -81,14 +80,13 @@ namespace zeus {
* @return
*/
template<class... _ARGS>
ememory::SharedPtr<zeus::message::Call> createCall(bool _isEvent,
const ememory::SharedPtr<zeus::WebServer>& _iface,
ememory::SharedPtr<zeus::message::Call> createCall(const ememory::SharedPtr<zeus::WebServer>& _iface,
uint64_t _transactionId,
const uint32_t& _source,
const uint32_t& _destination,
const std::string& _functionName,
_ARGS&&... _args) {
ememory::SharedPtr<zeus::message::Call> callElem = createBaseCall(_isEvent, _iface, _transactionId, _source, _destination, _functionName);
ememory::SharedPtr<zeus::message::Call> callElem = createBaseCall(_iface, _transactionId, _source, _destination, _functionName);
if (callElem == nullptr) {
return nullptr;
}
@ -307,21 +305,10 @@ namespace zeus {
template<class... _ARGS>
zeus::FutureBase call(const uint32_t& _source, const uint32_t& _destination, const std::string& _functionName, _ARGS&&... _args) {
uint16_t id = getId();
ememory::SharedPtr<zeus::message::Call> callElem = zeus::createCall(false, sharedFromThis(), id, _source, _destination, _functionName, std::forward<_ARGS>(_args)...);
ememory::SharedPtr<zeus::message::Call> callElem = zeus::createCall(sharedFromThis(), id, _source, _destination, _functionName, std::forward<_ARGS>(_args)...);
return callBinary(id, callElem);
}
/**
* @brief
* @param[in]
* @return
*/
template<class... _ARGS>
void event(const uint32_t& _source, const uint32_t& _destination, const std::string& _eventName, _ARGS&&... _args) {
uint16_t id = getId();
ememory::SharedPtr<zeus::message::Call> callElem = zeus::createCall(true, sharedFromThis(), id, _source, _destination, _eventName, std::forward<_ARGS>(_args)...);
callBinary(id, callElem);
}
public: // progress ...
public: // Events ...
/**
* @brief Send a progression value to a specific call in progress
* @param[in] _transactionId Current trasaction ID
@ -329,7 +316,15 @@ namespace zeus {
* @param[in] _destination Destinatio of the progression
* @param[in] _value Value to send
*/
void progressNotify(uint32_t _transactionId, uint32_t _source, uint32_t _destination, const std::string& _value);
template<class ZEUS_ARG>
void eventValue(uint32_t _clientTransactionId, uint32_t _source, uint32_t _destination, ZEUS_ARG _value) {
ememory::SharedPtr<zeus::message::Event> event = zeus::message::Event::create(sharedFromThis());
event->setTransactionId(_clientTransactionId);
event->setSource(_source);
event->setDestination(_destination);
event->addEvent(_value);
writeBinary(event);
}
public: // answers ...
/**
* @brief

26
zeus/message/Event.cpp
View File

@ -10,6 +10,31 @@
#include <etk/stdTools.hpp>
#include <zeus/message/Event.hpp>
void zeus::message::Event::generateDisplay(std::ostream& _os) const {
zeus::Message::generateDisplay(_os);
if (getNumberParameter() != 0) {
_os << " '" + simpleStringParam(0) + "'";
}
}
bool zeus::message::Event::writeOn(enet::WebSocket& _interface) {
std::unique_lock<std::mutex> lock = _interface.getScopeLock();
zeus::Message::writeOn(_interface);
_interface.writeData((uint8_t*)(&m_uid), sizeof(m_uid));
if (message::Parameter::writeOn(_interface) == false) {
return false;
}
int32_t count = _interface.send();
return count > 0;
}
void zeus::message::Event::composeWith(const uint8_t* _buffer, uint32_t _lenght) {
uint64_t* uuid = (uint64_t*)_buffer;
m_uid = *uuid;
// parse parameters:
message::Parameter::composeWith(&_buffer[sizeof(m_uid)], _lenght-sizeof(m_uid));
}
// ------------------------------------------------------------------------------------
// -- Factory
// ------------------------------------------------------------------------------------
@ -17,3 +42,4 @@
ememory::SharedPtr<zeus::message::Event> zeus::message::Event::create(ememory::SharedPtr<zeus::WebServer> _iface) {
return ememory::SharedPtr<zeus::message::Event>(new zeus::message::Event(_iface));
}

36
zeus/message/Event.hpp
View File

@ -4,24 +4,33 @@
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <zeus/message/Call.hpp>
#include <etk/types.hpp>
#include <enet/WebSocket.hpp>
#include <zeus/message/ParamType.hpp>
#include <zeus/message/Parameter.hpp>
namespace zeus {
class WebServer;
namespace message {
class Event :
public message::Call {
public message::Parameter {
friend class zeus::Message;
protected:
uint64_t m_uid; //!< Signal is sended in an active call ==> then we need to identify all the type ==> need an uniqueId ... the bigger bit mean that the message has no more data ...
protected:
/**
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::message::Call::create
* @brief basic constructor (hidden to force the use of ememory::SharedPtr) @ref zeus::message::Event::create
*/
Event(ememory::SharedPtr<zeus::WebServer> _iface):
zeus::message::Call(_iface) {
zeus::message::Parameter(_iface) {
m_header.flags = ZEUS_BUFFER_FLAG_FINISH + uint8_t(zeus::message::type::event);
};
void composeWith(const uint8_t* _buffer, uint32_t _lenght) override;
bool writeOn(enet::WebSocket& _interface) override;
void generateDisplay(std::ostream& _os) const override;
public:
/**
* @brief Create a shared pointer on the MessageCall
* @brief Create a shared pointer on the Event
* @return Allocated Message.
*/
static ememory::SharedPtr<zeus::message::Event> create(ememory::SharedPtr<zeus::WebServer> _iface);
@ -29,7 +38,22 @@ namespace zeus {
enum zeus::message::type getType() const override {
return zeus::message::type::event;
}
/**
* @brief set the Event of the call
* @param[in] _value Value to add
*/
template<class ZEUS_TYPE_DATA>
void addEvent(const ZEUS_TYPE_DATA& _value) {
addParameter(_value);
}
/**
* @brief get the Event value
* @param[in] Data of the Event
*/
template<class ZEUS_TYPE_DATA>
ZEUS_TYPE_DATA getEvent() const {
return getParameter<ZEUS_TYPE_DATA>(0);
}
};
}
}

4
zeus/zeus-File.impl.cpp
View File

@ -119,11 +119,11 @@ zeus::Raw zeus::FileImpl::getPart(uint64_t _start, uint64_t _stop) {
}
std::string zeus::storeInFile(zeus::ProxyFile _file, std::string _filename) {
zeus::ActionNotification tmp;
zeus::ActionNotification<std::string> tmp;
return zeus::storeInFileNotify(_file, _filename, tmp);
}
std::string zeus::storeInFileNotify(zeus::ProxyFile _file, std::string _filename, zeus::ActionNotification _notification) {
std::string zeus::storeInFileNotify(zeus::ProxyFile _file, std::string _filename, zeus::ActionNotification<std::string> _notification) {
auto futSize = _file.getSize();
auto futSha = _file.getSha512();
futSize.wait();