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 "usage_options.h"
 
namespace ookii
{
    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;
            bool is_required{};
            bool cancel_parsing{};
            CharType multi_value_separator{};
        };
 
        template<class 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>
        struct element_type
        {
            using type = T;
        };
 
        template<typename T>
        struct element_type<std::optional<T>>
        {
            using type = T;
        };
    }
 
    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 usage_options_type = basic_usage_options<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;
        }
 
        const std::vector<string_type> &aliases() const noexcept
        {
            return _storage.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 bool set_value(string_view_type value, std::locale loc = {}) = 0;
 
        virtual void apply_default_value() = 0;
 
        virtual bool set_switch_value() = 0;
 
        virtual string_type format_default_value(const usage_options_type &options, const std::locale &loc = {}) const = 0;
 
    protected:
        void set_value() noexcept
        {
            _has_value = true;
        }
 
        const storage_type &base_storage() const
        {
            return _storage;
        }
 
        command_line_argument_base(storage_type &&storage)
            : _storage{std::move(storage)}
        {
        }
 
        template<typename T>
        static string_type format_default_value_helper(const std::optional<T> &value, const usage_options_type &options, const std::locale &loc = {})
        {
            if (options.include_default_value_in_description && value)
                return format::ncformat(loc, options.default_value_format, *value);
            else
                return {};
        }
 
    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 usage_options_type = typename base_type::usage_options_type;
 
        command_line_argument(typename base_type::storage_type &&storage, typed_storage_type &&typed_storage)
            : base_type{std::move(storage)},
              _storage{std::move(typed_storage)}
        {
        }
 
        bool is_switch() const noexcept override
        {
            return details::is_switch<T>::value;
        }
 
        bool set_value(string_view_type value, std::locale loc = {}) override
        {
            std::optional<element_type> converted;
            if (_storage.converter)
                converted = _storage.converter(value, loc);
            else
                converted = lexical_convert<element_type, CharType, Traits, Alloc>::from_string(value, loc);
 
            if (!converted)
                return false;
 
            _storage.value = std::move(*converted);
            base_type::set_value();
            return true;
        }
 
        bool set_switch_value() override
        {
            return set_switch_value_core();
        }
 
        void apply_default_value() override
        {
            if (!this->has_value() && _storage.default_value)
            {
                _storage.value = *_storage.default_value;
            }
        }
 
        string_type format_default_value(const usage_options_type &options, const std::locale &loc = {}) const override
        {
            return this->format_default_value_helper(_storage.default_value, options, loc);
        }
 
    private:
        template<typename T2 = T>
        std::enable_if_t<details::is_switch<T2>::value, bool> set_switch_value_core()
        {
            _storage.value = true;
            return true;
        }
 
        template<typename T2 = T>
        std::enable_if_t<!details::is_switch<T2>::value, bool> set_switch_value_core()
        {
            return false;
        }
 
        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 usage_options_type = typename base_type::usage_options_type;
 
        multi_value_command_line_argument(typename base_type::storage_type &&storage, typed_storage_type &&typed_storage)
            : base_type{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();
        }
 
        bool set_value(string_view_type value, std::locale loc = {}) override
        {
            for (auto element : tokenize{value, separator()})
            {
                std::optional<element_type> converted;
                if (_storage.converter)
                    converted = _storage.converter(element, loc);
                else
                    converted = lexical_convert<element_type, CharType, Traits, Alloc>::from_string(element, loc);
 
                if (!converted)
                    return false;
 
                _storage.value.push_back(std::move(*converted));
            }
 
            base_type::set_value();
            return true;
        }
 
        bool set_switch_value() 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);
            }
        }
 
        string_type format_default_value(const usage_options_type &options, const std::locale &loc = {}) const override
        {
            return this->format_default_value_helper(_storage.default_value, options, loc);
        }
 
    private:
        template<typename T2 = element_type>
        std::enable_if_t<details::is_switch<T2>::value, bool> set_switch_value_core()
        {
            _storage.value.push_back(true);
            return true;
        }
 
        template<typename T2 = element_type>
        std::enable_if_t<!details::is_switch<T2>::value, bool> set_switch_value_core()
        {
            return false;
        }
 
        typed_storage_type _storage;
    };
 
}
 
#endif