From 1fe4406f374291ab2e86e95a97341fd9c475fcb8 Mon Sep 17 00:00:00 2001 From: Jun Wako Date: Fri, 24 Apr 2015 16:26:14 +0900 Subject: Squashed 'tmk_core/' changes from 7967731..b9e0ea0 b9e0ea0 Merge commit '7fa9d8bdea3773d1195b04d98fcf27cf48ddd81d' as 'tool/mbed/mbed-sdk' 7fa9d8b Squashed 'tool/mbed/mbed-sdk/' content from commit 7c21ce5 git-subtree-dir: tmk_core git-subtree-split: b9e0ea08cb940de20b3610ecdda18e9d8cd7c552 --- tool/mbed/mbed-sdk/libraries/rpc/rpc.h | 313 +++++++++++++++++++++++++++++++++ 1 file changed, 313 insertions(+) create mode 100644 tool/mbed/mbed-sdk/libraries/rpc/rpc.h (limited to 'tool/mbed/mbed-sdk/libraries/rpc/rpc.h') diff --git a/tool/mbed/mbed-sdk/libraries/rpc/rpc.h b/tool/mbed/mbed-sdk/libraries/rpc/rpc.h new file mode 100644 index 000000000..8ed63c65a --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/rpc/rpc.h @@ -0,0 +1,313 @@ +/* mbed Microcontroller Library + * Copyright (c) 2006-2013 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef RPC_H +#define RPC_H + +#include "mbed.h" +#include "Arguments.h" + +namespace mbed { + +#define RPC_MAX_STRING 128 + +struct rpc_function { + const char *name; + void (*function_caller)(Arguments*, Reply*); +}; + +struct rpc_class { + const char *name; + const rpc_function *static_functions; + struct rpc_class *next; +}; + +/* Class RPC + * The RPC class for most things + */ +class RPC { + +public: + + RPC(const char *name = NULL); + + virtual ~RPC(); + + /* Function get_rpc_methods + * Returns a pointer to an array describing the rpc methods + * supported by this object, terminated by either + * RPC_METHOD_END or RPC_METHOD_SUPER(Superclass). + * + * Example + * > class Example : public RPC { + * > int foo(int a, int b) { return a + b; } + * > virtual const struct rpc_method *get_rpc_methods() { + * > static const rpc_method rpc_methods[] = { + * > { "foo", generic_caller }, + * > RPC_METHOD_SUPER(RPC) + * > }; + * > return rpc_methods; + * > } + * > }; + */ + virtual const struct rpc_method *get_rpc_methods(); + + static bool call(const char *buf, char *result); + + /* Function lookup + * Lookup and return the object that has the given name. + * + * Variables + * name - the name to lookup. + */ + static RPC *lookup(const char *name); + +protected: + static RPC *_head; + RPC *_next; + char *_name; + bool _from_construct; + +private: + static rpc_class *_classes; + + static const rpc_function _RPC_funcs[]; + static rpc_class _RPC_class; + + void delete_self(); + static void list_objs(Arguments *args, Reply *result); + static void clear(Arguments *args, Reply *result); + +public: + /* Function add_rpc_class + * Add the class to the list of classes which can have static + * methods called via rpc (the static methods which can be called + * are defined by that class' get_rpc_class() static method). + */ + template + static void add_rpc_class() { + rpc_class *c = C::get_rpc_class(); + c->next = _classes; + _classes = c; + } + + template + static const char *construct() { + RPC *p = new C(); + p->_from_construct = true; + return p->_name; + } + + template + static const char *construct(A1 arg1) { + RPC *p = new C(arg1); + p->_from_construct = true; + return p->_name; + } + + template + static const char *construct(A1 arg1, A2 arg2) { + RPC *p = new C(arg1, arg2); + p->_from_construct = true; + return p->_name; + } + + template + static const char *construct(A1 arg1, A2 arg2, A3 arg3) { + RPC *p = new C(arg1, arg2, arg3); + p->_from_construct = true; + return p->_name; + } + + template + static const char *construct(A1 arg1, A2 arg2, A3 arg3, A4 arg4) { + RPC *p = new C(arg1, arg2, arg3, arg4); + p->_from_construct = true; + return p->_name; + } +}; + +/* Macro MBED_OBJECT_NAME_MAX + * The maximum size of object name (including terminating null byte) + * that will be recognised when using fopen to open a FileLike + * object, or when using the rpc function. + */ +#define MBED_OBJECT_NAME_MAX 32 + +/* Macro MBED_METHOD_NAME_MAX + * The maximum size of rpc method name (including terminating null + * byte) that will be recognised by the rpc function (in rpc.h). + */ +#define MBED_METHOD_NAME_MAX 32 + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + (static_cast(this_ptr)->*member)(arguments, result); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + (static_cast(this_ptr)->*member)(); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + + (static_cast(this_ptr)->*member)(arg1); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + + (static_cast(this_ptr)->*member)(arg1, arg2); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + A3 arg3 = arguments->getArg(); + + (static_cast(this_ptr)->*member)(arg1, arg2, arg3); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + R res = (static_cast(this_ptr)->*member)(); + result->putData(res); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + + R res = (static_cast(this_ptr)->*member)(arg1); + result->putData(res); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + + R res = (static_cast(this_ptr)->*member)(arg1, arg2); + result->putData(res); +} + +/* Function rpc_method_caller + */ +template +void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + A3 arg3 = arguments->getArg(); + + R res = (static_cast(this_ptr)->*member)(arg1, arg2, arg3); + result->putData(res); +} + +/* Function rpc_function caller + */ +template +void rpc_function_caller(Arguments *arguments, Reply *result) { + R res = (*func)(); + result->putData(res); +} + +/* Function rpc_function caller + */ +template +void rpc_function_caller(Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + R res = (*func)(arg1); + result->putData(res); +} + +/* Function rpc_function caller + */ +template +void rpc_function_caller(Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + + R res = (*func)(arg1, arg2); + result->putData(res); +} + +/* Function rpc_function caller + */ +template +void rpc_function_caller(Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + A3 arg3 = arguments->getArg(); + + R res = (*func)(arg1, arg2, arg3); + result->putData(res); +} + +/* Function rpc_function caller + */ +template +void rpc_function_caller(Arguments *arguments, Reply *result) { + A1 arg1 = arguments->getArg(); + A2 arg2 = arguments->getArg(); + A3 arg3 = arguments->getArg(); + A4 arg4 = arguments->getArg(); + + R res = (*func)(arg1, arg2, arg3, arg4); + result->putData(res); +} + +struct rpc_method { + const char *name; + typedef void (*method_caller_t)(RPC*, Arguments*, Reply*); + typedef const struct rpc_method *(*super_t)(RPC*); + union { + method_caller_t method_caller; + super_t super; + }; +}; + +template +const struct rpc_method *rpc_super(RPC *this_ptr) { + return static_cast(this_ptr)->C::get_rpc_methods(); +} + +#define RPC_METHOD_END { NULL, NULL } +#define RPC_METHOD_SUPER(C) { NULL, (rpc_method::method_caller_t)rpc_super } + +} // namespace mbed + +#endif -- cgit v1.2.3