CommandLineParser.h

Go to the documentation of this file.

/*
 *   ORXONOX - the hottest 3D action shooter ever to exist
 *                    > www.orxonox.net <
 *
 *
 *   License notice:
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *   Author:
 *      Reto Grieder
 *   Co-authors:
 *      ...
 *
 */

#ifndef _CommandLine_H__
#define _CommandLine_H__

#include "core/CorePrereqs.h"

#include <fstream>
#include <map>
#include "util/OrxAssert.h"
#include "util/MultiType.h"
#include "util/Singleton.h"

namespace orxonox
{
    class _CoreExport CommandLineArgument
    {
        friend class CommandLineParser;

    public:
        CommandLineArgument(const std::string& name, const MultiType& defaultValue)
            : bHasDefaultValue_(true)
            , name_(name)
            , value_(defaultValue)
            , defaultValue_(defaultValue)
        { }
        ~CommandLineArgument() { }

        bool hasDefaultValue() const { return bHasDefaultValue_; }
        const std::string& getName() const { return name_; }

        const std::string& getShortcut() const { return shortcut_; }
        CommandLineArgument& shortcut(const std::string& shortcut)
        { this->shortcut_ = shortcut; return *this; }

        const std::string& getInformation() const { return this->usageInformation_; }
        CommandLineArgument& information(const std::string& usage)
        { this->usageInformation_ = usage; return *this; }

        const MultiType& getValue() const { return value_; }
        const MultiType& getDefaultValue() const { return defaultValue_; }

    private:
        // non-copyable:
        CommandLineArgument(const CommandLineArgument&) = delete;
        CommandLineArgument& operator=(const CommandLineArgument&) = delete;

        void parse(const std::string& value);

        bool bHasDefaultValue_;

    private:
        std::string name_;             
        std::string shortcut_;         
        std::string usageInformation_; 

        MultiType   value_;            
        MultiType   defaultValue_;     
    };


    class _CoreExport CommandLineParser : public Singleton<CommandLineParser>
    {
        friend class Singleton<CommandLineParser>;

    public:
        CommandLineParser() : bFirstTimeParse_(true) { }
        ~CommandLineParser();

        static void parse(const std::string& cmdLine)
        { getInstance()._parse(cmdLine); }

        static std::string getUsageInformation();

        static const CommandLineArgument* getArgument(const std::string& name);
        template <class T>
        static void getValue(const std::string& name, T* value)
        { *value = (T)(getArgument(name)->getValue()); }
        static const MultiType& getValue(const std::string& name)
        { return getArgument(name)->getValue(); }

        static void addArgument(CommandLineArgument* argument);
        static void removeArgument(CommandLineArgument* argument);

        static bool existsArgument(const std::string& name)
        {
            std::map<std::string, CommandLineArgument*>::const_iterator it = getInstance().cmdLineArgs_.find(name);
            return !(it == getInstance().cmdLineArgs_.end());
        }

        static void generateDoc(std::ofstream& file);

    private:
        CommandLineParser(const CommandLineParser& instance);

        void _parse(const std::string& cmdLine);
        void checkFullArgument(const std::string& name, const std::string& value);
        void checkShortcut(const std::string& shortcut, const std::string& value);

        bool bFirstTimeParse_;

        std::map<std::string, CommandLineArgument*> cmdLineArgs_;
        std::map<std::string, CommandLineArgument*> cmdLineArgsShortcut_;

        static CommandLineParser* singletonPtr_s;
    };

    template <>
    inline void CommandLineParser::getValue<std::string>(const std::string& name, std::string* value)
    {
        *value = getArgument(name)->getValue().get<std::string>();
    }
}

#endif /* _CommandLine_H__ */