application.hh

Go to the documentation of this file.

/*
 * application.hh
 *
 *  Created on: Jul 20, 2018
 *      Author: N.S. Oblath
 */

#ifndef SCARAB_APPLICATION_HH_
#define SCARAB_APPLICATION_HH_

#include "CLI11.hpp"

#include "member_variables.hh"
#include "param_helpers.hh"
#include "version_semantic.hh"

namespace scarab
{
    typedef CLI::App app;

    class version_semantic;

    class main_app;

    class SCARAB_API config_decorator
    {
        public:
            config_decorator( main_app* a_main, app* a_this_app );
            config_decorator( const config_decorator& ) = delete;
            config_decorator( config_decorator&& ) = delete;
            virtual ~config_decorator();

            config_decorator& operator=( const config_decorator& ) = delete;
            config_decorator& operator=( config_decorator&& ) = delete;

            main_app* main() const;
            app* this_app() const;

            config_decorator* add_config_subcommand( std::string a_subcommand_name, std::string a_description="" );

            template< typename T, CLI::enable_if_t< ! CLI::is_vector<T>::value, CLI::detail::enabler > = CLI::detail::dummy >
            CLI::Option* add_config_option( std::string a_name,
                                            std::string a_master_config_addr,
                                            std::string a_description = "" );

            template< typename T, CLI::enable_if_t< ! CLI::is_vector<T>::value, CLI::detail::enabler > = CLI::detail::dummy >
            CLI::Option* add_config_multi_option( std::string a_name,
                                                  std::string a_master_config_addr,
                                                  std::string a_description = "" );

            template< typename T, CLI::enable_if_t< std::is_integral<T>::value && ! CLI::is_bool<T>::value, CLI::detail::enabler > = CLI::detail::dummy >
            CLI::Option* add_config_flag( std::string a_name,
                                          std::string a_master_config_addr,
                                          std::string a_description = "" );

            template< typename T, CLI::enable_if_t< CLI::is_bool<T>::value, CLI::detail::enabler > = CLI::detail::dummy >
            CLI::Option* add_config_flag( std::string a_name,
                                          std::string a_master_config_addr,
                                          std::string a_description = "" );

        public:
            // these structs provide a type erasure mechanism that:
            //  - holds the actual value provided on the CL, and
            //  - adds the value to the f_app_options, and then to the global config, from the pre_callback function
            struct app_option_holder
            {
                virtual void add_to_app_options( param_node& a_app_options ) = 0;
                CLI::Option* f_option;
                std::string f_master_config_addr;
                virtual ~app_option_holder() {}
            };

            template< typename T >
            struct app_option_holder_typed : app_option_holder
            {
                void add_to_app_options( param_node& a_app_options )
                {
                    if( ! (*f_option) ) return;
                    param_ptr_t t_new_config_ptr = simple_parser::parse_address(
                            f_master_config_addr,
                            param_ptr_t( new param_value(f_value) ) ); // throws scarab::error if top-level param object is not a node
                    a_app_options.merge( t_new_config_ptr->as_node() );
                    return;
                }
                T f_value;
                virtual ~app_option_holder_typed() {}
            };

            template< typename T >
            struct app_option_holder_vector_typed : app_option_holder
            {
                void add_to_app_options( param_node& a_app_options )
                {
                    if( ! (*f_option) ) return;
                    param_array t_array;
                    std::for_each( f_values.begin(), f_values.end(), [&t_array]( T a_value ){ t_array.push_back( a_value ); } );
                    param_ptr_t t_new_config_ptr = simple_parser::parse_address(
                            f_master_config_addr,
                            param_ptr_t( new param_array(std::move(t_array)) ) ); // throws scarab::error if top-level param object is not a node
                    a_app_options.merge( t_new_config_ptr->as_node() );
                    return;
                }
                std::vector< T > f_values;
                virtual ~app_option_holder_vector_typed() {}
            };

            struct app_option_holder_bool_flag : app_option_holder
            {
                void add_to_app_options( param_node& a_app_options )
                {
                    if( ! (*f_option) ) return;
                    param_ptr_t t_new_config_ptr = simple_parser::parse_address(
                            f_master_config_addr,
                            param_ptr_t( new param_value(*f_option) ) ); // throws scarab::error if top-level param object is not a node
                    a_app_options.merge( t_new_config_ptr->as_node() );
                    return;
                }
                virtual ~app_option_holder_bool_flag() {}
            };

        protected:
            main_app* f_main;
            app* f_this;

