command_line_argument.h

Go to the documentation of this file.

#ifndef OOKII_COMMAND_LINE_ARGUMENT_H_
#define OOKII_COMMAND_LINE_ARGUMENT_H_
 
#pragma once
 
#include <functional>
#include "command_line_switch.h"
#include "parsing_mode.h"
 
namespace ookii
{
    // Forward declaration.
    template<typename CharType, typename Traits, typename Alloc>
    class basic_command_line_parser;
 
    namespace details
    {
        template<typename CharType, typename Traits, typename Alloc>
        struct argument_storage
        {
            using string_type = std::basic_string<CharType, Traits, Alloc>;
 
            argument_storage(string_type name)
                : name{name}
            {
            }
 
            string_type name;
            string_type value_description;
            string_type description;
            std::optional<size_t> position;
            std::vector<string_type> aliases;
            std::vector<CharType> short_aliases;
            bool is_required{};
            bool cancel_parsing{};
            bool has_long_name{true};
            CharType multi_value_separator{};
            CharType short_name{};
        };
 
        template<typename T, typename Element, typename CharType, typename Traits>
        struct typed_argument_storage
        {
            using converter_type = std::function<std::optional<Element>(std::basic_string_view<CharType, Traits>, const std::locale &)>;
 
            typed_argument_storage(T &value)
                : value{value}
            {
            }
 
            T &value;
            std::optional<Element> default_value;
            converter_type converter;
        };
 
        template<typename T, typename CharType, typename Traits, typename Alloc>
        struct action_argument_storage
        {
            using converter_type = std::function<std::optional<T>(std::basic_string_view<CharType, Traits>, const std::locale &)>;
            using function_type = std::function<bool(const T &value, basic_command_line_parser<CharType, Traits, Alloc> &parser)>;
 
            action_argument_storage(function_type action)
                : action{action}
            {
            }
 
            function_type action;
            converter_type converter;
        };
 
        template<typename T>
        struct element_type
        {
            using type = T;
        };
 
        template<typename T>
        struct element_type<std::optional<T>>
        {
            using type = T;
        };
    }
 
    enum class set_value_result
    {
        success,
        error,
        cancel
    };
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class command_line_argument_base
    {
    public:
        using storage_type = details::argument_storage<CharType, Traits, Alloc>;
        using string_type = typename storage_type::string_type;
        using string_view_type = std::basic_string_view<CharType, Traits>;
        using stream_type = std::basic_ostream<CharType, Traits>;
        using parser_type = basic_command_line_parser<CharType, Traits, Alloc>;
 
        command_line_argument_base(const command_line_argument_base &) = delete;
 
        virtual ~command_line_argument_base() = default;
 
        command_line_argument_base &operator=(const command_line_argument_base &) = delete;
 
        const string_type &name() const noexcept
        {
            return _storage.name;
        }
 
        CharType short_name() const noexcept
        {
            return _storage.short_name;
        }
 
        bool has_short_name() const noexcept
        {
            return _storage.short_name != '\0';
        }
 
        bool has_long_name() const noexcept
        {
            return _storage.has_long_name;
        }
 
        string_view_type short_or_long_name() const
        {
            if (has_short_name())
            {
                return string_view_type(&_storage.short_name, 1);
            }
            else
            {
                return name();
            }
        }
 
        string_type name_with_prefix(const parser_type &parser) const
        {
            if (has_long_name() && parser.mode() == parsing_mode::long_short)
            {
                return parser.long_prefix() + name();
            }
            else
            {
                return parser.prefixes()[0] + name();
            }
        }
 
        const std::vector<string_type> &aliases() const noexcept
        {
            return _storage.aliases;
        }
 
        const std::vector<CharType> &short_aliases() const noexcept
        {
            return _storage.short_aliases;
        }
 
        const string_type &value_description() const noexcept
        {
            return _storage.value_description;
        }
 
        const string_type &description() const noexcept
        {
            return _storage.description;
        }
 
        std::optional<size_t> position() const noexcept
        {
            return _storage.position;
        }
 
        bool is_required() const noexcept
        {
            return _storage.is_required;
        }
 
        bool cancel_parsing() const noexcept
        {
            return _storage.cancel_parsing;
        }
 
        bool has_value() const noexcept
        {
            return _has_value;
        }
 
        virtual bool is_switch() const noexcept = 0;
 
        virtual bool is_multi_value() const noexcept
        {
            return false;
        }
 
        virtual void reset()
        {
            _has_value = false;
        }
 
        virtual set_value_result set_value(string_view_type value, parser_type &parser) = 0;
 
        virtual void apply_default_value() = 0;
 
        virtual set_value_result set_switch_value(parser_type &parser) = 0;
 
        virtual stream_type &write_default_value(stream_type &stream) const = 0;
 
        virtual bool has_default_value() const noexcept = 0;
 
    protected:
        void set_value() noexcept
        {
            _has_value = true;
        }
 
        const storage_type &base_storage() const
        {
            return _storage;
        }
 
        command_line_argument_base(const parser_type &parser, storage_type &&storage)
            : _storage{std::move(storage)}
        {
            // Normalize elements based on parsing mode.
            if (parser.mode() == parsing_mode::long_short)
            {
                if (!_storage.has_long_name)
                {
                    if (_storage.short_name == '\0')
                    {
                        throw std::logic_error("Argument has neither a long nor a short name.");
                    }
 
                    _storage.name = _storage.short_name;
                    _storage.aliases.clear();
                }
 
                if (_storage.short_name == '\0')
                {
                    _storage.short_aliases.clear();
                }
            }
            else
            {
                _storage.short_name = static_cast<CharType>('\0');
                _storage.has_long_name = true;
                _storage.short_aliases.clear();
            }
        }
 
    private:
        storage_type _storage;
        bool _has_value{};
    };
 
