[DEV] Create function signature in c++11 and call with a json object (simple function not class function)

jus/Client.h

@@ -87,7 +87,7 @@ namespace jus {
 			void createParam(ejson::Object& _obj, const std::vector<bool>& _param, _ARGS&&... _args) {
 				ejson::Array array = _obj["param"].toArray();
 				ejson::Array array2;
-				for (auto& it : _param) {
+				for (const auto& it : _param) {
 					array2.add(ejson::Boolean(it));
 				}
 				array.add(array2);

jus/Service.cpp

@@ -9,6 +9,99 @@
 
 #include <unistd.h>
 
+generate_basic_type(void, "void");
+generate_basic_type(bool, "bool");
+generate_basic_type(float, "float");
+generate_basic_type(double, "double");
+generate_basic_type(int64_t, "int64");
+generate_basic_type(int32_t, "int32");
+generate_basic_type(int16_t, "int16");
+generate_basic_type(int8_t, "int8");
+generate_basic_type(uint64_t, "uint64");
+generate_basic_type(uint32_t, "uint32");
+generate_basic_type(uint16_t, "uint16");
+generate_basic_type(uint8_t, "uint8");
+generate_basic_type(std::string, "string");
+
+template<> bool convertJsonTo<bool>(const ejson::Value& _value) {
+	return _value.toBoolean().get();
+}
+template<> float convertJsonTo<float>(const ejson::Value& _value) {
+	return _value.toNumber().get();
+}
+template<> double convertJsonTo<double>(const ejson::Value& _value) {
+	return _value.toNumber().get();
+}
+template<> int64_t convertJsonTo<int64_t>(const ejson::Value& _value) {
+	return int64_t(_value.toNumber().get());
+}
+template<> int32_t convertJsonTo<int32_t>(const ejson::Value& _value) {
+	return int32_t(_value.toNumber().get());
+}
+template<> int16_t convertJsonTo<int16_t>(const ejson::Value& _value) {
+	return int16_t(_value.toNumber().get());
+}
+template<> int8_t convertJsonTo<int8_t>(const ejson::Value& _value) {
+	return int8_t(_value.toNumber().get());
+}
+template<> uint64_t convertJsonTo<uint64_t>(const ejson::Value& _value) {
+	return uint64_t(_value.toNumber().get());
+}
+template<> uint32_t convertJsonTo<uint32_t>(const ejson::Value& _value) {
+	return uint32_t(_value.toNumber().get());
+}
+template<> uint16_t convertJsonTo<uint16_t>(const ejson::Value& _value) {
+	return uint16_t(_value.toNumber().get());
+}
+template<> uint8_t convertJsonTo<uint8_t>(const ejson::Value& _value) {
+	return uint8_t(_value.toNumber().get());
+}
+template<> std::string convertJsonTo<std::string>(const ejson::Value& _value) {
+	_value.display();
+	return _value.toString().get();
+}
+
+template<> ejson::Value convertToJson<bool>(const bool& _value) {
+	return ejson::Boolean(_value);
+}
+template<> ejson::Value convertToJson<float>(const float& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<double>(const double& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<int64_t>(const int64_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<int32_t>(const int32_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<int16_t>(const int16_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<int8_t>(const int8_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<uint64_t>(const uint64_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<uint32_t>(const uint32_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<uint16_t>(const uint16_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<uint8_t>(const uint8_t& _value) {
+	return ejson::Number(_value);
+}
+template<> ejson::Value convertToJson<std::string>(const std::string& _value) {
+	return ejson::String(_value);
+}
+
+
+
+
+
 jus::Service::Service() :
   propertyIp(this, "ip", "127.0.0.1", "Ip to connect server", &jus::Service::onPropertyChangeIp),
   propertyPort(this, "port", 1984, "Port to connect server", &jus::Service::onPropertyChangePort),

jus/Service.h

@@ -10,6 +10,193 @@
 #include <ejson/ejson.h>
 #include <jus/debug.h>
 
+class ParamType {
+	protected:
+		const char* m_typeName;
+	public:
+		ParamType(const char* _name = ""):
+		  m_typeName(_name) {
+			
+		}
+		const char* getName() const {
+			return m_typeName;
+		}
+};
+
+template<class JUS_TYPE>
+ParamType createType();
+
+#define generate_basic_type(_type, _name) \
+template<> ParamType createType<_type>() {\
+	return ParamType(_name); \
+}
+
+class CmdBase {
+	public:
+		template<typename JUS_TYPE>
+		class Type2String {
+			public:
+				//std::string operator()();
+				static std::string name();
+		};
+	protected:
+		const std::string m_name;
+	public:
+		const std::string& getName() const {
+			return m_name;
+		}
+	protected:
+		const std::string m_description;
+	public:
+		const std::string& getDescription() const {
+			return m_description;
+		}
+	protected:
+		ParamType m_returnType;
+		std::vector<ParamType> m_listParamType;
+	protected:
+		CmdBase(const std::string& _name,
+		        const std::string& _desc,
+		        const ParamType& _retType,
+		        const std::vector<ParamType>& _params):
+		  m_name(_name),
+		  m_description(_desc),
+		  m_returnType(_retType),
+		  m_listParamType(_params) {
+			
+		}
+	public:
+		virtual ~CmdBase() {};
+		//virtual bool checkArguments(const std::vector<CmdBase::Variant>& _params) = 0;
+	public:
+		std::string getPrototype() const {
+			std::string ret;
+			ret += m_returnType.getName();
+			ret += " ";
+			ret += m_name;
+			ret += "(";
+			for (size_t iii=0; iii<m_listParamType.size(); ++iii) {
+				if (iii != 0) {
+					ret += ", ";
+				}
+				ret += m_listParamType[iii].getName();
+			}
+			ret += ");";
+			return ret;
+		}
+		virtual ejson::Value execute(const ejson::Array& _params) = 0;
+};
+
+template<class JUS_TYPE>
+JUS_TYPE convertJsonTo(const ejson::Value& _value);
+
+template<class JUS_TYPE>
+ejson::Value convertToJson(const JUS_TYPE& _value);
+
+template <class JUS_RETURN, class... JUS_TYPES>
+class TypeList: public CmdBase {
+	protected:
+		//int32_t m_sizeParam;
+	public:
+		using functionType = JUS_RETURN (*)(JUS_TYPES...);
+		functionType m_function;
+		TypeList(const std::string& _name, const std::string& _desc, functionType _fptr):
+		  CmdBase(_name, _desc, createType<JUS_RETURN>(), {createType<JUS_TYPES>()...}),
+		  //m_sizeParam(sizeof...(JUS_TYPES)),
+		  m_function(_fptr) {
+			
+		}
+		//template <typename std::enable_if<!std::is_same<JUS_RETURN, void>::value>::type >
+		ejson::Value execute2(const ejson::Array& _params) {
+			ejson::Object out;
+			if (_params.size() != m_listParamType.size()) {
+				JUS_ERROR("Wrong number of Parameters ...");
+				out.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(m_listParamType.size());
+				help += " parameters. prototype function:";
+				help += getPrototype();
+				out.add("error-help", ejson::String(help));
+				return out;
+			}
+			// TODO : Check params ...
+			int32_t idParam = 0;
+			ejson::Value retVal = convertToJson(m_function(convertJsonTo<JUS_TYPES>(_params[idParam++])...));
+			out.add("return", retVal);
+			return out;
+		}
+		
+		ejson::Value execute(const ejson::Array& _params) override {
+			return execute2(_params);
+		}
+};
+// Void special case :
+template <class... JUS_TYPES>
+class TypeListVoid: public CmdBase {
+	protected:
+		//int32_t m_sizeParam;
+	public:
+		using functionType = void (*)(JUS_TYPES...);
+		functionType m_function;
+		TypeListVoid(const std::string& _name, const std::string& _desc, functionType _fptr):
+		  CmdBase(_name, _desc, createType<void>(), {createType<JUS_TYPES>()...}),
+		  //m_sizeParam(sizeof...(JUS_TYPES)),
+		  m_function(_fptr) {
+			
+		}
+		ejson::Value execute(const ejson::Array& _params) override {
+			ejson::Object out;
+			if (_params.size() != m_listParamType.size()) {
+				JUS_ERROR("Wrong number of Parameters ...");
+				out.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(m_listParamType.size());
+				help += " parameters. prototype function:";
+				help += getPrototype();
+				out.add("error-help", ejson::String(help));
+				return out;
+			}
+			// TODO : Check params ...
+			int32_t idParam = m_listParamType.size()-1;
+			m_function(convertJsonTo<JUS_TYPES>(_params[idParam--])...);
+			out.add("return", ejson::Null());
+			return out;
+		}
+};
+
+template <typename JUS_RETURN, typename... JUS_TYPES>
+CmdBase* createCmd(const std::string& _name, const std::string& _desc, JUS_RETURN (*_fffp)(JUS_TYPES...)) {
+	return new TypeList<JUS_RETURN, JUS_TYPES...>(_name, _desc, _fffp);
+}
+template <typename... JUS_TYPES>
+CmdBase* createCmd(const std::string& _name, const std::string& _desc, void (*_fffp)(JUS_TYPES...)) {
+	return new TypeListVoid<JUS_TYPES...>(_name, _desc, _fffp);
+}
+
+
+static double mulllll(double _val1) {
+	double _val2 = 2.0f;
+	JUS_ERROR("Call with parameter : " << _val1);
+	return _val1*_val2;
+}
+
+static void mulllll2(std::string _value, int32_t _val1) {
+	JUS_ERROR("Call with parameter : " << _value);
+	JUS_ERROR("          parameter : " << _val1);
+}
+
+static std::string mulllll3(float _value, bool _val1) {
+	double _val2 = 1.0f;
+	return "";
+}
+
+static bool mulllll4() {
+	return false;
+}
 namespace jus {
 	class Service : public eproperty::Interface {
 		public:
@@ -71,6 +258,33 @@ namespace jus {
 			void advertise(const std::string& _name,
 			               JUS_RETURN_VALUE (JUS_CLASS_TYPE::*_func)(const JUS_FUNC_ARGS_TYPE&... _args),
 			               const std::string& _desc) {
+				
+				//CmdBase* tmp = createCmd(_name, &mulllll);
+				CmdBase* tmp = createCmd(_name, "desc", &mulllll);
+				JUS_ERROR("Signature : " << tmp->getPrototype());
+				{
+					ejson::Array param;
+					param.add(ejson::Number(58.5));
+					ejson::Value out = tmp->execute(param);
+					JUS_ERROR("    return: ");
+					out.display();
+				}
+				
+				
+				tmp = createCmd(_name, "desc", &mulllll2);
+				JUS_ERROR("Signature2 : " << tmp->getPrototype());
+				{
+					ejson::Array param;
+					param.add(ejson::String("coucou"));
+					param.add(ejson::Number(1563));
+					ejson::Value out = tmp->execute(param);
+					JUS_ERROR("    return: ");
+					out.display();
+				}
+				tmp = createCmd(_name, "desc", &mulllll3);
+				JUS_ERROR("Signature3 : " << tmp->getPrototype());
+				tmp = createCmd(_name, "desc", &mulllll4);
+				JUS_ERROR("Signature4 : " << tmp->getPrototype());
 				/*
 				std::vector<std::string> plop = createSignature(_args):
 				JUS_ERROR("signature:");

test/service1/appl/main.cpp

@@ -13,7 +13,8 @@
 namespace appl {
 	class Service1 : public jus::Service {
 		private:
-			double mul(const double& _val1, const double& _val2) {
+			double mul(const double& _val1) {//, const double& _val2) {
+				double _val2 = 1.0f;
 				return _val1*_val2;
 			}
 		public: