configuration.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------

#pragma once

#include <tuple>

#include <meta/meta.hpp>

#include <seqan3/core/algorithm/concept.hpp>
#include <seqan3/core/algorithm/configuration_utility.hpp>
#include <seqan3/core/algorithm/pipeable_config_element.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/template_inspection.hpp>
#include <seqan3/core/tuple_utility.hpp>
#include <seqan3/core/type_list.hpp>
#include <seqan3/std/concepts>

namespace seqan3
{

// Forward declaration for friend declaration definitions below.
template <detail::ConfigElement ... configs_t>
class configuration;

template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> && lhs,
                         pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs)
{
    return configuration{static_cast<lhs_derived_t &&>(lhs)}.push_back(static_cast<rhs_derived_t &&>(rhs));
}

template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> && lhs,
                         pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs)
{
    return configuration{static_cast<lhs_derived_t &&>(lhs)}.push_back(static_cast<rhs_derived_t const &>(rhs));
}

template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> const & lhs,
                         pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs)
{
    return configuration{static_cast<lhs_derived_t const &>(lhs)}.push_back(static_cast<rhs_derived_t &&>(rhs));
}

template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> const & lhs,
                         pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs)
{
    return configuration{static_cast<lhs_derived_t const &>(lhs)}.push_back(static_cast<rhs_derived_t const &>(rhs));
}

// ----------------------------------------------------------------------------
// configuration
// ----------------------------------------------------------------------------

template <detail::ConfigElement ... configs_t>
class configuration : public std::tuple<configs_t...>
{
    template <detail::ConfigElement ... _configs_t>
    friend class configuration;
public:
    using base_type = std::tuple<configs_t...>;


    constexpr configuration()                                  = default; 
    constexpr configuration(configuration const &)             = default; 
    constexpr configuration(configuration &&)                  = default; 
    constexpr configuration & operator=(configuration const &) = default; 
    constexpr configuration & operator=(configuration &&)      = default; 
    ~configuration()                                           = default; 

    template <typename derived_t, typename value_t>
    constexpr configuration(pipeable_config_element<derived_t, value_t> && elem) :
        base_type{static_cast<derived_t &&>(std::move(elem))}
    {}

    template <typename derived_t, typename value_t>
    constexpr configuration(pipeable_config_element<derived_t, value_t> const & elem) :
        base_type{static_cast<derived_t const &>(elem)}
    {}

    constexpr size_t size() const noexcept
    {
        return std::tuple_size_v<base_type>;
    }

    template <typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) & noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(*this).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) const & noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(*this).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) && noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(std::move(*this)).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) const && noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(std::move(*this)).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <template <typename...> typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) & noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(*this).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <template <typename...> typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) const & noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(*this).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <template <typename...> typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) && noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(std::move(*this)).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <template <typename...> typename query_t, typename default_t>
    constexpr decltype(auto) value_or(default_t && default_value) const && noexcept
    {
        if constexpr (exists<query_t>())
        {
            return get<query_t>(std::move(*this)).value;
        }
        else
        {
            using ret_type = remove_rvalue_reference_t<decltype(default_value)>;
            return static_cast<ret_type>(default_value);
        }
    }

    template <typename query_t>
    static constexpr bool exists() noexcept
    {
        return !meta::empty<meta::find<type_list<configs_t...>, query_t>>::value;
    }
    template <template <typename...> typename query_t>
    static constexpr bool exists() noexcept
    {
        return !meta::empty<meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>>::value;
    }

    template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> && lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs);

    template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> && lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs);

    template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> const & lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs);

    template <typename lhs_derived_t, typename lhs_value_t, typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(pipeable_config_element<lhs_derived_t, lhs_value_t> const & lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs);

    template <typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(configuration && lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs)
    {
        return std::move(lhs).push_back(static_cast<rhs_derived_t &&>(rhs));
    }

    template <typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(configuration const & lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> && rhs)
    {
        return lhs.push_back(static_cast<rhs_derived_t &&>(rhs));
    }

    template <typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(configuration && lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs)
    {
        return std::move(lhs).push_back(static_cast<rhs_derived_t const &>(rhs));
    }

    template <typename rhs_derived_t, typename rhs_value_t>
    friend constexpr auto operator|(configuration const & lhs,
                                    pipeable_config_element<rhs_derived_t, rhs_value_t> const & rhs)
    {
        return lhs.push_back(static_cast<rhs_derived_t const &>(rhs));
    }

    template <typename ...rhs_configs_t>
    friend constexpr auto operator|(configuration && lhs,
                                    configuration<rhs_configs_t...> && rhs)
    {
        using lhs_base_t = typename configuration::base_type;
        using rhs_base_t = typename configuration<rhs_configs_t...>::base_type;

        return make_configuration(std::tuple_cat(static_cast<lhs_base_t>(std::move(lhs)),
                                                 static_cast<rhs_base_t>(std::move(rhs))));
    }

    template <typename ...rhs_configs_t>
    friend constexpr auto operator|(configuration const & lhs,
                                    configuration<rhs_configs_t...> && rhs)
    {
        using lhs_base_t = typename configuration::base_type;
        using rhs_base_t = typename configuration<rhs_configs_t...>::base_type;

        return make_configuration(std::tuple_cat(static_cast<lhs_base_t>(lhs),
                                                 static_cast<rhs_base_t>(std::move(rhs))));
    }

    template <typename ...rhs_configs_t>
    friend constexpr auto operator|(configuration && lhs,
                                    configuration<rhs_configs_t...> const & rhs)
    {
        using lhs_base_t = typename configuration::base_type;
        using rhs_base_t = typename configuration<rhs_configs_t...>::base_type;

        return make_configuration(std::tuple_cat(static_cast<lhs_base_t>(std::move(lhs)),
                                                 static_cast<rhs_base_t>(rhs)));
    }

    template <typename ...rhs_configs_t>
    friend constexpr auto operator|(configuration const & lhs,
                                    configuration<rhs_configs_t...> const & rhs)
    {
        using lhs_base_t = typename configuration::base_type;
        using rhs_base_t = typename configuration<rhs_configs_t...>::base_type;

        return make_configuration(std::tuple_cat(static_cast<lhs_base_t>(lhs),
                                                 static_cast<rhs_base_t>(rhs)));
    }

