App.h

/***************************************************************************
 * \file App.h
 *
 * \brief Defines basic application-level constructs.
 *
 * \author DA
 * \copyright Copyright (c) 2015-2021 CyberRadio Solutions, Inc.
 *
 */
 
#ifndef INCLUDED_LIBCYBERRADIO_APP_H
#define INCLUDED_LIBCYBERRADIO_APP_H
 
#include <string>
#include <map>
#include <getopt.h>
#include "LibCyberRadio/Common/BasicList.h"
 

namespace LibCyberRadio
{
    class AppOption
    {
        public:
            AppOption();
            AppOption(const std::string& shortName, const std::string& longName,
                    int valueType, void *valuePtr,
                    const std::string& helpArgName, const std::string& helpText,
                    bool showDefault);
            AppOption(const AppOption& opt);
            virtual AppOption& operator=(const AppOption& opt);
            virtual ~AppOption();
 
        public:
            std::string shortName;
            std::string longName;
            int valueType;
            void *valuePtr;
            std::string helpArgName;
            std::string helpText;
            bool showDefault;
 
        public:
            static int TYPE_NONE;
            static int TYPE_INTEGER;
            static int TYPE_FLOAT;
            static int TYPE_DOUBLE;
            static int TYPE_STRING;
            static int TYPE_BOOLEAN;
            static int TYPE_BOOLEAN_SET_TRUE;
            static int TYPE_BOOLEAN_SET_FALSE;
    };
 

    typedef BASIC_LIST_CONTAINER<AppOption> AppOptionList;
 

    class AppHelpTextFormatter
    {
        public:
            AppHelpTextFormatter(int displayWidth = 75);
            virtual ~AppHelpTextFormatter();
            virtual void addPreOptionText(const std::string& text);
            virtual void addOptionText(const std::string& option, const std::string& text);
            virtual void addPostOptionText(const std::string& text);
            virtual std::string getFormattedText();
 
        protected:
            // Wraps the given text to the specified width (in characters), applying
            // the given hanging indent (in characters) to each line after the first.
            virtual std::string wordWrappedText(const std::string& text, int width,
                    int hangingIndent);
 
        protected:
            BasicStringList _preOptionText;
            BasicStringList _options;
            BasicStringList _optionText;
            BasicStringList _postOptionText;
            int _maxOptionWidth;
            int _displayWidth;
    };
 

    class AppOptionParser
    {
        public:
            AppOptionParser();
            virtual ~AppOptionParser();
            void allowUnknownOption(bool allow = true);
            void setDescription(const std::string& description);
            void setDisplayWidth(int displayWidth = 75);
            void setEpilogText(const std::string& epilogText);
            void setExecutable(const std::string& executable);
            void setUnparsedArgText(const std::string& unparsedArgText);
            void setVersion(const std::string& version);
            virtual void addOption(const AppOption& opt);
            virtual void addOption(const std::string& shortName, const std::string& longName,
                    int valueType, void *valuePtr,
                    const std::string& helpArgName, const std::string& helpText,
                    bool showDefault);
            virtual int parse(int argc, char **argv);
 
        protected:
            // Prints usage information.
            virtual void printUsage();
            // Determines whether an option should have an argument based on its type.
            virtual int optionValueArg(int valueType);
            // Gets the default value for a given option, as a string.
            virtual std::string getDefault(const AppOption& opt);
            // Dispatch function for handling configured options.
            virtual int handleOptionReturn(int opt, const std::string& optarg);
            // Option type handler functions.
            // -- AppOptionValueType::NONE
            virtual int handleOptionNone(int optindex, const std::string& optarg);
            // -- AppOptionValueType::INTEGER
            virtual int handleOptionInt(int optindex, const std::string& optarg);
            // -- AppOptionValueType::FLOAT
            virtual int handleOptionFloat(int optindex, const std::string& optarg);
            // -- AppOptionValueType::DOUBLE
            virtual int handleOptionDouble(int optindex, const std::string& optarg);
            // -- AppOptionValueType::STRING
            virtual int handleOptionString(int optindex, const std::string& optarg);
            // -- AppOptionValueType::BOOLEAN
            virtual int handleOptionBool(int optindex, const std::string& optarg);
            // -- AppOptionValueType::BOOLEAN_SET_TRUE
            virtual int handleOptionBooleanSetTrue(int optindex, const std::string& optarg);
            // -- AppOptionValueType::BOOLEAN_SET_FALSE
            virtual int handleOptionBooleanSetFalse(int optindex, const std::string& optarg);
 
        public:
            BasicStringList unparsedArgs;
 
        protected:
            AppOptionList _optionList;
            std::string _description;
            std::string _version;
            std::string _executable;
            std::string _unparsedArgText;
            std::string _epilogText;
            bool _allowUnknownOption;
            int _displayWidth;
            typedef int (AppOptionParser::*OptionHelper)(int optindex, const std::string& optarg);
            std::map<int, OptionHelper> _optionHelpers;
    };
 

    class App
    {
        public:
            App();
            virtual ~App() { };
            virtual int run(int argc, char *argv[]);
 
        protected:
            virtual void defineOptions(const char *argv0);
            // .  The return value will
            // be passed up to the host operating system as a return code.
            virtual int mainLoop();
            // Parses command-line options.
            virtual int parseCommandLine(int argc, char *argv[]);
 
        public:
            std::string description;
            std::string version;
 
        protected:
            AppOptionParser _optParser;
    };
 
} /* namespace LibCyberRadio */
 
#endif /* INCLUDED_LIBCYBERRADIO_APP_H */