Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

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

adapted CommandExecutor and CommandEvaluation to make it compile again, but it doesn't run yet. ready for refactoring.
  • Property svn:eol-style set to native
File size: 18.0 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            bool isHidden() const;
245
246            _ConsoleCommand& description(const std::string& description);
247            const std::string& getDescription() const;
248
249            _ConsoleCommand& descriptionParam(unsigned int param, const std::string& description);
250            const std::string& getDescriptionParam(unsigned int param) const;
251
252            _ConsoleCommand& descriptionReturnvalue(const std::string& description);
253            const std::string& getDescriptionReturnvalue(int param) const;
254
255            _ConsoleCommand& defaultValues(const MultiType& param1);
256            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2);
257            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
258            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
259            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
260            _ConsoleCommand& defaultValue(unsigned int index, const MultiType& param);
261
262            inline _ConsoleCommand& accessLevel(AccessLevel::Enum level)
263                { this->accessLevel_ = level; return *this; }
264            inline AccessLevel::Enum getAccessLevel() const
265                { return this->accessLevel_; }
266
267            _ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
268            ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
269
270            inline _ConsoleCommand& setAsInputCommand()
271            {
272                this->keybindMode(KeybindMode::OnHold);
273                this->defaultValue(0, Vector2(0.0f, 0.0f));
274                this->inputConfiguredParam(0);
275                return *this;
276            }
277
278            inline _ConsoleCommand& keybindMode(KeybindMode::Value mode)
279                { this->keybindMode_ = mode; return *this; }
280            inline KeybindMode::Value getKeybindMode() const
281                { return this->keybindMode_; }
282
283            inline _ConsoleCommand& inputConfiguredParam(int index)
284                { this->inputConfiguredParam_ = index; return *this; }
285            inline int getInputConfiguredParam_() const
286                { return this->inputConfiguredParam_; }
287
288            inline _ConsoleCommandManipulator getManipulator() const
289                { return this; }
290
291        private:
292            bool headersMatch(const FunctorPtr& functor);
293            bool headersMatch(const ExecutorPtr& executor);
294
295            bool setFunction(const ExecutorPtr& executor, bool bForce = false);
296            bool setFunction(const FunctorPtr& functor, bool bForce = false);
297            void pushFunction(const ExecutorPtr& executor, bool bForce = false);
298            void pushFunction(const FunctorPtr& functor, bool bForce = false);
299            void pushFunction();
300            void popFunction();
301            void resetFunction();
302
303            bool setObject(void* object);
304            void pushObject(void* object);
305            void popObject();
306            void* getObject() const;
307
308            bool bActive_;
309            bool bHidden_;
310            AccessLevel::Enum accessLevel_;
311            std::string baseName_;
312            ExecutorPtr baseExecutor_;
313
314            ExecutorPtr executor_;
315            std::stack<Command> commandStack_;
316            std::stack<void*> objectStack_;
317
318            ArgumentCompleter* argumentCompleter_[5];
319
320            KeybindMode::Value keybindMode_;
321            int inputConfiguredParam_;
322
323            LanguageEntryLabel description_;
324            LanguageEntryLabel descriptionReturnvalue_;
325            LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];
326
327        public:
328            static inline const std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommands()
329                { return _ConsoleCommand::getCommandMap(); }
330
331            static inline const _ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
332                { return _ConsoleCommand::getCommand("", name, bPrintError); }
333            static const _ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
334
335            static void destroyAll();
336
337        private:
338            static std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommandMap();
339            static void registerCommand(const std::string& group, const std::string& name, _ConsoleCommand* command);
340            static void unregisterCommand(_ConsoleCommand* command);
341    };
342
343    inline _ConsoleCommand* _createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
344        { return new _ConsoleCommand("", name, executor, bInitialized); }
345    inline _ConsoleCommand* _createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
346        { return new _ConsoleCommand(group, name, executor, bInitialized); }
347
348    inline _ConsoleCommand::_ConsoleCommandManipulator _ModifyConsoleCommand(const std::string& name)
349        { return _ConsoleCommand::getCommand(name, true); }
350    inline _ConsoleCommand::_ConsoleCommandManipulator _ModifyConsoleCommand(const std::string& group, const std::string& name)
351        { return _ConsoleCommand::getCommand(group, name, true); }
352}
353
354#endif /* _ConsoleCommand_H__ */
Note: See TracBrowser for help on using the repository browser.