private:

    template <typename ... _configs_t>
    explicit constexpr configuration(std::tuple<_configs_t...> const & cfg) : base_type{cfg}
    {}

    template <typename ... _configs_t>
    explicit constexpr configuration(std::tuple<_configs_t...> && cfg) : base_type{std::move(cfg)}
    {}

    template <typename tuple_t>
        requires detail::is_type_specialisation_of_v<tuple_t, std::tuple> &&
                 std::tuple_size_v<remove_cvref_t<tuple_t>> > 0
    static constexpr auto make_configuration(tuple_t && tpl)
    {
        auto make_config = [](auto && tpl)
        {
            auto impl = [](auto & impl_ref, auto && config, auto && head, auto && tail)
            {
                if constexpr (std::tuple_size_v<remove_cvref_t<decltype(tail)>> == 0)
                {
                    return std::forward<decltype(config)>(config).push_back(std::get<0>(std::forward<decltype(head)>(head)));
                }
                else
                {
                    auto [_head, _tail] = tuple_split<1>(std::forward<decltype(tail)>(tail));
                    auto tmp = std::forward<decltype(config)>(config).push_back(
                            std::get<0>(std::forward<decltype(head)>(head)));
                    return impl_ref(impl_ref, std::move(tmp), std::move(_head), std::move(_tail));
                }
            };
            auto [head, tail] = tuple_split<1>(std::forward<decltype(tpl)>(tpl));
            return impl(impl, configuration<>{}, std::move(head), std::move(tail));
        };
        return make_config(std::forward<tuple_t>(tpl));
    }

    template <detail::ConfigElement config_element_t>
    constexpr auto push_back(config_element_t elem) const &
    {
        static_assert(detail::is_configuration_valid_v<remove_cvref_t<config_element_t>,
                                                            configs_t...>,
                      "Configuration error: The passed element cannot be combined with one or more elements in the "
                      "current configuration.");

        return configuration<configs_t..., std::remove_reference_t<config_element_t>>{
            std::tuple_cat(static_cast<base_type>(*this),
            std::tuple{std::move(elem)})};
    }

    template <detail::ConfigElement config_element_t>
    constexpr auto push_back(config_element_t elem) &&
    {
        static_assert(detail::is_configuration_valid_v<remove_cvref_t<config_element_t>,
                                                            configs_t...>,
                      "Configuration error: The passed element cannot be combined with one or more elements in the "
                      "current configuration.");

        return configuration<configs_t..., std::remove_reference_t<config_element_t>>{
            std::tuple_cat(std::move(static_cast<base_type>(*this)),
            std::tuple{std::move(elem)})};
    }
};

template <typename derived_t, typename value_t>
configuration(pipeable_config_element<derived_t, value_t> &&) -> configuration<remove_cvref_t<derived_t>>;

template <typename derived_t, typename value_t>
configuration(pipeable_config_element<derived_t, value_t> const &) -> configuration<remove_cvref_t<derived_t>>;

template <template <typename ...> class query_t, typename ...configs_t>
constexpr auto & get(configuration<configs_t...> & config) noexcept
{
    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");

    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
    return get<pos>(config);
}

template <template <typename ...> class query_t, typename ...configs_t>
constexpr auto const & get(configuration<configs_t...> const & config) noexcept
{
    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");

    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
    return get<pos>(config);
}

template <template <typename ...> class query_t, typename ...configs_t>
constexpr auto && get(configuration<configs_t...> && config) noexcept
{
    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");

    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
    return get<pos>(std::move(config));
}

template <template <typename ...> class query_t, typename ...configs_t>
constexpr auto const && get(configuration<configs_t...> const && config) noexcept
{
    using _tail = meta::find_if<type_list<configs_t...>, detail::is_same_configuration_f<query_t>>;
    static_assert(!meta::empty<_tail>::value, "Access error: The requested type is not contained.");

    constexpr size_t pos = sizeof...(configs_t) - meta::size<_tail>::value;
    // TODO: change after GCC-7 bug with const && version of get in std::tuple is fixed.
    // return get<pos>(std::move(config));
    return std::move(get<pos>(config));
}

} // namespace seqan3::detail

namespace std
{

template <seqan3::detail::ConfigElement ... configs_t>
struct tuple_size<seqan3::configuration<configs_t...>>
{
    static constexpr size_t value = std::tuple_size_v<typename seqan3::configuration<configs_t...>::base_type>;
};

template <size_t pos, seqan3::detail::ConfigElement ... configs_t>
struct tuple_element<pos, seqan3::configuration<configs_t...>>
{
    using type = std::tuple_element_t<pos, typename seqan3::configuration<configs_t...>::base_type>;
};
}  //namespace std