]> git.donarmstrong.com Git - qmk_firmware.git/blob - tool/mbed/mbed-sdk/libraries/rpc/rpc.h
Squashed 'tmk_core/' changes from 7967731..b9e0ea0
[qmk_firmware.git] / tool / mbed / mbed-sdk / libraries / rpc / rpc.h
1 /* mbed Microcontroller Library
2  * Copyright (c) 2006-2013 ARM Limited
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #ifndef RPC_H
17 #define RPC_H
18
19 #include "mbed.h"
20 #include "Arguments.h"
21
22 namespace mbed {
23
24 #define RPC_MAX_STRING      128
25
26 struct rpc_function {
27     const char *name;
28     void (*function_caller)(Arguments*, Reply*);
29 };
30
31 struct rpc_class {
32     const char *name;
33     const rpc_function *static_functions;
34     struct rpc_class *next;
35 };
36
37 /* Class RPC
38  *  The RPC class for most things
39  */
40 class RPC {
41
42 public:
43
44     RPC(const char *name = NULL);
45
46     virtual ~RPC();
47
48     /* Function get_rpc_methods
49      *  Returns a pointer to an array describing the rpc methods
50      *  supported by this object, terminated by either
51      *  RPC_METHOD_END or RPC_METHOD_SUPER(Superclass).
52      *
53      * Example
54      * > class Example : public RPC {
55      * >   int foo(int a, int b) { return a + b; }
56      * >   virtual const struct rpc_method *get_rpc_methods() {
57      * >     static const rpc_method rpc_methods[] = {
58      * >       { "foo", generic_caller<int, Example, int, int, &Example::foo> },
59      * >       RPC_METHOD_SUPER(RPC)
60      * >     };
61      * >     return rpc_methods;
62      * >   }
63      * > };
64      */
65     virtual const struct rpc_method *get_rpc_methods();
66
67     static bool call(const char *buf, char *result);
68
69     /* Function lookup
70      *  Lookup and return the object that has the given name.
71      *
72      * Variables
73      *  name - the name to lookup.
74      */
75     static RPC *lookup(const char *name);
76
77 protected:
78     static RPC *_head;
79     RPC *_next;
80     char *_name;
81     bool _from_construct;
82
83 private:
84     static rpc_class *_classes;
85
86     static const rpc_function _RPC_funcs[];
87     static rpc_class _RPC_class;
88
89     void delete_self();
90     static void list_objs(Arguments *args, Reply *result);
91     static void clear(Arguments *args, Reply *result);
92
93 public:
94     /* Function add_rpc_class
95      *  Add the class to the list of classes which can have static
96      *  methods called via rpc (the static methods which can be called
97      *  are defined by that class' get_rpc_class() static method).
98      */
99     template<class C>
100     static void add_rpc_class() {
101         rpc_class *c = C::get_rpc_class();
102         c->next = _classes;
103         _classes = c;
104     }
105
106     template<class C>
107     static const char *construct() {
108         RPC *p = new C();
109         p->_from_construct = true;
110         return p->_name;
111     }
112
113     template<class C, typename A1>
114     static const char *construct(A1 arg1) {
115         RPC *p = new C(arg1);
116         p->_from_construct = true;
117         return p->_name;
118     }
119
120     template<class C, typename A1, typename A2>
121     static const char *construct(A1 arg1, A2 arg2) {
122         RPC *p = new C(arg1, arg2);
123         p->_from_construct = true;
124         return p->_name;
125     }
126
127     template<class C, typename A1, typename A2, typename A3>
128     static const char *construct(A1 arg1, A2 arg2, A3 arg3) {
129         RPC *p = new C(arg1, arg2, arg3);
130         p->_from_construct = true;
131         return p->_name;
132     }
133
134     template<class C, typename A1, typename A2, typename A3, typename A4>
135     static const char *construct(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
136         RPC *p = new C(arg1, arg2, arg3, arg4);
137         p->_from_construct = true;
138         return p->_name;
139     }
140 };
141
142 /* Macro MBED_OBJECT_NAME_MAX
143  *  The maximum size of object name (including terminating null byte)
144  *  that will be recognised when using fopen to open a FileLike
145  *  object, or when using the rpc function.
146  */
147 #define MBED_OBJECT_NAME_MAX 32
148
149 /* Macro MBED_METHOD_NAME_MAX
150  *  The maximum size of rpc method name (including terminating null
151  *  byte) that will be recognised by the rpc function (in rpc.h).
152  */
153 #define MBED_METHOD_NAME_MAX 32
154
155 /* Function rpc_method_caller
156  */
157 template<class T, void(T::*member)(const char *, char *)>
158 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
159     (static_cast<T*>(this_ptr)->*member)(arguments, result);
160 }
161
162 /* Function rpc_method_caller
163  */
164 template<class T, void(T::*member)()>
165 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
166     (static_cast<T*>(this_ptr)->*member)();
167 }
168
169 /* Function rpc_method_caller
170  */
171 template<class T, typename A1, void(T::*member)(A1)>
172 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
173     A1 arg1 = arguments->getArg<A1>();
174
175     (static_cast<T*>(this_ptr)->*member)(arg1);
176 }
177
178 /* Function rpc_method_caller
179  */
180 template<class T, typename A1, typename A2, void(T::*member)(A1, A2)>
181 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
182     A1 arg1 = arguments->getArg<A1>();
183     A2 arg2 = arguments->getArg<A2>();
184
185     (static_cast<T*>(this_ptr)->*member)(arg1, arg2);
186 }
187
188 /* Function rpc_method_caller
189  */
190 template<class T, typename A1, typename A2, typename A3, void(T::*member)(A1, A2, A3)>
191 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
192     A1 arg1 = arguments->getArg<A1>();
193     A2 arg2 = arguments->getArg<A2>();
194     A3 arg3 = arguments->getArg<A3>();
195
196     (static_cast<T*>(this_ptr)->*member)(arg1, arg2, arg3);
197 }
198
199 /* Function rpc_method_caller
200  */
201 template<typename R, class T, R(T::*member)()>
202 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
203     R res = (static_cast<T*>(this_ptr)->*member)();
204     result->putData<R>(res);
205 }
206
207 /* Function rpc_method_caller
208  */
209 template<typename R, class T, typename A1, R(T::*member)(A1)>
210 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
211     A1 arg1 = arguments->getArg<A1>();
212
213     R res = (static_cast<T*>(this_ptr)->*member)(arg1);
214     result->putData<R>(res);
215 }
216
217 /* Function rpc_method_caller
218  */
219 template<typename R, class T, typename A1, typename A2, R(T::*member)(A1, A2)>
220 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
221     A1 arg1 = arguments->getArg<A1>();
222     A2 arg2 = arguments->getArg<A2>();
223
224     R res = (static_cast<T*>(this_ptr)->*member)(arg1, arg2);
225     result->putData<R>(res);
226 }
227
228 /* Function rpc_method_caller
229  */
230 template<typename R, class T, typename A1, typename A2, typename A3, R(T::*member)(A1, A2, A3)>
231 void rpc_method_caller(RPC *this_ptr, Arguments *arguments, Reply *result) {
232     A1 arg1 = arguments->getArg<A1>();
233     A2 arg2 = arguments->getArg<A2>();
234     A3 arg3 = arguments->getArg<A3>();
235
236     R res = (static_cast<T*>(this_ptr)->*member)(arg1, arg2, arg3);
237     result->putData<R>(res);
238 }
239
240 /* Function rpc_function caller
241  */
242 template<typename R, R(*func)()>
243 void rpc_function_caller(Arguments *arguments, Reply *result) {
244     R res = (*func)();
245     result->putData<R>(res);
246 }
247
248 /* Function rpc_function caller
249  */
250 template<typename R, typename A1, R(*func)(A1)>
251 void rpc_function_caller(Arguments *arguments, Reply *result) {
252     A1 arg1 = arguments->getArg<A1>();
253     R res = (*func)(arg1);
254     result->putData<R>(res);
255 }
256
257 /* Function rpc_function caller
258  */
259 template<typename R, typename A1, typename A2, R(*func)(A1, A2)>
260 void rpc_function_caller(Arguments *arguments, Reply *result) {
261     A1 arg1 = arguments->getArg<A1>();
262     A2 arg2 = arguments->getArg<A2>();
263
264     R res = (*func)(arg1, arg2);
265     result->putData<R>(res);
266 }
267
268 /* Function rpc_function caller
269  */
270 template<typename R, typename A1, typename A2, typename A3, R(*func)(A1, A2, A3)>
271 void rpc_function_caller(Arguments *arguments, Reply *result) {
272     A1 arg1 = arguments->getArg<A1>();
273     A2 arg2 = arguments->getArg<A2>();
274     A3 arg3 = arguments->getArg<A3>();
275
276     R res = (*func)(arg1, arg2, arg3);
277     result->putData<R>(res);
278 }
279
280 /* Function rpc_function caller
281  */
282 template<typename R, typename A1, typename A2, typename A3, typename A4, R(*func)(A1, A2, A3, A4)>
283 void rpc_function_caller(Arguments *arguments, Reply *result) {
284     A1 arg1 = arguments->getArg<A1>();
285     A2 arg2 = arguments->getArg<A2>();
286     A3 arg3 = arguments->getArg<A3>();
287     A4 arg4 = arguments->getArg<A4>();
288
289     R res = (*func)(arg1, arg2, arg3, arg4);
290     result->putData<R>(res);
291 }
292
293 struct rpc_method {
294     const char *name;
295     typedef void (*method_caller_t)(RPC*, Arguments*, Reply*);
296     typedef const struct rpc_method *(*super_t)(RPC*);
297     union {
298         method_caller_t method_caller;
299         super_t super;
300     };
301 };
302
303 template<class C>
304 const struct rpc_method *rpc_super(RPC *this_ptr) {
305     return static_cast<C*>(this_ptr)->C::get_rpc_methods();
306 }
307
308 #define RPC_METHOD_END      { NULL, NULL }
309 #define RPC_METHOD_SUPER(C) { NULL, (rpc_method::method_caller_t)rpc_super<C> }
310
311 } // namespace mbed
312
313 #endif