atria-soft/zeus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
zeus/jus/AbstractFunctionTypeClass.h

325 lines
13 KiB
C++
Raw Blame History

/** @file
* @author Edouard DUPIN
* @copyright 2016, Edouard DUPIN, all right reserved
* @license APACHE v2.0 (see license file)
*/
#pragma once
#include <jus/TcpString.h>
#include <eproperty/Value.h>
#include <ejson/ejson.h>
#include <jus/debug.h>
#include <jus/AbstractFunction.h>
#include <jus/mineType.h>
#include <etk/os/FSNode.h>
#include <ejson/base64.h>
namespace jus {
template <class JUS_CLASS_TYPE, class JUS_RETURN, class... JUS_TYPES>
void executeClassCallJson(const ememory::SharedPtr<jus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
JUS_CLASS_TYPE* _pointer,
JUS_RETURN (JUS_CLASS_TYPE::*_func)(JUS_TYPES...),
const ejson::Array& _params) {
std::vector<ActionAsyncClient> asyncAction;
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
ejson::Value ret = convertToJson(asyncAction, -1, (*_pointer.*_func)((convertJsonTo<JUS_TYPES>(_params[idParam++]))...));
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(JUS_TYPES))-1;
ejson::Value ret = convertToJson(asyncAction, -1, (*_pointer.*_func)(convertJsonTo<JUS_TYPES>(_params[idParam--])...));
#else
#error Must be implemented ...
ejson::Value ret = ejson::Null();
return;
#endif
if (asyncAction.size() != 0) {
JUS_ERROR("Missing send async messages");
}
ejson::Object answer;
answer.add("id", ejson::Number(_transactionId));
answer.add("client-id", ejson::Number(_clientId));
answer.add("return", ret);
JUS_INFO("Answer: " << answer.generateHumanString());
_interfaceClient->write(answer.generateMachineString());
}
class SendFile {
private:
jus::FileServer m_data;
uint64_t m_transactionId;
uint64_t m_clientId;
uint32_t m_partId;
etk::FSNode m_node;
uint64_t m_size;
public:
SendFile(jus::FileServer _data,
uint64_t _transactionId,
uint64_t _clientId) :
m_data(_data),
m_transactionId(_transactionId),
m_clientId(_clientId),
m_partId(0),
m_node(_data.getFileName()),
m_size(0) {
}
~SendFile() {
//m_node.fileClose();
}
bool operator() (TcpString* _interface) {
ejson::Object answer;
answer.add("id", ejson::Number(m_transactionId));
answer.add("client-id", ejson::Number(m_clientId));
answer.add("part", ejson::Number(m_partId));
if (m_partId == 0) {
m_node.fileOpenRead();
ejson::Object file;
file.add("type", ejson::String("file"));
std::string extention = std::string(m_data.getFileName().begin()+m_data.getFileName().size() -3, m_data.getFileName().end());
JUS_WARNING("send file: '" << m_data.getFileName() << "' with extention: '" << extention << "'");
file.add("mine-type", ejson::String(jus::getMineType(extention)));
m_size = m_node.fileSize();
file.add("size", ejson::Number(m_size));
answer.add("return", file);
JUS_INFO("Answer: " << answer.generateHumanString());
_interface->write(answer.generateMachineString());
m_partId++;
return false;
}
int32_t tmpSize = 1024;
if (m_size < 1024) {
tmpSize = m_size;
}
uint8_t tmpData[1024];
m_node.fileRead(tmpData, 1, tmpSize);
answer.add("data", ejson::String(ejson::base64::encode(tmpData, tmpSize)));
m_size -= tmpSize;
if (m_size <= 0) {
answer.add("finish", ejson::Boolean(true));
m_node.fileClose();
}
JUS_INFO("Answer: " << answer.generateHumanString());
_interface->write(answer.generateMachineString());
m_partId++;
if (m_size <= 0) {
return true;
}
return false;
}
};
template <class JUS_CLASS_TYPE, class... JUS_TYPES>
void executeClassCallJson(const ememory::SharedPtr<jus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
JUS_CLASS_TYPE* _pointer,
jus::FileServer (JUS_CLASS_TYPE::*_func)(JUS_TYPES...),
const ejson::Array& _params) {
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
jus::FileServer tmpElem = (*_pointer.*_func)((convertJsonTo<JUS_TYPES>(_params[idParam++]))...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(JUS_TYPES))-1;
jus::FileServer tmpElem = (*_pointer.*_func)(convertJsonTo<JUS_TYPES>(_params[idParam--])...);
#else
#error Must be implemented ...
jus::FileServer tmpElem;
return;
#endif
_interfaceClient->addAsync(SendFile(tmpElem, _transactionId, _clientId));
}
template <class JUS_CLASS_TYPE, class... JUS_TYPES>
void executeClassCallJson(const ememory::SharedPtr<jus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
JUS_CLASS_TYPE* _pointer,
void (JUS_CLASS_TYPE::*_func)(JUS_TYPES...),
const ejson::Array& _params) {
ejson::Object out;
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
(*_pointer.*_func)((convertJsonTo<JUS_TYPES>(_params[idParam++]))...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(JUS_TYPES))-1;
(*_pointer.*_func)(convertJsonTo<JUS_TYPES>(_params[idParam--])...);
#else
#error Must be implemented ...
ejson::Value ret = ejson::Null();
return;
#endif
ejson::Object answer;
answer.add("id", ejson::Number(_transactionId));
answer.add("client-id", ejson::Number(_clientId));
answer.add("return", ejson::Null());
JUS_INFO("Answer: " << answer.generateHumanString());
_interfaceClient->write(answer.generateMachineString());
}
template <class JUS_CLASS_TYPE, class JUS_RETURN, class... JUS_TYPES>
std::string executeClassCallString(JUS_CLASS_TYPE* _pointer,
JUS_RETURN (JUS_CLASS_TYPE::*_func)(JUS_TYPES...),
const std::vector<std::string>& _params) {
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
return etk::to_string((*_pointer.*_func)((convertStringTo<JUS_TYPES>(_params[idParam++]))...));
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(JUS_TYPES))-1;
return etk::to_string((*_pointer.*_func)(convertStringTo<JUS_TYPES>(_params[idParam--])...));
#else
#error Must be implemented ...
#endif
return "";
}
template <class JUS_CLASS_TYPE, class... JUS_TYPES>
std::string executeClassCallString(JUS_CLASS_TYPE* _pointer,
void (JUS_CLASS_TYPE::*_func)(JUS_TYPES...),
const std::vector<std::string>& _params) {
ejson::Object out;
#if defined(__clang__)
// clang generate a basic warning:
// warning: multiple unsequenced modifications to 'idParam' [-Wunsequenced]
int32_t idParam = 0;
(*_pointer.*_func)((convertStringTo<JUS_TYPES>(_params[idParam++]))...);
#elif defined(__GNUC__) || defined(__GNUG__) || defined(_MSC_VER)
int32_t idParam = int32_t(sizeof...(JUS_TYPES))-1;
(*_pointer.*_func)(convertStringTo<JUS_TYPES>(_params[idParam--])...);
#else
#error Must be implemented ...
#endif
return "";
}
template <class JUS_RETURN, class JUS_CLASS_TYPE, class... JUS_TYPES>
class AbstractFunctionTypeClass: public jus::AbstractFunction {
protected:
static const ParamType m_returnType;
static const ParamType m_paramType[sizeof...(JUS_TYPES)];
public:
using functionType = JUS_RETURN (JUS_CLASS_TYPE::*)(JUS_TYPES...);
functionType m_function;
AbstractFunctionTypeClass(const std::string& _name, const std::string& _desc, functionType _fptr):
AbstractFunction(_name, _desc),
m_function(_fptr) {
}
std::string getPrototype() const override {
std::string ret;
ret += m_returnType.getName();
ret += " ";
ret += m_name;
ret += "(";
for (size_t iii=0; iii<sizeof...(JUS_TYPES); ++iii) {
if (iii != 0) {
ret += ", ";
}
ret += m_paramType[iii].getName();
}
ret += ");";
return ret;
}
std::string getPrototypeReturn() const override {
return m_returnType.getName();
}
std::vector<std::string> getPrototypeParam() const override {
std::vector<std::string> out;
for (size_t iii=0; iii<sizeof...(JUS_TYPES); ++iii) {
out.push_back(m_paramType[iii].getName());
}
return out;
}
void executeJson(const ememory::SharedPtr<jus::TcpString>& _interfaceClient,
uint64_t _transactionId,
uint64_t _clientId,
const ejson::Array& _params,
void* _class) override {
JUS_CLASS_TYPE* tmpClass = nullptr;
if (_class != nullptr) {
tmpClass = (JUS_CLASS_TYPE*)_class;
}
// check parameter number
if (_params.size() != sizeof...(JUS_TYPES)) {
JUS_ERROR("Wrong number of Parameters ...");
ejson::Object answer;
answer.add("id", ejson::Number(_transactionId));
answer.add("client-id", ejson::Number(_clientId));
answer.add("error", ejson::String("WRONG-PARAMETER-NUMBER"));
std::string help = "request ";
help += etk::to_string(_params.size());
help += " parameters and need ";
help += etk::to_string(sizeof...(JUS_TYPES));
help += " parameters. prototype function:";
help += getPrototype();
answer.add("error-help", ejson::String(help));
JUS_INFO("Answer: " << answer.generateHumanString());
_interfaceClient->write(answer.generateMachineString());
return;
}
// check parameter compatibility
for (size_t iii=0; iii<sizeof...(JUS_TYPES); ++iii) {
if (checkCompatibility(m_paramType[iii], _params[iii]) == false) {
ejson::Object answer;
answer.add("id", ejson::Number(_transactionId));
answer.add("client-id", ejson::Number(_clientId));
answer.add("error", ejson::String("WRONG-PARAMETER-TYPE"));
answer.add("error-help", ejson::String("Parameter id " + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'"));
JUS_INFO("Answer: " << answer.generateHumanString());
_interfaceClient->write(answer.generateMachineString());
return;
}
}
// execute cmd:
jus::executeClassCallJson(_interfaceClient, _transactionId, _clientId, tmpClass, m_function, _params);
}
std::string executeString(const std::vector<std::string>& _params, void* _class) override {
JUS_CLASS_TYPE* tmpClass = (JUS_CLASS_TYPE*)_class;
std::string out;
// check parameter number
if (_params.size() != sizeof...(JUS_TYPES)) {
JUS_ERROR("Wrong number of Parameters ...");
out += "error:WRONG-PARAMETER-NUMBER;";
out += "error-help:request ";
out += etk::to_string(_params.size());
out += " parameters and need ";
out += etk::to_string(sizeof...(JUS_TYPES));
out += " parameters. prototype function:";
out += getPrototype();
return out;
}
// check parameter compatibility
for (size_t iii=0; iii<sizeof...(JUS_TYPES); ++iii) {
if (checkCompatibility(m_paramType[iii], _params[iii]) == false) {
out += "error:WRONG-PARAMETER-TYPE;";
out += "error-help:Parameter id " + etk::to_string(iii) + " not compatible with type: '" + m_paramType[iii].getName() + "'";
return out;
}
}
// execute cmd:
out = jus::executeClassCallString(tmpClass, m_function, _params);
return out;
}
};
template <class JUS_RETURN, class JUS_CLASS_TYPE, class... JUS_TYPES>
const ParamType AbstractFunctionTypeClass<JUS_RETURN, JUS_CLASS_TYPE, JUS_TYPES...>::m_returnType = createType<JUS_RETURN>();
template <class JUS_RETURN, class JUS_CLASS_TYPE, class... JUS_TYPES>
const ParamType AbstractFunctionTypeClass<JUS_RETURN, JUS_CLASS_TYPE, JUS_TYPES...>::m_paramType[sizeof...(JUS_TYPES)] = {createType<JUS_TYPES>()...};
template <typename JUS_RETURN, class JUS_CLASS_TYPE, typename... JUS_TYPES>
AbstractFunction* createAbstractFunctionClass(const std::string& _name, const std::string& _desc, JUS_RETURN (JUS_CLASS_TYPE::*_fffp)(JUS_TYPES...)) {
return new AbstractFunctionTypeClass<JUS_RETURN, JUS_CLASS_TYPE, JUS_TYPES...>(_name, _desc, _fffp);
}
}
Reference in New Issue View Git Blame Copy Permalink