Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/shell/shell_command.h @ 5327

Last change on this file since 5327 was 5327, checked in by bensch, 19 years ago

orxonox/trunk: more overwhelmingly complicated code, that slowly gets out of my grasp
File size: 17.3 KB
Line 
1/*!
2 * @file shell_command.h
3 * Definition of a on-screen-shell
4 *
5 * @todo also take Static functions
6*/
7
8#ifndef _SHELL_COMMAND_H
9#define _SHELL_COMMAND_H
10
11#include "base_object.h"
12
13#include "helper_functions.h"
14#include "substring.h"
15#include "functor_list.h"
16
17#include <stdarg.h>
18
19#define     SHELL_COMMAND_MAX_SIZE      //!< The maximum size of a Shell Command
20
21
22
23// FORWARD DECLARATION
24template<class T> class tList;
25
26/**
27 * an easy to use Macro to create a Command
28 * @param command the name of the command (without "" around the string)
29 * @param class the name of the class to apply this command to (without the "" around the string)
30 * @param function the function to call
31 *
32 * MEANING:
33 *  ShellCommandBase* someUniqueVarName =
34 *       ShellCommand<ClassName>::registerCommand("commandNameInShell", "ClassName", &ClassName::FunctionToCall);
35 *
36 * In the Shell you would call this Command using:
37 * $ ClassName [ObjectName] commandNameInShell [parameters]
38 */
39#define SHELL_COMMAND(command, class, function) \
40        ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
41
42
43////////////////
44// BASE CLASS //
45////////////////
46class ShellCommandBase;
47class ShellCommandAlias;
48
49//! A class to hold all Classes that have (once) registered Commands.
50class ShellCommandClass : public BaseObject
51{
52  friend class ShellCommandBase;
53
54  public:
55    /** @returns the CommandClassList */
56    static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };
57    static bool getCommandListOfClass(const char* className, tList<const char>* stringList);
58    static bool getCommandListOfAlias(tList<const char>* aliasList);
59
60    static ShellCommandClass* getCommandClass(const char* className);
61    static void unregisterAllCommands();
62
63    static void help (const char* className);
64
65  private:
66    ShellCommandClass(const char* className);
67    ~ShellCommandClass();
68
69    static const ShellCommandClass* isRegistered(const char* className);
70    static void initCommandClassList();
71
72  private:
73    const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
74    long                             classID;                   //!< The classID of this Class
75    tList<ShellCommandBase>*         commandList;               //!< A list of Commands from this Class
76    static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
77    static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
78};
79
80
81//! a baseClass for all possible ShellCommands
82class ShellCommandBase : public BaseObject
83{
84  friend class ShellCommandClass;
85  public:
86    static bool execute (const char* executionString);
87
88    ShellCommandBase* describe(const char* description);
89    ShellCommandBase* setAlias(const char* alias);
90    ShellCommandBase* defaultValues(unsigned int count, ...);
91
92    /** @returns the CommandList of the Shell */
93    static void unregisterCommand(const char* commandName, const char* className);
94
95    static void debug();
96
97  protected:
98    ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...);
99    ~ShellCommandBase();
100
101    static bool isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...);
102    static const char* paramToString(long parameter);
103
104    void debugDyn();
105
106  private:
107    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
108    virtual void executeCommand (BaseObject* object, const char* parameters) = 0;
109
110  protected:
111    void*                            functionPointer;                      //!< The pointeer to the function of the Class (or static pointer if ClassID == CL_NULL )
112    unsigned int                     paramCount;                           //!< the count of parameters.
113    unsigned int*                    parameters;                           //!< Parameters the function of this Command takes.
114    char*                            defaultStrings[FUNCTOR_MAX_ARGUMENTS];//!< A list of default Strings stored.
115    int                              defaultInts[FUNCTOR_MAX_ARGUMENTS];   //!< A list of default Ints stored.
116    float                            defaultFloats[FUNCTOR_MAX_ARGUMENTS]; //!< A list of default Floats stored.
117    bool                             defaultBools[FUNCTOR_MAX_ARGUMENTS];  //!< A list of default Bools stored.
118
119  private:
120    ShellCommandClass*               shellClass;                           //!< A Pointer to the Shell-Class this Command belongs to.
121    ShellCommandAlias*               alias;                                //!< An Alias for the Class.
122
123    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
124};
125
126///////////////////////////////////////////////////
127///////////////////////////////////////////////////
128
129/////////////////////////////////
130// MACRO DEFINITION EXTENSIONS //
131/////////////////////////////////
132//! where to chek for default BOOL values
133#define   l_BOOL_DEFGRAB(i)         this->defaultBools[i]
134//! where to chek for default INT values
135#define   l_INT_DEFGRAB(i)          this->defaultInts[i]
136//! where to chek for default UINT values
137#define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultInts[i]
138//! where to chek for default LONG values
139#define   l_LONG_DEFGRAB(i)         (long)this->defaultInts[i]
140//! where to chek for default FLOAT values
141#define   l_FLOAT_DEFGRAB(i)        this->defaultFloats[i]
142//! where to chek for default STRING values
143#define   l_STRING_DEFGRAB(i)       this->defaultStrings[i]
144
145//////////////////////////
146// COMMAND REGISTRATION //
147//////////////////////////
148// SHELLCOMMAND can be redefined as ShellCommand or ShellCommandStatic
149// SHELLCOMMANDEXECUTER can be redefined too.
150// SHELLCOMMANDINCLASS
151//! registers a command without any parameters
152#define ShellCommandRegister0() \
153  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
154  { \
155    if (isRegistered(commandName, className, 0)== true) \
156      return NULL; \
157    return new SHELLCOMMAND<T>(commandName, className, function); \
158  }
159
160//! registers a command with 1 parameter
161#define ShellCommandRegister1(t1) \
162  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
163  { \
164    if (isRegistered(commandName, className, 1, t1##_PARAM)== true) \
165      return NULL; \
166    return new SHELLCOMMAND<T>(commandName, className, function, d1); \
167  }
168
169//! registers a command with 2 parameters
170#define ShellCommandRegister2(t1,t2) \
171  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
172  { \
173    if (isRegistered(commandName, className, 2, t1##_PARAM, t2##_PARAM)== true) \
174      return NULL; \
175    return new SHELLCOMMAND<T>(commandName, className, function, d1, d2); \
176  }
177
178//! registers a command with 3 parameters
179#define ShellCommandRegister3(t1,t2,t3) \
180  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
181  { \
182    if (isRegistered(commandName, className, 3, t1##_PARAM, t2##_PARAM, t3##_PARAM)== true) \
183      return NULL; \
184    return new SHELLCOMMAND<T>(commandName, className, function, d1, d2, d3); \
185  }
186
187//! registers a command with 4 parameters
188#define ShellCommandRegister4(t1,t2,t3,t4) \
189  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
190  { \
191    if (isRegistered(commandName, className, 4, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM)== true) \
192      return NULL; \
193    return new SHELLCOMMAND<T>(commandName, className, function, d1, d2, d3, d4); \
194  }
195
196//! registers a command with 5 parameters
197#define ShellCommandRegister5(t1,t2,t3,t4,t5) \
198  static SHELLCOMMAND<T>* registerCommand(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT, t5##_TYPE d5 = t5##_DEFAULT) \
199  { \
200    if (isRegistered(commandName, className, 5, t1##_PARAM, t2##_PARAM, t3##_PARAM, t4##_PARAM, t5##_PARAM)== true) \
201      return NULL; \
202    return new ShellCommand<T>(commandName, className, function, d1, d2, d3, d4, d5); \
203  }
204
205//////////////////
206// CONSTRUCTORS //
207/////////////////
208//! creates a command that takes no parameters
209#define ShellCommandConstructor0() \
210  void SHELLCOMMANDINCLASS(*functionPointer_0)(); \
211  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)()) \
212  : ShellCommandBase(commandName, className, 0) \
213  { \
214    this->functionPointer_0 = function; \
215  }
216
217//! creates a command that takes one parameter
218#define ShellCommandConstructor1(t1) \
219  void SHELLCOMMANDINCLASS(*functionPointer_1_##t1)(t1##_TYPE); \
220  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE), t1##_TYPE d1) \
221  : ShellCommandBase(commandName, className, 1, t1##_PARAM, d1) \
222  { \
223    this->functionPointer_1_##t1 = function; \
224  }
225
226//! creates a command that takes two parameters
227#define ShellCommandConstructor2(t1,t2) \
228  void SHELLCOMMANDINCLASS(*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); \
229  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1, t2##_TYPE d2) \
230  : ShellCommandBase(commandName, className, 2, t1##_PARAM, d1, t2##_PARAM, d2) \
231  { \
232    this->functionPointer_2_##t1##_##t2 = function; \
233  }
234
235//! creates a command that takes three parameter
236#define ShellCommandConstructor3(t1,t2,t3) \
237  void SHELLCOMMANDINCLASS(*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); \
238  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3) \
239  : ShellCommandBase(commandName, className, 3, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3) \
240  { \
241    this->functionPointer_3_##t1##_##t2##_##t3 = function; \
242  }
243
244//! creates a command that takes four parameter
245#define ShellCommandConstructor4(t1,t2,t3,t4) \
246  void SHELLCOMMANDINCLASS(*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); \
247  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4) \
248  : ShellCommandBase(commandName, className, 4, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4) \
249  { \
250    this->functionPointer_4_##t1##_##t2##_##t3##_##t4 = function; \
251  }
252
253//! creates a command that takes five parameter
254#define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
255  void SHELLCOMMANDINCLASS(*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
256  SHELLCOMMAND(const char* commandName, const char* className, void SHELLCOMMANDINCLASS(*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1, t2##_TYPE d2, t3##_TYPE d3, t4##_TYPE d4, t5##_TYPE d5) \
257  : ShellCommandBase(commandName, className, 5, t1##_PARAM, d1, t2##_PARAM, d2, t3##_PARAM, d3, t4##_PARAM, d4, t5##_PARAM, d5) \
258  { \
259    this->functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5 = function; \
260  }
261
262///////////////
263// EXECUTION //
264///////////////
265//! execute-macro for functions with no parameters
266#define ShellCommandExecute0() \
267  if (this->paramCount == 0) \
268    SHELLCOMMANDEXECUTER(_0)()
269
270//! execute-macro for functions with one parameter
271#define ShellCommandExecute1(t1) \
272   else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
273    SHELLCOMMANDEXECUTER(_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
274
275//! execute-macro for functions with two parameters
276#define ShellCommandExecute2(t1,t2) \
277   else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
278    SHELLCOMMANDEXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
279
280//! execute-macro for functions with three parameters
281#define ShellCommandExecute3(t1,t2,t3) \
282   else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
283    SHELLCOMMANDEXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)))
284
285//! execute-macro for functions with four parameters
286#define ShellCommandExecute4(t1,t2,t3,t4) \
287   else if (this->paramCount == 4 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM) \
288    SHELLCOMMANDEXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)))
289
290//! execute-macro for functions with five parameters
291#define ShellCommandExecute5(t1,t2,t3,t4,t5) \
292   else if (this->paramCount == 5 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM && this->parameters[4] == t5##_PARAM) \
293    SHELLCOMMANDEXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)), t5##_FUNC(sub.getString(4), t5##_DEFGRAB(4)))
294
295
296//! keeps information about a ShellCommand
297template<class T> class ShellCommand : public ShellCommandBase
298{
299  public:
300#ifdef FUNCTOR_LIST
301#undef FUNCTOR_LIST
302#endif
303#ifdef SHELLCOMMAND
304#undef SHELLCOMMAND
305#endif
306#define SHELLCOMMAND                       ShellCommand
307#ifdef SHELLCOMMANDEXECUTER
308#undef SHELLCOMMANDEXECUTER
309#endif
310#define SHELLCOMMANDEXECUTER(nameExt)      (dynamic_cast<T*>(object)->*functionPointer##nameExt)
311#ifdef SHELLCOMMANDINCLASS
312#undef SHELLCOMMANDINCLASS
313#endif
314#define SHELLCOMMANDINCLASS(FUNCTION)      (T::FUNCTION)
315
316//! FUNCTOR_LIST is the List of command-registerers
317#define FUNCTOR_LIST(x) ShellCommandRegister ## x
318#include "functor_list.h"
319#undef FUNCTOR_LIST
320
321
322  private:
323//! FUNCTOR_LIST is the List of CommandConstructors
324#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
325#include "functor_list.h"
326#undef FUNCTOR_LIST
327
328    virtual void executeCommand (BaseObject* object, const char* parameters)
329    {
330      SubString sub(parameters, true);
331//! FUNCTOR_LIST is the List of Executive Functions
332#define FUNCTOR_LIST(x) ShellCommandExecute ## x
333#include "functor_list.h"
334#undef FUNCTOR_LIST
335    }
336};
337
338//! keeps information about a ShellCommand, that points to a Static Function
339template<class T> class ShellCommandStatic : public ShellCommandBase
340{
341  public:
342#ifdef FUNCTOR_LIST
343#undef FUNCTOR_LIST
344#endif
345#ifdef SHELLCOMMAND
346#undef SHELLCOMMAND
347#endif
348#define SHELLCOMMAND                      ShellCommandStatic
349#ifdef SHELLCOMMANDEXECUTER
350#undef SHELLCOMMANDEXECUTER
351#endif
352#define SHELLCOMMANDEXECUTER(nameExt)     T::functionPointer##nameExt
353#ifdef SHELLCOMMANDINCLASS
354#undef SHELLCOMMANDINCLASS
355#endif
356#define SHELLCOMMANDINCLASS(FUNCTION)     (FUNCTION)
357
358//! FUNCTOR_LIST is the List of command-registerers
359#define FUNCTOR_LIST(x) ShellCommandRegister ## x
360#include "functor_list.h"
361#undef FUNCTOR_LIST
362
363  private:
364//! FUNCTOR_LIST is the List of CommandConstructors
365#define FUNCTOR_LIST(x) ShellCommandConstructor ## x
366#include "functor_list.h"
367#undef FUNCTOR_LIST
368
369    virtual void executeCommand (BaseObject* object, const char* parameters)
370    {
371  SubString sub(parameters, true);
372//! FUNCTOR_LIST is the List of Executive Functions
373#define FUNCTOR_LIST(x) ShellCommandExecute ## x
374#include "functor_list.h"
375#undef FUNCTOR_LIST
376    }
377};
378
379//! A Class, that handles aliases.
380class ShellCommandAlias
381{
382  friend class ShellCommandBase;
383  public:
384    /** @returns the Name of the Alias. */
385    const char* getName() const { return this->aliasName; };
386    /** @returns the Command, this Alias is asociated with */
387    ShellCommandBase* getCommand() const { return this->command; };
388
389  private:
390    /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
391    ShellCommandAlias(const char* aliasName, ShellCommandBase* command) { this->aliasName = aliasName; this->command = command; };
392
393  private:
394    const char*         aliasName;       //!< the name of the Alias
395    ShellCommandBase*   command;         //!< a pointer to the command, this alias executes.
396};
397
398#endif /* _SHELL_COMMAND_H */
Note: See TracBrowser for help on using the repository browser.