    template<class T, typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class command_line_argument final : public command_line_argument_base<CharType, Traits, Alloc>
    {
    public:
        using base_type = command_line_argument_base<CharType, Traits, Alloc>;
        using value_type = T;
        using element_type = typename details::element_type<T>::type;
        using string_type = typename base_type::string_type;
        using string_view_type = typename base_type::string_view_type;
        using typed_storage_type = details::typed_argument_storage<value_type, element_type, CharType, Traits>;
        using parser_type = typename base_type::parser_type;
 
        command_line_argument(const typename base_type::parser_type &parser, typename base_type::storage_type &&storage,
                              typed_storage_type &&typed_storage)
            : base_type{parser, std::move(storage)},
              _storage{std::move(typed_storage)}
        {
        }
 
        bool is_switch() const noexcept override
        {
            return details::is_switch<T>::value;
        }
 
        set_value_result set_value(string_view_type value, parser_type &parser) override
        {
            std::optional<element_type> converted;
            if (_storage.converter)
                converted = _storage.converter(value, parser.locale());
            else
                converted = lexical_convert<element_type, CharType, Traits, Alloc>::from_string(value, parser.locale());
 
            if (!converted)
                return set_value_result::error;
 
            _storage.value = std::move(*converted);
            base_type::set_value();
            return set_value_result::success;
        }
 
        set_value_result set_switch_value([[maybe_unused]] parser_type &parser) override
        {
            return set_switch_value_core();
        }
 
        void apply_default_value() override
        {
            if (!this->has_value() && _storage.default_value)
            {
                _storage.value = *_storage.default_value;
            }
        }
 
        typename base_type::stream_type &write_default_value(typename base_type::stream_type &stream) const override
        {
            if (_storage.default_value)
            {
                stream << *_storage.default_value;
            }
 
            return stream;
        }
 
        bool has_default_value() const noexcept override
        {
            return _storage.default_value.has_value();
        }
 
    private:
        template<typename T2 = T>
        std::enable_if_t<details::is_switch<T2>::value, set_value_result> set_switch_value_core()
        {
            _storage.value = true;
            base_type::set_value();
            return set_value_result::success;
        }
 
        template<typename T2 = T>
        std::enable_if_t<!details::is_switch<T2>::value, set_value_result> set_switch_value_core()
        {
            return set_value_result::error;
        }
 
        typed_storage_type _storage;
    };
 
