Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/consolecommands3/src/libraries/core/command/ConsoleCommand.h @ 7236

Last change on this file since 7236 was 7236, checked in by landauf, 14 years ago

replaced the temporary names of all ConsoleCommand related classes and functions by their real names
  • Property svn:eol-style set to native
File size: 18.6 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _ConsoleCommand_H__
30#define _ConsoleCommand_H__
31
32#include "core/CorePrereqs.h"
33
34#include <stack>
35#include <boost/preprocessor/cat.hpp>
36#include <boost/preprocessor/facilities/expand.hpp>
37
38#include "util/VA_NARGS.h"
39#include "ArgumentCompletionFunctions.h"
40#include "Executor.h"
41
42
43#define SetConsoleCommand(...) \
44    BOOST_PP_EXPAND(BOOST_PP_CAT(SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
45#define SetConsoleCommand2(name, functionpointer) \
46    SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
47#define SetConsoleCommand3(group, name, functionpointer) \
48    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
49#define SetConsoleCommand4(group, name, functionpointer, object) \
50    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
51
52#define SetConsoleCommandGeneric(group, name, functor) \
53    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor)))
54
55
56#define DeclareConsoleCommand(...) \
57    BOOST_PP_CAT(DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__)
58#define DeclareConsoleCommand2(name, functionpointer) \
59    DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
60#define DeclareConsoleCommand3(group, name, functionpointer) \
61    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
62#define DeclareConsoleCommand4(group, name, functionpointer, object) \
63    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
64
65#define DeclareConsoleCommandGeneric(group, name, functor) \
66    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
67
68
69namespace orxonox
70{
71    namespace prototype
72    {
73        inline void void__void(void) {}
74        inline void void__string(const std::string&) {}
75    }
76
77    namespace AccessLevel
78    {
79        enum Enum
80        {
81            All,
82            Standalone,
83            Master,
84            Server,
85            Client,
86            Online,
87            Offline,
88            None
89        };
90    }
91
92    class _CoreExport ConsoleCommand
93    {
94        friend struct ConsoleCommandManipulator;
95
96        struct Command
97        {
98            ExecutorPtr executor_;
99            FunctorPtr functor_;
100        };
101
102        public:
103            struct ConsoleCommandManipulator
104            {
105                public:
106                    ConsoleCommandManipulator(const ConsoleCommand* command) : command_(const_cast<ConsoleCommand*>(command)) {}
107
108                    template <class F>
109                    inline ConsoleCommandManipulator& setFunction(F function, bool bForce = false)
110                        {
111                            if (this->command_)
112                            {
113                                if (this->command_->getExecutor() && this->command_->getExecutor()->getFunctor() && this->command_->getExecutor()->getFunctor()->getFullIdentifier() == typeid(F))
114                                {
115                                    FunctorPointer<F>* functor = static_cast<FunctorPointer<F>*>(this->command_->getExecutor()->getFunctor().get());
116                                    functor->setFunction(function);
117                                    return *this;
118                                }
119                                this->command_->setFunction(createFunctor(function), bForce);
120                            }
121                            return *this;
122                        }
123                    template <class F, class O>
124                    inline ConsoleCommandManipulator& setFunction(F function, O* object, bool bForce = false)
125                        {
126                            if (this->command_)
127                            {
128                                if (this->command_->getExecutor() && this->command_->getExecutor()->getFunctor() && this->command_->getExecutor()->getFunctor()->getFullIdentifier() == typeid(F))
129                                {
130                                    FunctorPointer<F, O>* functor = static_cast<FunctorPointer<F, O>*>(this->command_->getExecutor()->getFunctor().get());
131                                    functor->setFunction(function);
132                                    functor->setObject(object);
133                                    return *this;
134                                }
135                                this->command_->setFunction(createFunctor(function, object), bForce);
136                            }
137                            return *this;
138                        }
139                    inline ConsoleCommandManipulator& setFunction(const FunctorPtr& functor, bool bForce = false)
140                        { if (this->command_) { this->command_->setFunction(functor, bForce); } return *this; }
141                    inline ConsoleCommandManipulator& setFunction(const ExecutorPtr& executor, bool bForce = false)
142                        { if (this->command_) { this->command_->setFunction(executor, bForce); } return *this; }
143
144                    template <class F>
145                    inline ConsoleCommandManipulator& pushFunction(F function, bool bForce = false)
146                        { if (this->command_) { this->command_->pushFunction(createFunctor(function), bForce); } return *this; }
147                    template <class F, class O>
148                    inline ConsoleCommandManipulator& pushFunction(F function, O* object, bool bForce = false)
149                        { if (this->command_) { this->command_->pushFunction(createFunctor(function, object), bForce); } return *this; }
150                    inline ConsoleCommandManipulator& pushFunction(const FunctorPtr& functor, bool bForce = false)
151                        { if (this->command_) { this->command_->pushFunction(functor, bForce); } return *this; }
152                    inline ConsoleCommandManipulator& pushFunction(const ExecutorPtr& executor, bool bForce = false)
153                        { if (this->command_) { this->command_->pushFunction(executor, bForce); } return *this; }
154
155                    inline ConsoleCommandManipulator& popFunction()
156                        { if (this->command_) { this->command_->popFunction(); } return *this; }
157
158                    inline ConsoleCommandManipulator& resetFunction()
159                        { if (this->command_) { this->command_->resetFunction(); } return *this; }
160
161                    inline ConsoleCommandManipulator& setObject(void* object)
162                        { if (this->command_) { this->command_->setObject(object); } return *this; }
163                    inline ConsoleCommandManipulator& pushObject(void* object)
164                        { if (this->command_) { this->command_->pushObject(object); } return *this; }
165                    inline ConsoleCommandManipulator& popObject()
166                        { if (this->command_) { this->command_->popObject(); } return *this; }
167
168                    inline ConsoleCommandManipulator& setActive(bool bActive)
169                        { if (this->command_) { this->command_->setActive(bActive); } return *this; }
170                    inline ConsoleCommandManipulator& activate()
171                        { return this->setActive(true); }
172                    inline ConsoleCommandManipulator& deactivate()
173                        { return this->setActive(false); }
174
175                    inline ConsoleCommandManipulator& setHidden(bool bHidden)
176                        { if (this->command_) { this->command_->setHidden(bHidden); } return *this; }
177                    inline ConsoleCommandManipulator& hide()
178                        { return this->setHidden(true); }
179                    inline ConsoleCommandManipulator& show()
180                        { return this->setHidden(false); }
181
182                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1)
183                        { if (this->command_) { this->command_->defaultValues(param1); } return *this; }
184                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2)
185                        { if (this->command_) { this->command_->defaultValues(param1, param2); } return *this; }
186                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
187                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3); } return *this; }
188                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
189                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4); } return *this; }
190                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
191                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4, param5); } return *this; }
192                    inline ConsoleCommandManipulator& defaultValue(unsigned int index, const MultiType& param)
193                        { if (this->command_) { this->command_->defaultValue(index, param); } return *this; }
194
195                    inline ConsoleCommandManipulator& accessLevel(AccessLevel::Enum level)
196                        { if (this->command_) { this->command_->accessLevel(level); } return *this; }
197
198                    inline ConsoleCommandManipulator& argumentCompleter(unsigned int param, ArgumentCompleter* completer)
199                        { if (this->command_) { this->command_->argumentCompleter(param, completer); } return *this; }
200
201                    inline ConsoleCommandManipulator& setAsInputCommand()
202                        { if (this->command_) { this->command_->setAsInputCommand(); } return *this; }
203                    inline ConsoleCommandManipulator& keybindMode(KeybindMode::Value mode)
204                        { if (this->command_) { this->command_->keybindMode(mode); } return *this; }
205                    inline ConsoleCommandManipulator& inputConfiguredParam(int index)
206                        { if (this->command_) { this->command_->inputConfiguredParam(index); } return *this; }
207
208                private:
209                    ConsoleCommand* command_;
210            };
211
212        public:
213            ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
214            ~ConsoleCommand();
215
216            ConsoleCommand& addShortcut();
217            ConsoleCommand& addShortcut(const std::string&  name);
218            ConsoleCommand& addGroup(const std::string& group);
219            ConsoleCommand& addGroup(const std::string& group, const std::string&  name);
220
221            inline const std::string& getName() const
222                { return this->baseName_; }
223
224            const ExecutorPtr& getExecutor() const;
225            inline const ExecutorPtr& getBaseExecutor() const
226                { return this->baseExecutor_; }
227
228            inline ConsoleCommand& setActive(bool bActive)
229                { this->bActive_ = bActive; return *this; }
230            inline ConsoleCommand& activate()
231                { return this->setActive(true); }
232            inline ConsoleCommand& deactivate()
233                { return this->setActive(false); }
234
235            inline ConsoleCommand& setHidden(bool bHidden)
236                { this->bHidden_ = bHidden; return *this; }
237            inline ConsoleCommand& hide()
238                { return this->setHidden(true); }
239            inline ConsoleCommand& show()
240                { return this->setHidden(false); }
241
242            bool isActive() const;
243            bool hasAccess() const;
244            inline bool isHidden() const
245                { return this->bHidden_; }
246
247            ConsoleCommand& description(const std::string& description);
248            const std::string& getDescription() const;
249
250            ConsoleCommand& descriptionParam(unsigned int param, const std::string& description);
251            const std::string& getDescriptionParam(unsigned int param) const;
252
253            ConsoleCommand& descriptionReturnvalue(const std::string& description);
254            const std::string& getDescriptionReturnvalue(int param) const;
255
256            ConsoleCommand& defaultValues(const MultiType& param1);
257            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2);
258            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
259            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
260            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
261            ConsoleCommand& defaultValue(unsigned int index, const MultiType& param);
262
263            inline ConsoleCommand& accessLevel(AccessLevel::Enum level)
264                { this->accessLevel_ = level; return *this; }
265            inline AccessLevel::Enum getAccessLevel() const
266                { return this->accessLevel_; }
267
268            ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
269            ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
270
271            inline ConsoleCommand& setAsInputCommand()
272            {
273                this->keybindMode(KeybindMode::OnHold);
274                this->defaultValue(0, Vector2(0.0f, 0.0f));
275                this->inputConfiguredParam(0);
276                return *this;
277            }
278
279            inline ConsoleCommand& keybindMode(KeybindMode::Value mode)
280                { this->keybindMode_ = mode; return *this; }
281            inline KeybindMode::Value getKeybindMode() const
282                { return this->keybindMode_; }
283
284            inline ConsoleCommand& inputConfiguredParam(int index)
285                { this->inputConfiguredParam_ = index; return *this; }
286            inline int getInputConfiguredParam_() const
287                { return this->inputConfiguredParam_; }
288
289            inline ConsoleCommandManipulator getManipulator() const
290                { return this; }
291
292        private:
293            bool headersMatch(const FunctorPtr& functor);
294            bool headersMatch(const ExecutorPtr& executor);
295
296            bool setFunction(const ExecutorPtr& executor, bool bForce = false);
297            bool setFunction(const FunctorPtr& functor, bool bForce = false);
298            void pushFunction(const ExecutorPtr& executor, bool bForce = false);
299            void pushFunction(const FunctorPtr& functor, bool bForce = false);
300            void pushFunction();
301            void popFunction();
302            void resetFunction();
303
304            bool setObject(void* object);
305            void pushObject(void* object);
306            void popObject();
307            void* getObject() const;
308
309            bool bActive_;
310            bool bHidden_;
311            AccessLevel::Enum accessLevel_;
312            std::string baseName_;
313            ExecutorPtr baseExecutor_;
314
315            ExecutorPtr executor_;
316            std::stack<Command> commandStack_;
317            std::stack<void*> objectStack_;
318
319            ArgumentCompleter* argumentCompleter_[5];
320
321            KeybindMode::Value keybindMode_;
322            int inputConfiguredParam_;
323
324            LanguageEntryLabel description_;
325            LanguageEntryLabel descriptionReturnvalue_;
326            LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];
327
328        public:
329            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
330                { return ConsoleCommand::getCommandMap(); }
331            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
332                { return ConsoleCommand::getCommandMapLC(); }
333
334            static inline ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
335                { return ConsoleCommand::getCommand("", name, bPrintError); }
336            static inline ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
337                { return ConsoleCommand::getCommandLC("", name, bPrintError); }
338
339            static ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
340            static ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
341
342            static void destroyAll();
343
344        private:
345            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMap();
346            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMapLC();
347
348            static void registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command);
349            static void unregisterCommand(ConsoleCommand* command);
350    };
351
352    inline ConsoleCommand* createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
353        { return new ConsoleCommand("", name, executor, bInitialized); }
354    inline ConsoleCommand* createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
355        { return new ConsoleCommand(group, name, executor, bInitialized); }
356
357    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& name)
358        { return ConsoleCommand::getCommand(name, true); }
359    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& group, const std::string& name)
360        { return ConsoleCommand::getCommand(group, name, true); }
361}
362
363#endif /* _ConsoleCommand_H__ */
Note: See TracBrowser for help on using the repository browser.