command_line.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 * 
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_COMMAND_LINE
#define GEOGRAM_BASIC_COMMAND_LINE
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/string.h>
#include <geogram/basic/assert.h>
 
namespace GEO {
 
    namespace CmdLine {
 
        void GEOGRAM_API initialize();
 
        void GEOGRAM_API terminate();
 
 
        void GEOGRAM_API set_config_file_name(
            const std::string& filename,
            bool auto_create_args = false
        );
 
        bool GEOGRAM_API config_file_loaded();
        
        std::string GEOGRAM_API get_config_file_name();
 
        void GEOGRAM_API load_config(
            const std::string& filename, const std::string& program_name
        );
        
        enum ArgType {
            ARG_UNDEFINED = 0,
            ARG_INT = 1,
            ARG_DOUBLE = 2,
            ARG_STRING = 4,
            ARG_BOOL = 8,
            ARG_PERCENT = 16
        };
 
        enum ArgFlags {
            ARG_FLAGS_DEFAULT = 0,
            ARG_ADVANCED = 1
        };
 
        void GEOGRAM_API declare_arg_group(
            const std::string& name,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        );
 
        void GEOGRAM_API declare_arg(
            const std::string& name,
            ArgType type,
            const std::string& default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        );
 
        ArgType GEOGRAM_API get_arg_type(const std::string& name);
 
        bool GEOGRAM_API arg_is_declared(const std::string& name);
 
        inline void declare_arg(
            const std::string& name,
            const std::string& default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_STRING, default_value,
                description, flags
            );
        }
 
        inline void declare_arg(
            const std::string& name,
            const char* default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_STRING, default_value,
                description, flags
            );
        }
 
        inline void declare_arg(
            const std::string& name,
            int default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_INT, String::to_string(default_value),
                description, flags
            );
        }
 
        inline void declare_arg(
            const std::string& name,
            double default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_DOUBLE, String::to_string(default_value),
                description, flags
            );
        }
 
        inline void declare_arg(
            const std::string& name,
            bool default_value,
            const std::string& description,
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_BOOL, default_value ? "true" : "false",
                description, flags
            );
        }
 
        inline void declare_arg_percent(
            const std::string& name,
            double default_value,
            const std::string& description = "...",
            ArgFlags flags = ARG_FLAGS_DEFAULT
        ) {
            declare_arg(
                name, ARG_PERCENT, String::to_string(default_value) + "%",
                description, flags
            );
        }
 
        bool GEOGRAM_API parse(
            int argc, char** argv, std::vector<std::string>& unparsed_args,
            const std::string& additional_arg_specs = ""
        );
 
        bool GEOGRAM_API parse(
            int argc, char** argv
        );
 
        int GEOGRAM_API argc();
 
        
        typedef char** charptrptr; // Need to do that else the compiler thinks
                                   // that GEOGRAM_API qualifies the ptr instead
                                   // of the function.
        
        charptrptr GEOGRAM_API argv();
        
        void GEOGRAM_API show_usage(
            const std::string& additional_args = "",
            bool advanced = false
        );
 
        std::string GEOGRAM_API get_arg(const std::string& name);
 
        int GEOGRAM_API get_arg_int(const std::string& name);
 
        unsigned int GEOGRAM_API get_arg_uint(const std::string& name);
 
        double GEOGRAM_API get_arg_double(const std::string& name);
 
        double GEOGRAM_API get_arg_percent(
            const std::string& name, double reference
        );
 
        bool GEOGRAM_API get_arg_bool(const std::string& name);
 
        bool GEOGRAM_API set_arg(
            const std::string& name, const std::string& value
        );
 
        inline bool set_arg(const std::string& name, const char* value) {
            return set_arg(name, std::string(value));
        }
 
        void GEOGRAM_API set_arg(const std::string& name, Numeric::int32 value);
 
        /*
         * \brief Sets an argument value from an integer
         * \details This replaces the value of argument \p name by the given
         * integer \p value. If the declared type of the argument is not
         * compatible with an integer then the function aborts (compatible
         * argument types are: int, double or string). If the argument does
         * not exist, it is added as a new argument of undefined type.
         * \param[in] name the argument name
         * \param[in] value the new value as an integer
         */
        void GEOGRAM_API set_arg(
            const std::string& name, Numeric::uint32 value
        );
 
        /*
         * \brief Sets an argument value from an integer
         * \details This replaces the value of argument \p name by the given
         * integer \p value. If the declared type of the argument is not
         * compatible with an integer then the function aborts (compatible
         * argument types are: int, double or string). If the argument does
         * not exist, it is added as a new argument of undefined type.
         * \param[in] name the argument name
         * \param[in] value the new value as an integer
         */
        void GEOGRAM_API set_arg(const std::string& name, Numeric::int64 value);
 
        /*
         * \brief Sets an argument value from an integer
         * \details This replaces the value of argument \p name by the given
         * integer \p value. If the declared type of the argument is not
         * compatible with an integer then the function aborts (compatible
         * argument types are: int, double or string). If the argument does
         * not exist, it is added as a new argument of undefined type.
         * \param[in] name the argument name
         * \param[in] value the new value as an integer
         */
        void GEOGRAM_API set_arg(
            const std::string& name, Numeric::uint64 value
        );
        
        void GEOGRAM_API set_arg(const std::string& name, double value);
 
        void GEOGRAM_API set_arg(const std::string& name, bool value);
 
        void GEOGRAM_API set_arg_percent(const std::string& name, double value);
 
        /********************************************************************/
 
        void GEOGRAM_API get_args(std::vector<std::string>& args);
 
        index_t GEOGRAM_API ui_terminal_width();
 
        void GEOGRAM_API ui_separator(
            const std::string& title,
            const std::string& short_title = ""
        );
 
        void GEOGRAM_API ui_separator();
 
        void GEOGRAM_API ui_close_separator();
 
        void GEOGRAM_API ui_message(
            const std::string& message,
            index_t wrap_margin
        );
 
        void GEOGRAM_API ui_message(
            const std::string& message
        );
 
        void GEOGRAM_API ui_clear_line();
 
        void GEOGRAM_API ui_progress(
            const std::string& task_name, index_t val,
            index_t percent, bool clear = true
        );
 
        void GEOGRAM_API ui_progress_time(
            const std::string& task_name,
            double elapsed, bool clear = true
        );
 
        void GEOGRAM_API ui_progress_canceled(
            const std::string& task_name,
            double elapsed, index_t percent, bool clear = true
        );
 
        std::string GEOGRAM_API ui_feature(
            const std::string& feature, bool show = true
        );
    }
}
 
 
#ifdef GEO_OS_ANDROID
struct android_app;
 
namespace GEO {
    namespace CmdLine {
        void GEOGRAM_API set_android_app(android_app* app);
 
        android_app* GEOGRAM_API get_android_app();
    }
}
 
#endif
 
 
#endif