20namespace seqan3::detail
27template <
typename left_adaptor_t,
typename right_adaptor_t>
28class combined_adaptor;
75template <
typename derived_type,
typename ...stored_args_ts>
83 template <
typename urng_t,
size_t... Is>
88 return static_cast<derived_type
const &
>(*this).impl(
89 std::forward<urng_t>(urange),
94 template <
typename urng_t,
size_t... Is>
98 return static_cast<derived_type &&
>(*this).impl(
99 std::forward<urng_t>(urange),
112 constexpr adaptor_base(adaptor_base
const &)
noexcept =
default;
113 constexpr adaptor_base(adaptor_base &&) noexcept = default;
114 constexpr adaptor_base & operator=(adaptor_base const &) noexcept = default;
115 constexpr adaptor_base & operator=(adaptor_base &&) noexcept = default;
116 ~adaptor_base() noexcept = default;
119 constexpr adaptor_base(stored_args_ts ... args)
120 noexcept(noexcept(
std::tuple<stored_args_ts...>{std::forward<stored_args_ts>(args)...})) :
121 arguments{
std::
forward<stored_args_ts>(args)...}
126 template <std::ranges::input_range urng_t>
127 constexpr auto operator()(urng_t && urange)
const &
133 template <std::ranges::input_range urng_t>
134 constexpr auto operator()(urng_t && urange) &&
136 return std::move(*this).pass_args_to_impl(std::forward<urng_t>(urange),
151 template <
typename arg_t>
152 constexpr friend auto operator|(arg_t && arg, derived_type
const & me)
154 if constexpr (std::ranges::input_range<arg_t>)
155 return me(std::forward<arg_t>(arg));
157 return combined_adaptor{std::forward<arg_t>(arg), me};
161 template <
typename arg_t>
162 constexpr friend auto operator|(arg_t && arg, derived_type && me)
164 if constexpr (std::ranges::input_range<arg_t>)
165 return std::move(me)(std::forward<arg_t>(arg));
167 return combined_adaptor{std::forward<arg_t>(arg), std::move(me)};
186 template <
typename arg_t>
187 constexpr friend auto operator|(adaptor_base
const & me, arg_t && arg)
189 return combined_adaptor{
static_cast<derived_type
const &
>(me), std::forward<arg_t>(arg)};
193 template <
typename arg_t>
194 constexpr friend auto operator|(adaptor_base && me, arg_t && arg)
196 return combined_adaptor{
static_cast<derived_type &&
>(me), std::forward<arg_t>(arg)};
214template <
typename left_adaptor_t,
typename right_adaptor_t>
215class combined_adaptor :
216 public adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>,
222 using base_type = adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>,
230 template <std::ranges::input_range urng_t,
231 typename left_adaptor_t_,
232 typename right_adaptor_t_>
233 static auto impl(urng_t && urange, left_adaptor_t_ && left_adaptor, right_adaptor_t_ && right_adaptor)
235 return std::forward<urng_t>(urange)
236 | std::forward<left_adaptor_t_>(left_adaptor)
237 | std::forward<right_adaptor_t_>(right_adaptor);
244 constexpr combined_adaptor() =
default;
245 constexpr combined_adaptor(combined_adaptor
const &)
noexcept =
default;
246 constexpr combined_adaptor(combined_adaptor &&) noexcept = default;
247 constexpr combined_adaptor & operator=(combined_adaptor const &) noexcept = default;
248 constexpr combined_adaptor & operator=(combined_adaptor &&) noexcept = default;
249 ~combined_adaptor() noexcept = default;
252 using base_type::base_type;
255 constexpr combined_adaptor(left_adaptor_t l, right_adaptor_t r) :
256 base_type{std::forward<left_adaptor_t>(l), std::forward<right_adaptor_t>(r)}
auto operator|(validator1_type &&vali1, validator2_type &&vali2)
Enables the chaining of validators.
Definition: validators.hpp:1120
SeqAn specific customisations in the standard namespace.
The <ranges> header from C++20's standard library.