command_line_builder.h

Go to the documentation of this file.

#ifndef OOKII_COMMAND_LINE_BUILDER_H_
#define OOKII_COMMAND_LINE_BUILDER_H_
 
#pragma once
 
#include "command_line_core.h"
 
namespace ookii
{
    template<typename CharType = details::default_char_type, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class basic_parser_builder
    {
        using parser_storage_type = details::parser_storage<CharType, Traits, Alloc>;
 
    public:
        using parser_type = basic_command_line_parser<CharType, Traits, Alloc>;
        using string_type = typename parser_type::string_type;
        using argument_base_type = typename parser_type::argument_base_type;
 
        template<typename T>
        using typed_argument_type = command_line_argument<T, CharType, Traits, Alloc>;
 
        class argument_builder_base;
 
        template<typename ArgumentType, typename BaseType>
        class argument_builder;
 
        template<typename T>
        class multi_value_argument_builder;
 
        class argument_builder_base
        {
            using storage_type = typename argument_base_type::storage_type;
 
        public:
            virtual ~argument_builder_base() = default;
 
            argument_builder_base(argument_builder_base &) = delete;
            argument_builder_base &operator=(argument_builder_base &) = delete;
 
            template<typename T>
            argument_builder<typed_argument_type<T>, argument_builder_base> &add_argument(T &value, string_type name)
            {
                return _parser_builder.add_argument(value, name);
            }
 
            template<typename T>
            typename multi_value_argument_builder<T>::builder_type &add_multi_value_argument(T &value, string_type name)
            {
                return _parser_builder.add_multi_value_argument(value, name);
            }
 
            parser_type build()
            {
                return _parser_builder.build();
            }
 
            const string_type &name() const
            {
                return this->_storage.name;
            }
 
            virtual owned_or_borrowed_ptr<argument_base_type> to_argument() = 0;
 
        protected:
            argument_builder_base(basic_parser_builder &basic_parser_builder, string_type name)
                : _storage{name},
                  _parser_builder{basic_parser_builder}
            {
            }
 
            storage_type &storage()
            {
                return _storage;
            }
 
            size_t get_next_position()
            {
                return _parser_builder.get_next_position();
            }
 
        private:
            storage_type _storage;
            basic_parser_builder &_parser_builder;
        };
 
        template<typename ArgumentType, typename BaseType>
        class argument_builder : public BaseType
        {
            using typed_storage_type = typename ArgumentType::typed_storage_type;
            using value_type = typename ArgumentType::value_type;
            using element_type = typename ArgumentType::element_type;
            using converter_type = typename typed_storage_type::converter_type;
 
        public:
            argument_builder(basic_parser_builder &basic_parser_builder, string_type name, value_type &value)
                : BaseType{basic_parser_builder, name},
                  _typed_storage{value}
            {
            }
 
            argument_builder &value_description(string_type value_description)
            {
                this->storage().value_description = value_description;
                return *this;
            }
 
            argument_builder &description(string_type description)
            {
                this->storage().description = description;
                return *this;
            }
 
            argument_builder &positional()
            {
                if (!this->storage().position)
                {
                    this->storage().position = this->get_next_position();
                }
 
                return *this;
            }
 
            argument_builder &required()
            {
                this->storage().is_required = true;
                return *this;
            }
 
            argument_builder &default_value(element_type default_value)
            {
                this->_typed_storage.default_value = default_value;
                return *this;
            }
 
            argument_builder &converter(converter_type converter)
            {
                this->_typed_storage.converter = converter;
                return *this;
            }
 
            argument_builder &alias(string_type alias)
            {
                this->storage().aliases.push_back(alias);
                return *this;
            }
 
            argument_builder &cancel_parsing()
            {
                this->storage().cancel_parsing = true;
                return *this;
            }
 
        private:
            virtual owned_or_borrowed_ptr<argument_base_type> to_argument() override
            {
                if (this->storage().value_description.empty())
                    this->storage().value_description = ::ookii::value_description<element_type, CharType, Traits, Alloc>::get();
 
                return make_owned_ptr<ArgumentType>(std::move(this->storage()), std::move(_typed_storage));
            }
 
            typed_storage_type _typed_storage;
        };
 
        template<typename T>
        class multi_value_argument_builder : public argument_builder_base
        {
        public:
            using builder_type = argument_builder<multi_value_command_line_argument<T, CharType, Traits, Alloc>, multi_value_argument_builder>;
 
            builder_type &separator(CharType separator)
            {
                this->storage().multi_value_separator = separator;
                return *static_cast<builder_type*>(this);
            }
 
        protected:
            multi_value_argument_builder(basic_parser_builder &basic_parser_builder, string_type name)
                : argument_builder_base{basic_parser_builder, name}
            {
            }
        };
 
        basic_parser_builder(string_type command_name)
            : _storage{command_name}
        {
        }
 
        template<typename T>
        argument_builder<typed_argument_type<T>, argument_builder_base> &add_argument(T &value, string_type name)
        {
            _arguments.push_back(std::make_unique<argument_builder<typed_argument_type<T>, argument_builder_base>>(*this, name, value));
            return *static_cast<argument_builder<typed_argument_type<T>, argument_builder_base>*>(_arguments.back().get());
        }
 
        template<typename T>
        typename multi_value_argument_builder<T>::builder_type &add_multi_value_argument(T &value, string_type name)
        {
            _arguments.push_back(std::make_unique<typename multi_value_argument_builder<T>::builder_type>(*this, name, value));
            return *static_cast<typename multi_value_argument_builder<T>::builder_type*>(_arguments.back().get());
        }
 
        parser_type build()
        {
            if (_storage.prefixes.empty())
                _storage.prefixes = parser_type::get_default_prefixes();
 
            return parser_type{_arguments, std::move(_storage), _case_sensitive};
        }
 
        basic_parser_builder &case_sensitive(bool case_sensitive) noexcept
        {
            _case_sensitive = case_sensitive;
            return *this;
        }
 
        basic_parser_builder &locale(std::locale loc)
        {
            _storage.locale = loc;
            return *this;
        }
 
        template<typename Range>
        basic_parser_builder &prefixes(const Range &prefixes)
        {
            // Using enables ADL.
            using std::begin;
            using std::end;
            _storage.prefixes = std::vector<string_type>{ begin(prefixes), end(prefixes) };
            return *this;
        }
 
        template<typename T>
        basic_parser_builder &prefixes(std::initializer_list<T> prefixes)
        {
            return this->prefixes<std::initializer_list<T>>(prefixes);
        }
 
        basic_parser_builder &allow_whitespace_separator(bool allow) noexcept
        {
            _storage.allow_white_space_separator = allow;
            return *this;
        }
 
        basic_parser_builder &allow_duplicate_arguments(bool allow) noexcept
        {
            _storage.allow_duplicate_arguments = allow;
            return *this;
        }
 
        basic_parser_builder &argument_value_separator(CharType separator) noexcept
        {
            _storage.argument_value_separator = separator;
            return *this;
        }
 
        basic_parser_builder &description(string_type description)
        {
            _storage.description = description;
            return *this;
        }
 
    private:
        size_t get_next_position() noexcept
        {
            return _next_position++;
        }
 
        std::vector<std::unique_ptr<argument_builder_base>> _arguments;
        size_t _next_position{};
        bool _case_sensitive{};
        
        parser_storage_type _storage;
    };
 
    using parser_builder = basic_parser_builder<char>;
    using wparser_builder = basic_parser_builder<wchar_t>;
 
}
 
#endif