ArgumentParser.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3.0 of the License, or (at your option)
* any later version.
*
* This library 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 Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @author Maxim Serebrennik
*/

#pragma once

#include <trUtil/Export.h>

#include <trUtil/ApplicationUsage.h>
#include <trUtil/ArgumentParser.h>

#include <osg/ArgumentParser>
#include <osg/ref_ptr>

#include <memory>
#include <map>

namespace trUtil
{
    class TR_UTIL_EXPORT ArgumentParser
    {
    public:

        enum class ErrorSeverity
        {
            BENIGN = osg::ArgumentParser::ErrorSeverity::BENIGN,
            CRITICAL = osg::ArgumentParser::ErrorSeverity::CRITICAL
        };

        using ErrorMessageMap = std::map<std::string, ErrorSeverity>;

        class TR_UTIL_EXPORT Parameter
        {
        public:

            Parameter(bool& value);

            Parameter(float& value);

            Parameter(double& value);

            Parameter(int& value);

            Parameter(unsigned int& value);

            Parameter(std::string& value);

            Parameter(const Parameter& param);

            ~Parameter();

            Parameter& operator = (const Parameter& param);

            bool Valid(const char* str) const;

            bool Assign(const char* str);

            operator osg::ArgumentParser::Parameter() const;

            operator osg::ArgumentParser::Parameter& ();

            operator const osg::ArgumentParser::Parameter& () const;

            operator osg::ArgumentParser::Parameter* ();


        protected:

            osg::ArgumentParser::Parameter* mParam;
        };

        ArgumentParser(int* argc, char **argv);

        ~ArgumentParser();

        osg::ArgumentParser& GetOSGArgumentParser();

        const osg::ArgumentParser& GetOSGArgumentParser() const;

        bool IsOption(const char* str) const;

        bool IsString(const char* str) const;

        bool IsNumber(const char* str) const;

        bool IsBool(const char* str) const;

        void SetApplicationUsage(ApplicationUsage* usage);

        ApplicationUsage* GetApplicationUsage();

        const ApplicationUsage* GetApplicationUsage() const;

        int& GetArgc();

        char** GetArgv();

        std::string GetApplicationName() const;

        int Find(const std::string& str) const;

        bool IsOption(int pos) const;

        bool IsString(int pos) const;

        bool IsNumber(int pos) const;

        bool ContainsOptions() const;

        void Remove(int pos, int num = 1);

        bool Match(int pos, const std::string& str) const;

        bool Read(const std::string& str);

        bool Read(const std::string& str, Parameter value1);

        bool Read(const std::string& str, Parameter value1, Parameter value2);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6, Parameter value7);

        bool Read(const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6, Parameter value7, Parameter value8);

        bool Read(int pos, const std::string& str);

        bool Read(int pos, const std::string& str, Parameter value1);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6, Parameter value7);

        bool Read(int pos, const std::string& str, Parameter value1, Parameter value2, Parameter value3, Parameter value4, Parameter value5, Parameter value6, Parameter value7, Parameter value8);

        bool Errors(ErrorSeverity severity = ErrorSeverity::BENIGN) const;

        void ReportError(const std::string& message, ErrorSeverity severity = ErrorSeverity::CRITICAL);

        void ReportRemainingOptionsAsUnrecognized(ErrorSeverity severity = ErrorSeverity::BENIGN);

        void WriteErrorMessages(std::ostream& output, ErrorSeverity severity = ErrorSeverity::BENIGN);

        ApplicationUsage::Type ReadHelpType();

        void SetApplicationName(const std::string& name);

        void SetDescription(const std::string& desc);

        const std::string& GetDescription() const;

        void AddUsageExplanation(ApplicationUsage::Type type, const std::string& option, const std::string& explanation);

        void SetCommandLineUsage(const std::string& explanation);

        const std::string& GetCommandLineUsage() const;

        void AddCommandLineOption(const std::string& option, const std::string& explanation, const std::string &defaultValue = "");

        void SetCommandLineOptions(const ApplicationUsage::UsageMap& usageMap);

        const ApplicationUsage::UsageMap& GetCommandLineOptions() const;

        void SetCommandLineOptionsDefaults(const ApplicationUsage::UsageMap& usageMap);

        const ApplicationUsage::UsageMap& GetCommandLineOptionsDefaults() const;

        void AddEnvironmentalVariable(const std::string& option, const std::string& explanation, const std::string& defaultValue = "");

        void SetEnvironmentalVariables(const ApplicationUsage::UsageMap& usageMap);

        const ApplicationUsage::UsageMap& GetEnvironmentalVariables() const;

        void SetEnvironmentalVariablesDefaults(const ApplicationUsage::UsageMap& usageMap);

        const ApplicationUsage::UsageMap& GetEnvironmentalVariablesDefaults() const;

        void AddKeyboardMouseBinding(const std::string& prefix, int key, const std::string& explanation);

        void AddKeyboardMouseBinding(int key, const std::string& explanation);

        void AddKeyboardMouseBinding(const std::string& option, const std::string& explanation);

        void SetKeyboardMouseBindings(const ApplicationUsage::UsageMap& usageMap);

        const ApplicationUsage::UsageMap& GetKeyboardMouseBindings() const;

        void GetFormattedString(std::string& str, const ApplicationUsage::UsageMap& usageMap, unsigned int widthOfOutput = 80, bool showDefaults = false, const ApplicationUsage::UsageMap& usageMapDef = ApplicationUsage::UsageMap());

        void Write(std::ostream& output, const ApplicationUsage::UsageMap& usageMap, unsigned int widthOfOutput = 80, bool showDefaults = false, const ApplicationUsage::UsageMap& usageMapDef = ApplicationUsage::UsageMap());

        void Write(std::ostream& output, ApplicationUsage::Type type = ApplicationUsage::Type::COMMAND_LINE_OPTION, unsigned int widthOfOutput = 80, bool showDefaults = false);

        void WriteEnvironmentSettings(std::ostream& output);

    protected:

        std::unique_ptr<osg::ArgumentParser> mArgParser;
        std::unique_ptr<ApplicationUsage> mAppUsage;
    };
}