            // config_decorator owns the decorators of subcommands just like app owns the apps of subcommands
            using conf_dec_ptr_t = std::unique_ptr< config_decorator >;
            std::vector< conf_dec_ptr_t > f_subcommand_decorators;
    };


    class SCARAB_API main_app : public config_decorator, public app
    {
        public:
            main_app();
            virtual ~main_app();

        public:
            virtual void pre_callback();

            // Functions to perform each configuration stage
            virtual void do_config_stage_1();
            virtual void do_config_stage_2();
            virtual void do_config_stage_3();
            virtual void do_config_stage_4();

            void set_version( scarab::version_semantic_ptr_t a_ver );

            mv_referrable( param_node, master_config );

            // configuration stage 1
            mv_referrable( param_node, default_config );

            // configuration stage 2
            mv_referrable_const( std::string, config_filename );
            mv_accessible( unsigned, global_verbosity );

            // configuration stage 3
            mv_referrable( param_node, nonoption_kw_args );
            mv_referrable( param_array, nonoption_ord_args );

            // configuration stage 4
            mv_referrable( param_node, app_options );

            mv_referrable( std::vector< std::shared_ptr< app_option_holder > >, app_option_holders );
    };


    template< typename T, CLI::enable_if_t< ! CLI::is_vector<T>::value, CLI::detail::enabler > >
    CLI::Option* config_decorator::add_config_option( std::string a_name,
                                                      std::string a_master_config_addr,
                                                      std::string a_description )
    {
        auto t_opt_holder_ptr = std::make_shared< app_option_holder_typed<T> >();
        t_opt_holder_ptr->f_option = f_this->add_option( a_name, t_opt_holder_ptr->f_value, a_description ); // throws CLI::OptionAlreadyAdded if the option's already there
        t_opt_holder_ptr->f_master_config_addr = a_master_config_addr;
        f_main->app_option_holders().push_back( t_opt_holder_ptr );
        return t_opt_holder_ptr->f_option;
    }

    template< typename T, CLI::enable_if_t< ! CLI::is_vector<T>::value, CLI::detail::enabler > >
    CLI::Option* config_decorator::add_config_multi_option( std::string a_name,
                                                            std::string a_master_config_addr,
                                                            std::string a_description )
    {
        auto t_opt_holder_ptr = std::make_shared< app_option_holder_vector_typed<T> >();
        t_opt_holder_ptr->f_option = f_this->add_option( a_name, t_opt_holder_ptr->f_values, a_description ); // throws CLI::OptionAlreadyAdded if the option's already there
        t_opt_holder_ptr->f_master_config_addr = a_master_config_addr;
        f_main->app_option_holders().push_back( t_opt_holder_ptr );
        return t_opt_holder_ptr->f_option;
    }

    template< typename T, CLI::enable_if_t< std::is_integral<T>::value && ! CLI::is_bool<T>::value, CLI::detail::enabler > >
    CLI::Option* config_decorator::add_config_flag( std::string a_name,
                                                    std::string a_master_config_addr,
                                                    std::string a_description )
    {
        auto t_opt_holder_ptr = std::make_shared< app_option_holder_typed<T> >();
        t_opt_holder_ptr->f_option = f_this->add_flag( a_name, t_opt_holder_ptr->f_value, a_description ); // throws CLI::OptionAlreadyAdded if the option's already there
        t_opt_holder_ptr->f_master_config_addr = a_master_config_addr;
        f_main->app_option_holders().push_back( t_opt_holder_ptr );
        return t_opt_holder_ptr->f_option;
    }

    template< typename T, CLI::enable_if_t< CLI::is_bool<T>::value, CLI::detail::enabler > >
    CLI::Option* config_decorator::add_config_flag( std::string a_name,
                                                    std::string a_master_config_addr,
                                                    std::string a_description )
    {
        auto t_opt_holder_ptr = std::make_shared< app_option_holder_bool_flag >();
        t_opt_holder_ptr->f_option = f_this->add_flag( a_name, a_description ); // throws CLI::OptionAlreadyAdded if the option's already there
        t_opt_holder_ptr->f_master_config_addr = a_master_config_addr;
        f_main->app_option_holders().push_back( t_opt_holder_ptr );
        return t_opt_holder_ptr->f_option;
    }

    inline app* config_decorator::this_app() const
    {
        return f_this;
    }

    inline main_app* config_decorator::main() const
    {
        return f_main;
    }

} /* namespace scarab */

#endif /* SCARAB_APPLICATION_HH_ */