Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/questsystem2/src/core/CommandLine.h @ 2274

Last change on this file since 2274 was 2103, checked in by rgrieder, 16 years ago

Merged r2101 (objecthierarchy) to trunk.

  • Property svn:eol-style set to native
File size: 8.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 *      Reto Grieder
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _CommandLine_H__
30#define _CommandLine_H__
31
32#include "CorePrereqs.h"
33#include <map>
34#include "util/Convert.h"
35#include "util/Debug.h"
36#include "util/Exception.h"
37#include "util/MultiType.h"
38
39#define SetCommandLineArgument(name, defaultValue) \
40    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
41    = orxonox::CommandLine::addArgument(#name, defaultValue)
42#define SetCommandLineSwitch(name) \
43    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
44    = orxonox::CommandLine::addArgument(#name, false)
45
46
47namespace orxonox
48{
49    /**
50    @brief
51        Container class for a command line argument of any type supported by MultiType.
52
53        Whenever you want to have an option specified by a command line switch,
54        you need to first define it with SetCommandLineArgument(name, defaultValue).
55        It is then added to a map and possibly changed when the command line is being parsed.
56        If the option was not given, you can detect this by asking hasDefaultValue().
57
58        There is a possibility to define a short cut so you can write "-p 20" instead of "--port 20".
59        Note the difference between "-" and "--"!
60        Also, there is no restriction to the number of strings you add after --name.
61        So "--startVector (2, 4, 5)" is perfectly legal.
62
63        Retrieving an argument is possible with the getCommandLineArgument function of the
64        CommandLine class. It is a Singleton, but the public interface is static.
65    */
66    class _CoreExport CommandLineArgument
67    {
68        friend class CommandLine;
69
70    public:
71        //! Tells whether the value has been changed by the command line.
72        bool hasDefaultValue() const { return bHasDefaultValue_; }
73        //! Returns the name of the argument.
74        const std::string& getName() const { return name_; }
75
76        //! Returns the shortcut (example: "-p 22" for "--port 22") of the argument.
77        //! Evaluates to "" if none there is none.
78        const std::string& getShortcut() const { return shortcut_; }
79        //! Sets the shortcut for the argument
80        CommandLineArgument& shortcut(const std::string& shortcut)
81        { this->shortcut_ = shortcut; return *this; }
82
83        //! Returns the usage information
84        const std::string& getInformation() const { return this->usageInformation_; }
85        //! Sets the option information when displaying orxonox usage.
86        CommandLineArgument& information(const std::string& usage)
87        { this->usageInformation_ = usage; return *this; }
88
89        //! Returns the actual value of the argument. Can be equal to default value.
90        MultiType getValue() const { return value_; }
91        //! Returns the given default value as type T.
92        MultiType getDefaultValue() const { return defaultValue_; }
93
94    private:
95        //! Constructor initialises both value_ and defaultValue_ with defaultValue.
96        CommandLineArgument(const std::string& name, const MultiType& defaultValue)
97            : bHasDefaultValue_(true)
98            , name_(name)
99            , value_(defaultValue)
100            , defaultValue_(defaultValue)
101        { }
102
103        //! Undefined copy constructor
104        CommandLineArgument(const CommandLineArgument& instance);
105        ~CommandLineArgument() { }
106
107        //! Parses the value string of a command line argument.
108        void parse(const std::string& value);
109
110        //! Tells whether the value has been changed by the command line.
111        bool bHasDefaultValue_;
112
113    private:
114        std::string name_;             //!< Name of the argument
115        std::string shortcut_;         //!< Shortcut of the argument. @see getShortcut().
116        std::string usageInformation_; //!< Tells about the usage of this parameter
117
118        MultiType value_;            //!< The actual value
119        MultiType defaultValue_;     //!< Default value. Should not be changed.
120    };
121
122
123    /**
124    @brief
125        Global interface to command line options.
126        Allows to add and retrieve command line arguments. Also does the parsing.
127    @note
128        Internally it is a Singleton, but the public interface is static.
129    @see
130        CommandLineArgument
131    */
132    class _CoreExport CommandLine
133    {
134    public:
135
136        //! Parse redirection to internal member method.
137        static void parseAll(int argc, char** argv) { _getInstance()._parseAll(argc, argv); }
138
139        static std::string getUsageInformation();
140
141        static const CommandLineArgument* getArgument(const std::string& name);
142        //! Writes the argument value in the given parameter.
143        template <class T>
144        static void getValue(const std::string& name, T* value)
145        { *value = (T)(getArgument(name)->getValue()); }
146        static MultiType getValue(const std::string& name)
147        { return getArgument(name)->getValue(); }
148        template <class T>
149        static CommandLineArgument& addArgument(const std::string& name, T defaultValue);
150
151        static bool existsArgument(const std::string& name)
152        {
153            std::map<std::string, CommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
154            return !(it == _getInstance().cmdLineArgs_.end());
155        }
156
157
158    private:
159        //! Constructor initialises bFirstTimeParse_ with true.
160        CommandLine() : bFirstTimeParse_(true) { }
161        //! Undefined copy constructor
162        CommandLine(const CommandLine& instance);
163        ~CommandLine();
164
165        static CommandLine& _getInstance();
166
167        void _parseAll(int argc, char** argv);
168        void _parse(const std::vector<std::string>& arguments);
169        void checkFullArgument(const std::string& name, const std::string& value);
170        void checkShortcut(const std::string& shortcut, const std::string& value);
171
172        /**
173            Tells whether we parsed for the first time. The CommmandLineArguments are added before main().
174            So when we call parse() the first time, we need to create a map with all shortcuts since these
175            get added after addCommandLineArgument().
176        */
177        bool bFirstTimeParse_;
178
179        //! Holds all pointers to the arguments and serves as a search map by name.
180        std::map<std::string, CommandLineArgument*> cmdLineArgs_;
181        //! Search map by chortcut for the arguments.
182        std::map<std::string, CommandLineArgument*> cmdLineArgsShortcut_;
183    };
184
185    template <>
186    inline void CommandLine::getValue<std::string>(const std::string& name, std::string* value)
187    {
188        *value = (std::string)(getArgument(name)->getValue().getString());
189    }
190
191    /**
192    @brief
193        Adds a new CommandLineArgument to the internal map.
194        Note that only such arguments are actually valid.
195    @param name
196        Name of the argument. Shortcut can be added later.
197    @param defaultValue
198        Default value that is used when argument was not given.
199    */
200    template <class T>
201    CommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
202    {
203        OrxAssert(!_getInstance().existsArgument(name),
204            "Cannot add a command line argument with name '" + name + "' twice.");
205
206        return *(_getInstance().cmdLineArgs_[name] = new CommandLineArgument(name, defaultValue));
207    }
208}
209
210#endif /* _CommandLine_H__ */
Note: See TracBrowser for help on using the repository browser.