Changeset 2087 for code/trunk/src/core/CommandLine.h

Timestamp:

Nov 1, 2008, 7:04:09 PM (16 years ago)

Author:

landauf

Message:

merged objecthierarchy branch back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/core/CommandLine.h (modified) (9 diffs)

code/trunk/src/core/CommandLine.h

@@ -35 +35 @@
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/MultiType.h"
 
 #define SetCommandLineArgument(name, defaultValue) \
-    BaseCommandLineArgument& CmdArgumentDummyBoolVar##name \
+    CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, defaultValue)
 #define SetCommandLineSwitch(name) \
-    BaseCommandLineArgument& CmdArgumentDummyBoolVar##name \
+    CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, false)
 
@@ -48 +49 @@
     /**
     @brief
-        Template struct which creates a distinct type for every integer constant.
-    @note
-        This allows to select a different function depending on a boolean value
-        when creating a new CommandLineArgument.
-        From 'Modern C++ Design' (Alexandrescu 2001).
+        Container class for a command line argument of any type supported by MultiType.
+
+        Whenever you want to have an option specified by a command line switch,
+        you need to first define it with SetCommandLineArgument(name, defaultValue).
+        It is then added to a map and possibly changed when the command line is being parsed.
+        If the option was not given, you can detect this by asking hasDefaultValue().
+
+        There is a possibility to define a short cut so you can write "-p 20" instead of "--port 20".
+        Note the difference between "-" and "--"!
+        Also, there is no restriction to the number of strings you add after --name.
+        So "--startVector (2, 4, 5)" is perfectly legal.
+
+        Retrieving an argument is possible with the getCommandLineArgument function of the
+        CommandLine class. It is a Singleton, but the public interface is static.
     */
-    template <int v>
-    struct Int2Type
-    {
-        enum { value = v };
-    };
-
-    /**
-    @brief
-        Base class for CommandLineArguments.
-    */
-    class _CoreExport BaseCommandLineArgument
+    class _CoreExport CommandLineArgument
     {
         friend class CommandLine;
@@ -78 +78 @@
         const std::string& getShortcut() const { return shortcut_; }
         //! Sets the shortcut for the argument
-        BaseCommandLineArgument& setShortcut(const std::string& shortcut)
+        CommandLineArgument& shortcut(const std::string& shortcut)
         { this->shortcut_ = shortcut; return *this; }
 
@@ -84 +84 @@
         const std::string& getInformation() const { return this->usageInformation_; }
         //! Sets the option information when displaying orxonox usage.
-        BaseCommandLineArgument& setInformation(const std::string& usage)
+        CommandLineArgument& information(const std::string& usage)
         { this->usageInformation_ = usage; return *this; }
 
-    protected:
-        BaseCommandLineArgument(const std::string& name)
+        //! Returns the actual value of the argument. Can be equal to default value.
+        MultiType getValue() const { return value_; }
+        //! Returns the given default value as type T.
+        MultiType getDefaultValue() const { return defaultValue_; }
+
+    private:
+        //! Constructor initialises both value_ and defaultValue_ with defaultValue.
+        CommandLineArgument(const std::string& name, const MultiType& defaultValue)
             : bHasDefaultValue_(true)
             , name_(name)
+            , value_(defaultValue)
+            , defaultValue_(defaultValue)
         { }
 
         //! Undefined copy constructor
-        BaseCommandLineArgument(const BaseCommandLineArgument& instance);
-        virtual ~BaseCommandLineArgument() { }
+        CommandLineArgument(const CommandLineArgument& instance);
+        ~CommandLineArgument() { }
 
         //! Parses the value string of a command line argument.
-        virtual void parse(const std::string& value) = 0;
+        void parse(const std::string& value);
 
         //! Tells whether the value has been changed by the command line.
@@ -107 +115 @@
         std::string shortcut_;         //!< Shortcut of the argument. @see getShortcut().
         std::string usageInformation_; //!< Tells about the usage of this parameter
+
+        MultiType value_;            //!< The actual value
+        MultiType defaultValue_;     //!< Default value. Should not be changed.
     };
-
-
-    /**
-    @brief
-        Container class for a command line argument of type T.
-        
-        Whenever you want to have an option specified by a command line switch,
-        you need to first define it with SetCommandLineArgument(name, defaultValue).
-        It is then added to a map and possibly changed when the command line is being parsed.
-        If the option was not given, you can detect this by asking hasDefaultValue().
-        
-        There is a possibility to define a short cut so you can write "-p 20" instead of "--port 20".
-        Note the difference between "-" and "--"!
-        Also, there is no restriction to the number of strings you add after --name.
-        So "--startVector (2, 4, 5)" is perfectly legal.
-
-        Retrieving an argument is possible with the getCommandLineArgument function of the
-        CommandLine class. It is a Singleton, but the public interface is static.
-    */
-    template <class T>
-    class CommandLineArgument : public BaseCommandLineArgument
-    {
-        // Only let CommandLine change the value.
-        friend class CommandLine;
-
-    public:
-        //! Returns the actual value of the argument. Can be equal to default value.
-        T getValue() const { return value_; }
-        //! Returns the given default value as type T.
-        T getDefaultValue() const { return defaultValue_; }
-
-    private:
-        //! Constructor initialises both value_ and defaultValue_ with defaultValue.
-        CommandLineArgument(const std::string& name, const T& defaultValue)
-            : BaseCommandLineArgument(name)
-            , value_(defaultValue)
-            , defaultValue_(defaultValue)
-        { }
-
-        virtual void parse(const std::string& value);
-
-        T value_;            //!< The actual value
-        T defaultValue_;     //!< Default value. Should not be changed.
-    };
-
-    /**
-    @brief
-        Parses a value string for a command line argument.
-        It simply uses convertValue(Output, Input) to do that.
-    */
-    template <class T>
-    void CommandLineArgument<T>::parse(const std::string& value)
-    {
-        if (convertValue(&this->value_, value))
-        {
-            this->bHasDefaultValue_ = false;
-        }
-        else
-        {
-            ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
-        }
-    }
-
-    /**
-    @brief
-        Parses a value string for a command line argument.
-        It simply uses convertValue(Output, Input) to do that.
-        This is a template specialisation for bool type. That is necessary
-        so that you can have simple command line switches.
-    */
-    template <>
-    inline void CommandLineArgument<bool>::parse(const std::string& value)
-    {
-        if (convertValue(&this->value_, value))
-        {
-            this->bHasDefaultValue_ = false;
-        }
-        else if (value == "")
-        {
-            this->bHasDefaultValue_ = false;
-            this->value_ = true;
-        }
-        else
-        {
-            ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
-        }
-    }
 
 
@@ -215 +139 @@
         static std::string getUsageInformation();
 