    template<typename T, typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class multi_value_command_line_argument : public command_line_argument_base<CharType, Traits, Alloc>
    {
    public:
        using base_type = command_line_argument_base<CharType, Traits, Alloc>;
        using value_type = T;
        using element_type = typename T::value_type;
        using string_type = typename base_type::string_type;
        using string_view_type = typename base_type::string_view_type;
        using typed_storage_type = details::typed_argument_storage<T, element_type, CharType, Traits>;
        using parser_type = typename base_type::parser_type;
 
        multi_value_command_line_argument(const typename base_type::parser_type &parser, typename base_type::storage_type &&storage,
                                          typed_storage_type &&typed_storage)
            : base_type{parser, std::move(storage)},
              _storage{std::move(typed_storage)}
        {
        }
 
        bool is_switch() const noexcept override
        {
            return details::is_switch<element_type>::value;
        }
 
        bool is_multi_value() const noexcept override
        {
            return true;
        }
 
        CharType separator() const noexcept
        {
            return this->base_storage().multi_value_separator;
        }
 
        void reset() override
        {
            base_type::reset();
            _storage.value.clear();
        }
 
        set_value_result set_value(string_view_type value, parser_type &parser) override
        {
            for (auto element : tokenize{value, separator()})
            {
                std::optional<element_type> converted;
                if (_storage.converter)
                    converted = _storage.converter(element, parser.locale());
                else
                    converted = lexical_convert<element_type, CharType, Traits, Alloc>::from_string(element, parser.locale());
 
                if (!converted)
                    return set_value_result::error;
 
                _storage.value.push_back(std::move(*converted));
            }
 
            base_type::set_value();
            return set_value_result::success;
        }
 
        set_value_result set_switch_value([[maybe_unused]] parser_type &parser) override
        {
            return set_switch_value_core();
        }
 
        void apply_default_value() override
        {
            if (!this->has_value() && _storage.default_value)
            {
                _storage.value.push_back(*_storage.default_value);
            }
        }
 
        typename base_type::stream_type &write_default_value(typename base_type::stream_type &stream) const override
        {
            if (_storage.default_value)
            {
                stream << *_storage.default_value;
            }
 
            return stream;
        }
 
        bool has_default_value() const noexcept override
        {
            return _storage.default_value.has_value();
        }
 
    private:
        template<typename T2 = element_type>
        std::enable_if_t<details::is_switch<T2>::value, set_value_result> set_switch_value_core()
        {
            _storage.value.push_back(true);
            base_type::set_value();
            return set_value_result::success;
        }
 
        template<typename T2 = element_type>
        std::enable_if_t<!details::is_switch<T2>::value, set_value_result> set_switch_value_core()
        {
            return set_value_result::error;
        }
 
        typed_storage_type _storage;
    };
 
    template<class T, typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    class action_command_line_argument final : public command_line_argument_base<CharType, Traits, Alloc>
    {
    public:
        using base_type = command_line_argument_base<CharType, Traits, Alloc>;
        using value_type = T;
        using element_type = T;
        using string_type = typename base_type::string_type;
        using string_view_type = typename base_type::string_view_type;
        using typed_storage_type = details::action_argument_storage<value_type, CharType, Traits, Alloc>;
        using function_type = typename typed_storage_type::function_type;
        using parser_type = typename base_type::parser_type;
 
        action_command_line_argument(const typename base_type::parser_type &parser, typename base_type::storage_type &&storage,
                              typed_storage_type &&typed_storage)
            : base_type{parser, std::move(storage)},
              _storage{std::move(typed_storage)}
        {
        }
 
        bool is_switch() const noexcept override
        {
            return details::is_switch<T>::value;
        }
 
        set_value_result set_value(string_view_type value, parser_type &parser) override
        {
            std::optional<element_type> converted;
            if (_storage.converter)
                converted = _storage.converter(value, parser.locale());
            else
                converted = lexical_convert<element_type, CharType, Traits, Alloc>::from_string(value, parser.locale());
 
            if (!converted)
                return set_value_result::error;
 
            base_type::set_value();
            return invoke_action(*converted, parser);
        }
 
        set_value_result set_switch_value(parser_type &parser) override
        {
            return set_switch_value_core(parser);
        }
 
        void apply_default_value() override
        {
            // Does nothing; action arguments cannot have a default value.
        }
 
        typename base_type::stream_type &write_default_value(typename base_type::stream_type &stream) const override
        {
            // Does nothing; action arguments cannot have a default value.
            return stream;
        }
 
        bool has_default_value() const noexcept override
        {
            return false;
        }
 
    private:
        set_value_result invoke_action(const T &value, parser_type &parser)
        {
            bool result = _storage.action(value, parser);
            return result ? set_value_result::success : set_value_result::cancel;
        }
 
        template<typename T2 = T>
        std::enable_if_t<details::is_switch<T2>::value, set_value_result> set_switch_value_core(parser_type &parser)
        {
            base_type::set_value();
            return invoke_action(true, parser);
        }
 
        template<typename T2 = T>
        std::enable_if_t<!details::is_switch<T2>::value, set_value_result> set_switch_value_core(parser_type &)
        {
            return set_value_result::error;
        }
 
        typed_storage_type _storage;
    };
 
}
 
#endif