dlib C++ Library - cmd_line_parser_check_1.h

    // Copyright (C) 2006  Davis E. King (davisking@users.sourceforge.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_CMD_LINE_PARSER_CHECk_1_
    #define DLIB_CMD_LINE_PARSER_CHECk_1_

    #include "cmd_line_parser_kernel_abstract.h"
    #include <sstream>
    #include <string>
    #include "../string.h"
    #include <vector>

    namespace dlib
    {

        template <
            typename clp_base
            >
        class cmd_line_parser_check_1 : public clp_base
        {

            /*!
                This extension doesn't add any state.

            !*/

        public:
            typedef typename clp_base::char_type char_type;
            typedef typename clp_base::string_type string_type;

        // ------------------------------------------------------------------------------------

            class cmd_line_check_error : public dlib::error
            {
                friend class cmd_line_parser_check_1;

                cmd_line_check_error(
                    error_type t,
                    const string_type& opt_,
                    const string_type& arg_
                ) :
                    dlib::error(t),
                    opt(opt_),
                    opt2(),
                    arg(arg_),
                    required_opts()
                { set_info_string(); }

                cmd_line_check_error(
                    error_type t,
                    const string_type& opt_,
                    const string_type& opt2_,
                    int  // this is just to make this constructor different from the one above
                ) :
                    dlib::error(t),
                    opt(opt_),
                    opt2(opt2_),
                    arg(),
                    required_opts()
                { set_info_string(); }

                cmd_line_check_error (
                    error_type t,
                    const string_type& opt_,
                    const std::vector<string_type>& vect
                ) :
                    dlib::error(t),
                    opt(opt_),
                    opt2(),
                    arg(),
                    required_opts(vect)
                { set_info_string(); }

                cmd_line_check_error(
                    error_type t,
                    const string_type& opt_
                ) :
                    dlib::error(t),
                    opt(opt_),
                    opt2(),
                    arg(),
                    required_opts()
                { set_info_string(); }

                ~cmd_line_check_error() throw() {}

                void set_info_string (
                )
                {
                    std::ostringstream sout;
                    switch (type)
                    {
                        case EINVALID_OPTION_ARG:
                            sout << "Command line error: '" << narrow(arg) << "' is not a valid argument to "
                                 << "the '" << narrow(opt) << "' option.";
                            break;
                        case EMISSING_REQUIRED_OPTION:
                            if (required_opts.size() == 1)
                            {
                                sout << "Command line error: The '" << narrow(opt) << "' option requires the presence of "
                                     << "the '" << required_opts[0] << "' option.";
                            }
                            else
                            {
                                sout << "Command line error: The '" << narrow(opt) << "' option requires the presence of "
                                     << "one of the following options: ";
                                for (unsigned long i = 0; i < required_opts.size(); ++i)
                                {
                                    if (i == required_opts.size()-2)
                                        sout << "'" << required_opts[i] << "' or ";
                                    else if (i == required_opts.size()-1)
                                        sout << "'" << required_opts[i] << "'.";
                                    else
                                        sout << "'" << required_opts[i] << "', ";
                                }
                            }
                            break;
                        case EINCOMPATIBLE_OPTIONS:
                            sout << "Command line error: The '" << narrow(opt) << "' and '" << narrow(opt2)
                                << "' options can not be given together on the command line.";
                            break;
                        case EMULTIPLE_OCCURANCES:
                            sout << "Command line error: The '" << narrow(opt) << "' option can only "
                                 << "be given on the command line once.";
                            break;
                        default:
                            sout << "Command line error.";
                            break;
                    }
                    const_cast<std::string&>(info) = wrap_string(sout.str(),0,0);
                }

            public:
                const string_type opt;
                const string_type opt2;
                const string_type arg;
                const std::vector<string_type> required_opts;
            };

        // ------------------------------------------------------------------------------------

            template <
                typename T
                >
            void check_option_arg_type (
                const string_type& option_name
            ) const;

            template <
                typename T
                >
            void check_option_arg_range (
                const string_type& option_name,
                const T& first,
                const T& last
            ) const;

            template <
                typename T,
                size_t length
                >
            void check_option_arg_range (
                const string_type& option_name,
                const T (&arg_set)[length]
            ) const;

            template <
                size_t length
                >
            void check_option_arg_range (
                const string_type& option_name,
                const char_type* (&arg_set)[length]
            ) const;

            template <
                size_t length
                >
            void check_incompatible_options (
                const char_type* (&option_set)[length]
            ) const;

            template <
                size_t length
                >
            void check_one_time_options (
                const char_type* (&option_set)[length]
            ) const;

            void check_incompatible_options (
                const string_type& option_name1,
                const string_type& option_name2
            ) const;

            template <
                size_t length
                >
            void check_sub_options (
                const string_type& parent_option,
                const char_type* (&sub_option_set)[length]
            ) const;

            template <
                size_t length
                >
            void check_sub_options (
                const char_type* (&parent_option_set)[length],
                const string_type& sub_option
            ) const;

            template <
                size_t parent_length,
                size_t sub_length
                >
            void check_sub_options (
                const char_type* (&parent_option_set)[parent_length],
                const char_type* (&sub_option_set)[sub_length]
            ) const;
        };

        template <
            typename clp_base
            >
        inline void swap (
            cmd_line_parser_check_1<clp_base>& a,
            cmd_line_parser_check_1<clp_base>& b
        ) { a.swap(b); }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // member function definitions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template <typename T>
        void cmd_line_parser_check_1<clp_base>::
        check_option_arg_type (
            const string_type& option_name
        ) const
        {
            try
            {
                const typename clp_base::option_type& opt = option(option_name);
                const unsigned long number_of_arguments = opt.number_of_arguments();
                const unsigned long count = opt.count();
                for (unsigned long i = 0; i < number_of_arguments; ++i)
                {
                    for (unsigned long j = 0; j < count; ++j)
                    {
                        string_cast<T>(opt.argument(i,j));
                    }
                }
            }
            catch (string_cast_error& e)
            {
                throw cmd_line_check_error(EINVALID_OPTION_ARG,option_name,e.info);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template <typename T>
        void cmd_line_parser_check_1<clp_base>::
        check_option_arg_range (
            const string_type& option_name,
            const T& first,
            const T& last
        ) const
        {
            try
            {
                const typename clp_base::option_type& opt = option(option_name);
                const unsigned long number_of_arguments = opt.number_of_arguments();
                const unsigned long count = opt.count();
                for (unsigned long i = 0; i < number_of_arguments; ++i)
                {
                    for (unsigned long j = 0; j < count; ++j)
                    {
                        T temp(string_cast<T>(opt.argument(i,j)));
                        if (temp < first || last < temp)
                        {
                            throw cmd_line_check_error(
                                EINVALID_OPTION_ARG,
                                option_name,
                                opt.argument(i,j)
                            );
                        }
                    }
                }
            }
            catch (string_cast_error& e)
            {
                throw cmd_line_check_error(EINVALID_OPTION_ARG,option_name,e.info);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < typename T, size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_option_arg_range (
            const string_type& option_name,
            const T (&arg_set)[length]
        ) const
        {
            try
            {
                const typename clp_base::option_type& opt = option(option_name);
                const unsigned long number_of_arguments = opt.number_of_arguments();
                const unsigned long count = opt.count();
                for (unsigned long i = 0; i < number_of_arguments; ++i)
                {
                    for (unsigned long j = 0; j < count; ++j)
                    {
                        T temp(string_cast<T>(opt.argument(i,j)));
                        size_t k = 0;
                        for (; k < length; ++k)
                        {
                            if (arg_set[k] == temp)
                                break;
                        }
                        if (k == length)
                        {
                            throw cmd_line_check_error(
                                EINVALID_OPTION_ARG,
                                option_name,
                                opt.argument(i,j)
                            );
                        }
                    }
                }
            }
            catch (string_cast_error& e)
            {
                throw cmd_line_check_error(EINVALID_OPTION_ARG,option_name,e.info);
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_option_arg_range (
            const string_type& option_name,
            const char_type* (&arg_set)[length]
        ) const
        {
            const typename clp_base::option_type& opt = option(option_name);
            const unsigned long number_of_arguments = opt.number_of_arguments();
            const unsigned long count = opt.count();
            for (unsigned long i = 0; i < number_of_arguments; ++i)
            {
                for (unsigned long j = 0; j < count; ++j)
                {
                    size_t k = 0;
                    for (; k < length; ++k)
                    {
                        if (arg_set[k] == opt.argument(i,j))
                            break;
                    }
                    if (k == length)
                    {
                        throw cmd_line_check_error(
                            EINVALID_OPTION_ARG,
                            option_name,
                            opt.argument(i,j)
                        );
                    }
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_incompatible_options (
            const char_type* (&option_set)[length]
        ) const
        {
            for (size_t i = 0; i < length; ++i)
            {
                for (size_t j = i+1; j < length; ++j)
                {
                    if (option(option_set[i]).count() > 0 &&
                        option(option_set[j]).count() > 0 )
                    {
                        throw cmd_line_check_error(
                            EINCOMPATIBLE_OPTIONS,
                            option_set[i],
                            option_set[j],
                            0 // this argument has no meaning and is only here to make this
                            // call different from the other constructor
                        );
                    }
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        void cmd_line_parser_check_1<clp_base>::
        check_incompatible_options (
            const string_type& option_name1,
            const string_type& option_name2
        ) const
        {
            if (option(option_name1).count() > 0 &&
                option(option_name2).count() > 0 )
            {
                throw cmd_line_check_error(
                    EINCOMPATIBLE_OPTIONS,
                    option_name1,
                    option_name2,
                    0 // this argument has no meaning and is only here to make this
                    // call different from the other constructor
                );
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_sub_options (
            const string_type& parent_option,
            const char_type* (&sub_option_set)[length]
        ) const
        {
            if (option(parent_option).count() == 0)
            {
                size_t i = 0;
                for (; i < length; ++i)
                {
                    if (option(sub_option_set[i]).count() > 0)
                        break;
                }
                if (i != length)
                {
                    std::vector<string_type> vect;
                    vect.resize(1);
                    vect[0] = parent_option;
                    throw cmd_line_check_error( EMISSING_REQUIRED_OPTION, sub_option_set[i], vect);
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_sub_options (
            const char_type* (&parent_option_set)[length],
            const string_type& sub_option
        ) const
        {
            // first check if the sub_option is present
            if (option(sub_option).count() > 0)
            {
                // now check if any of the parents are present
                bool parents_present = false;
                for (size_t i = 0; i < length; ++i)
                {
                    if (option(parent_option_set[i]).count() > 0)
                    {
                        parents_present = true;
                        break;
                    }
                }

                if (!parents_present)
                {
                    std::vector<string_type> vect(parent_option_set, parent_option_set+length);
                    throw cmd_line_check_error( EMISSING_REQUIRED_OPTION, sub_option, vect);
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t parent_length, size_t sub_length >
        void cmd_line_parser_check_1<clp_base>::
        check_sub_options (
            const char_type* (&parent_option_set)[parent_length],
            const char_type* (&sub_option_set)[sub_length]
        ) const
        {
            // first check if any of the parent options are present
            bool parents_present = false;
            for (size_t i = 0; i < parent_length; ++i)
            {
                if (option(parent_option_set[i]).count() > 0)
                {
                    parents_present = true;
                    break;
                }
            }

            if (!parents_present)
            {
                // none of these sub options should be present
                size_t i = 0;
                for (; i < sub_length; ++i)
                {
                    if (option(sub_option_set[i]).count() > 0)
                        break;
                }
                if (i != sub_length)
                {
                    std::vector<string_type> vect(parent_option_set, parent_option_set+parent_length);
                    throw cmd_line_check_error( EMISSING_REQUIRED_OPTION, sub_option_set[i], vect);
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <typename clp_base>
        template < size_t length >
        void cmd_line_parser_check_1<clp_base>::
        check_one_time_options (
            const char_type* (&option_set)[length]
        ) const
        {
            size_t i = 0;
            for (; i < length; ++i)
            {
                if (option(option_set[i]).count() > 1)
                    break;
            }
            if (i != length)
            {
                throw cmd_line_check_error(
                    EMULTIPLE_OCCURANCES,
                    option_set[i]
                );
            }
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_CMD_LINE_PARSER_CHECk_1_