22 namespace seqan3::detail
29 template <
typename left_adaptor_t,
typename right_adaptor_t>
30 class combined_adaptor;
77 template <
typename derived_type,
typename ...stored_args_ts>
85 template <
typename urng_t,
size_t... Is>
90 return static_cast<derived_type
const &
>(*this).impl(
91 std::forward<urng_t>(urange),
96 template <
typename urng_t,
size_t... Is>
100 return static_cast<derived_type &&
>(*this).impl(
101 std::forward<urng_t>(urange),
114 constexpr adaptor_base(adaptor_base
const &) noexcept =
default;
115 constexpr adaptor_base(adaptor_base &&) noexcept = default;
116 constexpr adaptor_base & operator=(adaptor_base const &) noexcept = default;
117 constexpr adaptor_base & operator=(adaptor_base &&) noexcept = default;
118 ~adaptor_base() noexcept = default;
121 constexpr adaptor_base(stored_args_ts ... args)
122 noexcept(noexcept(
std::tuple<stored_args_ts...>{std::forward<stored_args_ts>(args)...})) :
123 arguments{std::forward<stored_args_ts>(args)...}
128 template <std::ranges::input_range urng_t>
129 constexpr
auto operator()(urng_t && urange)
const &
135 template <std::ranges::input_range urng_t>
136 constexpr
auto operator()(urng_t && urange) &&
138 return std::move(*this).pass_args_to_impl(std::forward<urng_t>(urange),
153 template <
typename arg_t>
154 constexpr
friend auto operator|(arg_t && arg, derived_type
const & me)
156 if constexpr (std::ranges::input_range<arg_t>)
157 return me(std::forward<arg_t>(arg));
159 return combined_adaptor{std::forward<arg_t>(arg), me};
163 template <
typename arg_t>
164 constexpr
friend auto operator|(arg_t && arg, derived_type && me)
166 if constexpr (std::ranges::input_range<arg_t>)
167 return std::move(me)(std::forward<arg_t>(arg));
169 return combined_adaptor{std::forward<arg_t>(arg),
std::move(me)};
188 template <
typename arg_t>
189 constexpr
friend auto operator|(adaptor_base
const & me, arg_t && arg)
191 return combined_adaptor{
static_cast<derived_type
const &
>(me), std::forward<arg_t>(arg)};
195 template <
typename arg_t>
196 constexpr
friend auto operator|(adaptor_base && me, arg_t && arg)
198 return combined_adaptor{
static_cast<derived_type &&
>(me), std::forward<arg_t>(arg)};
216 template <
typename left_adaptor_t,
typename right_adaptor_t>
217 class combined_adaptor :
218 public adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>,
224 using base_type = adaptor_base<combined_adaptor<left_adaptor_t, right_adaptor_t>,
232 template <std::ranges::input_range urng_t,
233 typename left_adaptor_t_,
234 typename right_adaptor_t_>
235 static auto impl(urng_t && urange, left_adaptor_t_ && left_adaptor, right_adaptor_t_ && right_adaptor)
237 return std::forward<urng_t>(urange)
238 | std::forward<left_adaptor_t_>(left_adaptor)
239 | std::forward<right_adaptor_t_>(right_adaptor);
246 constexpr combined_adaptor() =
default;
247 constexpr combined_adaptor(combined_adaptor
const &) noexcept =
default;
248 constexpr combined_adaptor(combined_adaptor &&) noexcept = default;
249 constexpr combined_adaptor & operator=(combined_adaptor const &) noexcept = default;
250 constexpr combined_adaptor & operator=(combined_adaptor &&) noexcept = default;
251 ~combined_adaptor() noexcept = default;
254 using base_type::base_type;
257 constexpr combined_adaptor(left_adaptor_t l, right_adaptor_t r) :
258 base_type{std::forward<left_adaptor_t>(l), std::forward<right_adaptor_t>(r)}
290 template <
template <
typename,
typename ...>
typename view_type>
291 class adaptor_for_view_without_args :
public adaptor_base<adaptor_for_view_without_args<view_type>>
295 using base_type = adaptor_base<adaptor_for_view_without_args<view_type>>;
306 template <
typename ...arg_types>
307 static auto impl(arg_types && ... args)
309 return view_type{std::forward<arg_types>(args)...};
316 constexpr adaptor_for_view_without_args() =
default;
319 constexpr adaptor_for_view_without_args(adaptor_for_view_without_args
const &) noexcept =
default;
321 constexpr adaptor_for_view_without_args(adaptor_for_view_without_args &&) noexcept = default;
323 constexpr adaptor_for_view_without_args & operator=(adaptor_for_view_without_args const &) noexcept = default;
325 constexpr adaptor_for_view_without_args & operator=(adaptor_for_view_without_args &&) noexcept = default;
327 ~adaptor_for_view_without_args() noexcept = default;
330 using base_type::base_type;
368 template <typename functor_type, typename ...stored_args_ts>
369 class adaptor_from_functor :
370 public adaptor_base<adaptor_from_functor<functor_type, stored_args_ts...>, stored_args_ts...>
374 using base_type = adaptor_base<adaptor_from_functor<functor_type, stored_args_ts...>, stored_args_ts...>;
389 template <std::ranges::input_range urng_t>
390 constexpr
auto impl(urng_t && urange, stored_args_ts ... args)
const
392 return fun(std::forward<urng_t>(urange), std::forward<stored_args_ts>(args)...);
399 constexpr adaptor_from_functor() =
default;
400 constexpr adaptor_from_functor(adaptor_from_functor
const &) noexcept =
default;
401 constexpr adaptor_from_functor(adaptor_from_functor &&) noexcept = default;
402 constexpr adaptor_from_functor & operator=(adaptor_from_functor const &) noexcept = default;
403 constexpr adaptor_from_functor & operator=(adaptor_from_functor &&) noexcept = default;
404 ~adaptor_from_functor() noexcept = default;
407 constexpr adaptor_from_functor(functor_type f, stored_args_ts ... args) :
408 base_type{std::forward<stored_args_ts>(args)...}, fun{
std::move(f)}