-        template <class T>
-        static const CommandLineArgument<T>* getArgument(const std::string& name);
+        static const CommandLineArgument* getArgument(const std::string& name);
         //! Writes the argument value in the given parameter.
         template <class T>
         static void getValue(const std::string& name, T* value)
-        { *value = getArgument<T>(name)->getValue(); }
+        { *value = (T)(getArgument(name)->getValue()); }
+        static MultiType getValue(const std::string& name)
+        { return getArgument(name)->getValue(); }
         template <class T>
-        static BaseCommandLineArgument& addArgument(const std::string& name, T defaultValue);
+        static CommandLineArgument& addArgument(const std::string& name, T defaultValue);
+
+        static bool existsArgument(const std::string& name)
+        {
+            std::map<std::string, CommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
+            return !(it == _getInstance().cmdLineArgs_.end());
+        }
+
 
     private:
@@ -237 +169 @@
         void checkShortcut(const std::string& shortcut, const std::string& value);
 
-        template <class T>
-        BaseCommandLineArgument* createArg(const std::string& name, T defaultValue, Int2Type<0> isString);
-        template <class T>
-        BaseCommandLineArgument* createArg(const std::string& name, T defaultValue, Int2Type<1> isString);
-
         /**
-            Tells whether we parse the first expression. The CommmandLineArguments are added before main().
+            Tells whether we parsed for the first time. The CommmandLineArguments are added before main().
             So when we call parse() the first time, we need to create a map with all shortcuts since these
             get added after addCommandLineArgument().
@@ -250 +177 @@
 
         //! Holds all pointers to the arguments and serves as a search map by name.
-        std::map<std::string, BaseCommandLineArgument*> cmdLineArgs_;
+        std::map<std::string, CommandLineArgument*> cmdLineArgs_;
         //! Search map by chortcut for the arguments.
-        std::map<std::string, BaseCommandLineArgument*> cmdLineArgsShortcut_;
+        std::map<std::string, CommandLineArgument*> cmdLineArgsShortcut_;
     };
 
-
-    /**
-    @brief
-        Retrieves a CommandLineArgument.
-        The method throws an exception if 'name' was not found or the value could not be converted.
-    @note
-        You shold of course not call this method before the command line has been parsed.
-    */
-    template <class T>
-    const CommandLineArgument<T>* CommandLine::getArgument(const std::string& name)
-    {
-        std::map<std::string, BaseCommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
-        if (it == _getInstance().cmdLineArgs_.end())
-        {
-            ThrowException(Argument, "Could find command line argument '" + name + "'.");
-        }
-        else
-        {
-            CommandLineArgument<T>* arg = dynamic_cast<CommandLineArgument<T>* >(it->second);
-            if (arg == 0)
-            {
-                ThrowException(Argument, "Could not convert command line argument value to requested type. " \
-                    "You should use exactly the same type as predefined.");
-            }
-            else
-            {
-                return arg;
-            }
-        }
+    template <>
+    inline void CommandLine::getValue<std::string>(const std::string& name, std::string* value)
+    {
+        *value = (std::string)(getArgument(name)->getValue().getString());
     }
 
@@ -294 +196 @@
     @param defaultValue
         Default value that is used when argument was not given.
-    @note
-        In order to store char* strings as std::string too, there's
-        little bit of template programming involved:
-        StaticConversions::exists determines whether T converts to std::string.
-        Int2Type<int> is then used to call the right function. One returns
-        a CommandLineArgument<T> and the other CommandLineArgument<std::string>.
     */
     template <class T>
-    BaseCommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
-    {
-        std::map<std::string, BaseCommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
-        OrxAssert(it == _getInstance().cmdLineArgs_.end(),
+    CommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
+    {
+        OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
 
-        return *(_getInstance().cmdLineArgs_[name] = 
-            _getInstance().createArg(name, defaultValue, Int2Type<StaticConversion<T, std::string>::exists>()));
-    }
-
-    /**
-        Returns a new CommandLineArgument<T>.
-    */
-    template <class T>
-    BaseCommandLineArgument* CommandLine::createArg(const std::string& name, T defaultValue, Int2Type<0> isPrime)
-    {
-        return new CommandLineArgument<T>(name, defaultValue);
-    }
-
-    /**
-        Returns a new CommandLineArgument<std::string>.
-    */
-    template <class T>
-    BaseCommandLineArgument* CommandLine::createArg(const std::string& name, T defaultValue, Int2Type<1> isPrime)
-    {
-        return new CommandLineArgument<std::string>(name, defaultValue);
+        return *(_getInstance().cmdLineArgs_[name] = new CommandLineArgument(name, defaultValue));
     }
 }