70EDrB20333333333 "mޡҍۤa346>Ffߔao[!D%3(DBHl   ˣp$ a FAEA Qr1T9,! module concepts { umbrella "concepts" export * } module meta { umbrella "meta" export * } module range_v3 { umbrella "range" export * exclude header "range/v3/algorithm/tagspec.hpp" exclude header "range/v3/at.hpp" exclude header "range/v3/back.hpp" exclude header "range/v3/begin_end.hpp" exclude header "range/v3/data.hpp" exclude header "range/v3/distance.hpp" exclude header "range/v3/em : sin_(&sin) , str_{} , delim_(delim) { this->next(); // prime the pump } std::string & cached() noexcept { return str_; } }; /// \cond using getlines_range RANGES_DEPRECATED( "getlines_range has been renamed getlines_view") = getlines_view; /// \endcond struct getlines_fn { getlines_view operator()(std::istream & sin, char delim = '\n') const { return getlines_view{sin, delim}; .com/ericniebler/range-v3 // #ifndef RANGES_V3_VIEW_FOR_EACH_HPP #define RANGES_V3_VIEW_FOR_EACH_HPP #include #include #include #include #include #include #include #include #include #include #include #include # , fun_(std::move(fun)) {} }; #if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17 template(typename Rng, typename Fun)( requires copy_constructible) chunk_by_view(Rng &&, Fun) ->chunk_by_view, Fun>; #endif namespace views { struct chunk_by_base_fn { template(typename Rng, typename Fun)( requires viewable_range AND forward_range AND // indirect_relation>) l equal(cursor that) const { return !rng_->sin_ == !that.rng_->sin_; } }; void next() { if(!(*sin_ >> cached())) sin_ = nullptr; } cursor begin_cursor() { return cursor{this}; } public: istream_view() = default; explicit istream_view(std::istream & sin) : sin_(&sin) , obj_{} { next(); // prime the pump } Val & cached() noeename D = Derived)( requires same_as AND range) constexpr auto begin_cursor() const noexcept(noexcept(view_adaptor::begin_cursor_(std::declval()))) -> decltype(view_adaptor::begin_cursor_(std::declval())) { return view_adaptor::begin_cursor_(derived()); } template static constexpr adaptor_sentinel_t end_cursor_(D & d) noexcept(noexcept( adaptor_sentinel_t{stlval().read(std::declval()))) { using V = range_access::cursor_value_t; static_assert(common_reference_with, "In your adaptor, you've specified a value type that does not " "share a common reference type with the return type of read."); return this->data_.second().read(this->data_.first()); } template().next( RESS compressed_pair data_; public: base_adaptor_sentinel() = default; base_adaptor_sentinel(BaseSent sent, Adapt adapt) : data_{std::move(sent), std::move(adapt)} {} // All sentinels into adapted ranges have a base() member for fetching // the underlying sentinel. BaseSent base() const { return data_.first(); } protected: // Adaptor accessor Adapt & get() { return data_.second(); template using adapted_iterator_t = detail::decay_t>().begin(std::declval()))>; template using adapted_sentinel_t = detail::decay_t>().end(std::declval()))>; struct adaptor_base_current_mem_fn {}; template constexpr int which_adaptor_value_(priority_tag<0>) or.hpp> #include #include namespace ranges { /// \addtogroup group-views /// @{ template struct iter_take_while_view : view_adaptor, Rng, is_finite::value ? finite : unknown> { private: friend range_access; RANGES_NO_UNIQUE_ADDRESS semiregular_box_t pred_; template struct sentinel_adaptor : adaptor_base or_t>>...>) { // By returning true if *any* of the iterators are equal, we allow // zipped ranges to be of different lengths, stopping when the first // one reaches the last. return tuple_foldl(tuple_transform(its_, that.its_, detail::equal_to), false, [](bool a, bool b) { return a || b; }); } bool equal(sentinel const & s) constail::ignore_t, std::tuple>...> ends) : ends_(std::move(ends)) {} template(bool Other)( requires Const AND CPP_NOT(Other)) // sentinel(sentinel that) : ends_(std::move(that.ends_)) {} }; template struct cursor { private: friend struct cursor; using fun_ref_ = semiregular_box_ref_or_val_toutput_range /// - The range of filtered values /// - Is either a `forward_range` or the concept satisfied by the input /// - Is a `common_range` if the input is a `common_range` /// - Is not a `sized_range` or `borrowed_range` /// - Reference type: `T` /// struct filter_fn : filter_base_fn { using filter_base_fn::operator(); oj proj) const -> drop_while_view, composed> { return {all(static_cast(rng)), compose(std::move(pred), std::move(proj))}; } }; struct drop_while_bind_fn { template constexpr auto operator()(Pred pred) const // TODO: underconstrained { return make_view_closure( bind_back(drop_while_base_fn{}, std::move(pred))); ar_box_t pred_; detail::non_propagating_cache> begin_; iterator_t get_begin_() { if(!begin_) begin_ = find_if_not(rng_, std::ref(pred_)); return *begin_; } public: drop_while_view() = default; drop_while_view(Rng rng, Pred pred) : rng_(std::move(rng)) , pred_(std::move(pred)) {} iterator_t begin() { return get_begin_(); } sentinel_t is_finite::value ? finite : range_cardinality::value> , private detail::non_propagating_cache, drop_view, !random_access_range> { private: using difference_type_ = range_difference_t; Rng rng_; difference_type_ n_; template(bool Const = true)( requires Const AND range>) iterator_t> // get_begin_(std::trconstexpr iota_view operator()(Val from, Val to) const { return {from, to}; } }; /// \relates ints_fn /// \ingroup group-views RANGES_INLINE_VARIABLE(ints_fn, ints) } // namespace views namespace cpp20 { namespace views { using ranges::views::iota; } } // namespace cpp20 /// @} } // namespace ranges #include RANGES_SATISFY_BOOST_RANGE(::ranges::closed_hable_sentinel_t*/> struct RANGES_EMPTY_BASES iota_view : view_facade, same_as ? infinite : std::is_integral::value && std::is_integral::value ? finite : unknown> { private: friend range_access; From from_ = From(); RANGES_NO_UNIQUE_ADDRESS To to_ = To(); struct cursor; struct sentinel constexpr void check_bounds_(std::false_type) {} public: closed_iota_view() = default; constexpr closed_iota_view(meta::id_t from, meta::id_t to) : from_(std::move(from)) , to_(std::move(to)) { check_bounds_(meta::bool_>{}); } }; template RANGES_INLINE_VAR constexpr bool enable_borrowed_range> = true; #if RANGES_CXX_DEDUCTION_GUIDES >= Rge/v3/view/delimit.hpp> #include #include RANGES_DIAGNOSTIC_PUSH RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH RANGES_DIAGNOSTIC_IGNORE_TRUNCATION namespace ranges { /// \cond namespace detail { template struct promote_as_signed_ { // This shouldn't cause us to LOSE precision, but maybe it doesn't // net us any either. static_assert(sizeof(std::intmax_t) * CHAR_BIT >= N, concept template CPP_concept random_access_reservable = reservable && random_access_range; // clang-format on /// \cond namespace detail { template(typename T)( requires container) std::true_type is_lvalue_container_like(T &) noexcept { return {}; } template(typename T)( requires container) meta::not_> // is_lvalue_container_like(reference_wrapper) noexc_value_t>> ); /// \concept container /// \brief The \c container concept template CPP_concept container = semi_container && CPP_concept_ref(ranges::container_, T); /// \concept reservable_ /// \brief The \c reservable_ concept template CPP_requires(reservable_, requires(C & c, C const & cc) // ( c.reserve(ranges::size(c)), cc.capacity(), cc.max_size(), concepts::requires_)( requires forward_range AND erasable_range) Rng operator()(Rng && rng, diff_t from, diff_t to) const { RANGES_EXPECT(0 <= from && 0 <= to && from <= to); RANGES_EXPECT(!sized_range || to <= distance(rng)); ranges::actions::erase(rng, begin(rng), next(begin(rng), from)); like AND input_iterator

AND sentinel_for AND (!range)) // auto insert(Cont && cont, P p, I i, S j) // -> decltype(detail::insert_impl( static_cast(cont), static_cast

(p), static_cast(i), static_cast(j), meta::bool_ && // sized_sentinel_for>{})) { return detail::insert_impl(staticuto const delta = static_cast>(j - i); auto pos = insert_reserve_helper(cont, std::move(p), delta); return cont.insert(pos, C{std::move(i)}, C{std::move(j)}); } template(typename Cont, typename I, typename Rng)( requires range) auto insert_impl(Cont && cont, I p, Rng && rng, std::false_type) -> decltype(unwrap_reference(cont).insert( p, range_cpp17_iterator_t{ranges::begin(rng)}, requires lvalue_container_like AND range) insert_t push_back(Cont && cont, Rng && rng) { ranges::insert(cont, end(cont), static_cast(rng)); } /// \cond // clang-format off /// \concept can_push_back_frag_ /// \brief The \c can_push_back_frag_ concept template CPP_requires(can_push_back_frag_, requires(Rng && rng, T && t) // ( push_back(rng, (T &&) t) tible_to, range_difference_t>) Rng operator()(Rng && rng, Gen && gen) const { ranges::shuffle(rng, static_cast(gen)); return static_cast(rng); } /// \cond template invoke_result_t // operator()(Rng && rng, detail::reference_wrapper_ r) const { return (*this)(static_cast(rng), r.get()); ame Fun)( requires forward_range AND predicate> AND copy_constructible) std::vector> operator()(Rng && rng, Fun fun) const { return views::split_when(rng, std::move(fun)) | to>>(); } }; /// \relates actions::split_when_fn RANGES_INLINE_VARIABLE(split_when_fn, split_when) meta::if_c<(bool)ranges::container, // uncvref_t, std::vector>>; template constexpr auto operator()(Fun fun) const { return make_action_closure( bind_back(split_when_fn{}, static_cast(fun))); } // BUGBUG something is not right with the actions. It should be possible // to move a container into a split and have elements moved into the result. "action_access and actions::action<> are deprecated. Please " "replace action<> with action_closure<> and discontinue use of " "action_access.") = action_access_; template struct old_action_; struct make_action_fn_ { template constexpr old_action_ operator()(Fun fun) const { return old_action_{static_cast(fun)}; } }; using make_action_fn RANGES******************** // * When piping a range into an action, the range must be moved in. * // ************************************************************************** #endif // RANGES_WORKAROUND_CLANG_43400 template friend constexpr auto operator|(action_closure act, Pipeable pipe) -> CPP_broken_friend_ret(action_closure>)( requires (is_pipeable_v)) HPP #define RANGES_V3_ACTION_TAKE_WHILE_HPP #include #include #include #include #include #include #include #include #include namespace ranges { /// \addtogroup group-actions /// @{ namespace actions { struct take_while_fn { /// \addtogroup group-actions /// @{ namespace actions { struct drop_fn { template(typename Int)( requires detail::integer_like_) constexpr auto operator()(Int n) const { RANGES_EXPECT(n >= Int(0)); return make_action_closure(bind_back(drop_fn{}, n)); } template(typename Rng)( requires forward_range AND erasable_range, itereclval()))); template using insert_t = decltype(static_cast( ranges::insert(std::declval(), std::declval>(), std::declval()))); template(typename Cont, typename T)( requires lvalue_container_like AND (!range) AND constructible_from, T>) push_front_t push_front(Cont && cont, T && t) { unwrap_reference(cont).pulang__) && (defined(__CYGWIN__) || defined(__apple_build_version__))) // BUGBUG avoid unresolved __cxa_thread_atexit #define RANGES_CXX_THREAD_LOCAL RANGES_CXX_THREAD_LOCAL_PRE_STANDARD #else #define RANGES_CXX_THREAD_LOCAL RANGES_CXX_FEATURE(THREAD_LOCAL) #endif #endif #if !defined(RANGES_DEPRECATED) && !defined(RANGES_DISABLE_DEPRECATED_WARNINGS) #if defined(__GNUC__) && !defined(__clang__) // GCC's support for [[deprecated("message")]] is unusably buggy. #define RANGES_DEPRECATED(MSG) __attribute__((deprecated(MSG))) #elif RANGTEMPLATES #ifdef __cpp_variable_templates #define RANGES_CXX_VARIABLE_TEMPLATES __cpp_variable_templates #else #define RANGES_CXX_VARIABLE_TEMPLATES RANGES_CXX_FEATURE(VARIABLE_TEMPLATES) #endif #endif #if(defined(__cpp_lib_type_trait_variable_templates) && \ __cpp_lib_type_trait_variable_templates > 0) || \ RANGES_CXX_VER >= RANGES_CXX_STD_17 #define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 1 #else #define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 0 #endif #ifndef RANGES_CXX_ATTRIBUTE_DEPRECATED #ifdef __has_cpp_attribute #defie RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS \ RANGES_DIAGNOSTIC_IGNORE(4522) #define RANGES_DIAGNOSTIC_IGNORE_VOID_PTR_DEREFERENCE #define RANGES_DIAGNOSTIC_KEYWORD_MACRO #define RANGES_DIAGNOSTIC_SUGGEST_OVERRIDE #define RANGES_CXX_VER _MSVC_LANG #if _MSC_VER < 1920 || _MSVC_LANG < 201703L #error range-v3 requires Visual Studio 2019 with the /std:c++17 (or /std:c++latest) and /permissive- options. #endif #if _MSC_VER < 1927 #define RANGES_WORKAROUND_MSVC_895622 // Error when phase 1 name binding finds only ES_CXX_COROUTINES_TS1 201703L #define RANGES_CXX_DEDUCTION_GUIDES_11 0L #define RANGES_CXX_DEDUCTION_GUIDES_14 0L #define RANGES_CXX_DEDUCTION_GUIDES_17 201606L #define RANGES_CXX_IF_CONSTEXPR_11 0L #define RANGES_CXX_IF_CONSTEXPR_14 0L #define RANGES_CXX_IF_CONSTEXPR_17 201606L #define RANGES_CXX_ALIGNED_NEW_11 0L #define RANGES_CXX_ALIGNED_NEW_14 0L #define RANGES_CXX_ALIGNED_NEW_17 201606L // Implementation-specific diagnostic control #if defined(_MSC_VER) && !defined(__clang__) #define RANGES_DIAGNOSTIC_PUSH __pragma(warning(p/ #ifndef RANGES_V3_DETAIL_CONFIG_HPP #define RANGES_V3_DETAIL_CONFIG_HPP // Grab some version information. #ifndef __has_include #include #elif __has_include() #include #else #include #endif #if(defined(NDEBUG) && !defined(RANGES_ENSURE_MSG)) || \ (!defined(NDEBUG) && !defined(RANGES_ASSERT) && \ ((defined(__GNUC__) && !defined(__clang__) && \ (__GNUC__ < 5 || defined(__MINGW32__))) || \ defined(_MSVC_STL_VERSION))) #include #include name requires (!same_as, variant>) AND (all_convertible_to(0))) // variant(variant that) : detail::variant_data{} , index_(detail::variant_move_copy_(that.index(), data_(), std::move(that.data_()))) {} variant & operator=(variant && that) { // TODO do a simple move assign when index()==that.index() this->clear_(); this->assign_(detail::move(that)) elem_t * elem = nullptr; auto & data_var = detail::variant_core_access::data(var); detail::variant_visit_( var.index(), data_var, detail::get_fn{&elem}); return detail::variant_deref_(elem); } template friend meta::_t< std::add_lvalue_reference, N> const>> get(Variant const & var) { using elem_t = me struct variant_visitor { Fun fun_; Variant * var_; // clang-format off template auto CPP_auto_fun(operator())(indexed_element u) ( return compose(emplace_fn{var_}, fun_)(u) ) // clang-format on }; template variant_visitor make_variant_visitor( Variant & var, Fun fun) nle, Args...>::value) : tail{meta::size_t{}, ((Args &&) args)...} {} }; }; template using variant_data = meta::_t, meta::as_list>, meta::quote>>>; inline std::size_t variant_move_copy_(std::size_t, variant_nil, variant_nil) : datum_(static_cast(ts)...) {} template(typename U)( requires (!same_as) AND convertible_to) constexpr indexed_datum(indexed_datum that) // noexcept(std::is_nothrow_constructible::value) // : datum_(std::move(that.datum_)) {} constexpr auto ref() noexcept { return indexed_element{datum_}; } constexpr auto ref() conursor_, requires(S & s, C & c) // ( range_access::equal(c, s), concepts::requires_> )); /// \concept sentinel_for_cursor /// \brief The \c sentinel_for_cursor concept template CPP_concept sentinel_for_cursor = semiregular && cursor && CPP_requires_ref(detail::sentinel_for_cursor_, S, C); using type = decltype(range_access::mixin_base_2_(42)); }; public: template using single_pass_t = meta::_t>; template using contiguous_t = meta::_t>; template using mixin_base_t = meta::_t>; // clang-format off template static constexpr auto CPP_auto_fun(begin_cursor)(Rng &rng) ( return rng.begin_cursor() > struct range_const_iterator; /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3 /// views template struct range_value; /// \brief Boost Range specialisation point, for making Boost ranges out of range-v3 /// views template struct range_size; } // namespace boost /// \brief Macro specialising Boost Range metafunctions for the specified view #define RANGES_SATISFY_BOOST_RANGE(view_name) \ na requires copy_constructible) constexpr forward_tuple_interface(TupleLike const & base) noexcept( std::is_nothrow_copy_constructible::value) : TupleLike(base) {} #endif // clang-format off template friend constexpr auto CPP_auto_fun(get)( forward_tuple_interface &wb) ( return detail::adl_get(static_cast(wb)) iter_common_reference_t> AND indirectly_copyable AND mergeable) I operator()(I first, iter_difference_t n, B buff, C r = C{}, P p = P{}) const { auto half = n / 2; if(0 == half) return next(first, n); I m = (*this)(first, half, buff, r, p); (*this)(m, n - half, buff, r, p); return merge_n_with_buffer(first, half, m, n - ALGORITHM_AUX_SORT_N_WITH_BUFFER_HPP #include #include #include #include #include #include #include #include #include #include namespace ranges { namespace aux { struct sort_n_with_buffer_fn constexpr bool operator()(T && t) const { return !invoke(pred_, val_, static_cast(t)); } }; template constexpr upper_bound_predicate make_upper_bound_predicate(Pred & pred, Val & val) { return {pred, val}; } } // namespace detail /// \endcond namespace aux { struct upper_bound_n_fn namespace ranges #include #endif /// \file // Range v3 library // // Copyright Eric Niebler 2014-present // Copyright Casey Carter 2015 // // Use, modification and distribution is subject to the // Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Project home: https://github.com/ericniebler/range-v3 // #ifndef RANGES_V3_ALGORITHM_MIN_HPP #define RANGES_V3_ALGORITHM_MIN_HPP #include #incexpr minmax_element_result // RANGES_FUNC(minmax_element)(I first, S last, C pred = C{}, P proj = P{}) // { minmax_element_result result{first, first}; if(first == last || ++first == last) return result; if(invoke(pred, invoke(proj, *first), invoke(proj, *result.min))) result.min = first; else result.max = first; while(++first != last) { I tmp = first; if(++fir iterator_t first = ranges::begin(rng); auto const n = distance(rng); if(n > 1) // start from the first parent, there is no need to consider children for(auto start = (n - 2) / 2; start >= 0; --start) detail::sift_down_n( first, n, first + start, ranges::ref(pred), ranges::ref(proj)); return first + n; } RANGES_FUNC_END(make_heap) namespace cpp20 { using ranges::make_heap; }ild = start - first; if(len < 2 || (len - 2) / 2 < child) return; child = 2 * child + 1; I child_i = first + child; if((child + 1) < len && invoke(pred, invoke(proj, *child_i), invoke(proj, *(child_i + 1)))) { // right-child exists and is greater than left-child ++child_i; ++child; } // check if we are in heap-order er_difference_t n, C pred = C{}, P proj = P{}) const { return is_heap_until_n(first, n, std::move(pred), std::move(proj)) == first + n; } }; RANGES_INLINE_VARIABLE(is_heap_n_fn, is_heap_n) } // namespace detail /// \endcond /// \addtogroup group-algorithms /// @{ RANGES_FUNC_BEGIN(is_heap_until) /// \brief function template \c is_heap_until es input_range AND input_range AND indirect_strict_weak_order, P0>, projected, P1>>) constexpr bool RANGES_FUNC(lexicographical_compare)(Rng0 && rng0, Rng1 && rng1, C pred = C{}, P0 pro*mid, mid is after the target range. auto && v = *mid; auto && pv = invoke(proj, (decltype(v) &&)v); if(invoke(pred, val, pv)) { return aux::equal_range_n( std::move(first), dist, val, ranges::ref(pred), ranges::ref(proj)); } else if(!invoke(pred, pv, val)) { // *mid == val: the lower bound is <= mid, and the upper bound is > // mid. constexpr move_result, O> // RANGES_FUNC(move)(Rng && rng, O out) // { return (*this)(begin(rng), end(rng), std::move(out)); } RANGES_FUNC_END(move) RANGES_HIDDEN_DETAIL(CPP_PP_RBRACE()) #ifndef RANGES_DOXYGEN_INVOKED struct RANGES_EMPTY_BASES move_fn : aux::move_fn , _move::move_fn { using aux::move_fn::operator(); using _move::move_fn::operator(); }; RANGES_INLINE_VARIABLE(move_fn, move) #endif nmove(op)); } RANGES_FUNC_END(fold_left) RANGES_FUNC_BEGIN(fold_left_first) template(typename I, typename S, typename Op)( requires sentinel_for AND input_iterator AND indirectly_binary_left_foldable, I> AND constructible_from, iter_reference_t>) // constexpr auto RANGES_FUNC(fold_left_first)(I first, S last, Op op) { using U = invoke_result_t(i, nth, last, pred); first = i; continue; turn end_orig; } // len > limit >= 3 I m = first + len / 2; I lm1 = last; unsigned n_swaps = detail::sort3(first, m, --lm1, pred, proj); // *m is median // partition [first, m) < *m and *m <= [m, last) //(this inhibits tossing elements equivalent to m around unnecessarily) I i = first; I j = lm1; // j points beyond range to be tested, *lm1 is known to be <= *go before here I1 l1 = end1; I2 l2 = end2; --l2; while(true) { do if(start == l1) return {end1, end1}; while(!invoke(pred, invoke(proj, *--l1), *l2)); I1 m1 = l1; I2 m2 = l2; do if(m2 == begin2) return {m1, ++l1}; // no need to check range on m1 because s guarantees we have enough source // Otherwise if source exhausted, pattern not found else if(m1 == begin1) return {end1, end1}; // if there is a mismatch, restart with a new l1 // else there is a match, check next elements while(invoke(pred, invoke(proj, *--m1), *--m2)); } } template constexpr subrange find_end_impl(I1 begin1, I1 end1, I2 begin2, I2 end2, R pred, ight notice and this permission notice // appear in supporting documentation. The authors make no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied // warranty. // // Algorithms from // Elements of Programming // by Alexander Stepanov and Paul McJones // Addison-Wesley Professional, 2009 #ifndef RANGES_V3_ALGORITHM_MERGE_HPP #define RANGES_V3_ALGORITHM_MERGE_HPP #include #include #include ed // not actually compute the end of [I1,S0); therefore, it is not necessarily // losing information. E.g., if begin0 == end0, we can return begin0 immediately. // If we returned pair, we would need to do an O(N) scan to find the // end position. /// \brief function template \c find_first_of template(typename I0, typename S0, typename I1, typename S1, typename R = equal_to, typename P0 = iden return {first, middle}; } return detail::rotate_(first, middle, last, iterator_tag_of{}); } /// \overload template(typename Rng, typename I = iterator_t)( requires range AND permutable) constexpr borrowed_subrange_t RANGES_FUNC(rotate)(Rng && rng, I middle) // { return (*this)(begin(rng), std::move(middle), end(rng)); } RANGES_FUNC_END(rotate) namespace cpp20 { using ranges::rotate; }r_move(i); ++first; } } *first = iter_move(i); ++first; return first; } /// \overload template(typename Rng, typename Pred, typename Proj = identity)( requires forward_range AND indirect_relation, Proj>> AND permutable>) constexpr borrowed_iterator_t RANGES_FUNC(adjacent_remove_if)(Rng && rng, Pred pred, Proj proj = uid{}; using param_t = typename decltype(uid)::param_type; while(++mid != last) { RANGES_ENSURE(mid - first <= PTRDIFF_MAX); if(auto const i = uid(gen, param_t{0, D2(mid - first)})) ranges::iter_swap(mid - i, mid); } return mid; } /// \overload template(typename Rng, typename Gen = detail::default_random_engine &)( requires random_access_range AND permutable> AND { for(I i = first; i != last; ++i) detail::unguarded_linear_insert(i, iter_move(i), pred, proj); } constexpr int introsort_threshold() { return 16; } template inline constexpr void final_insertion_sort(I first, I last, C & pred, P & proj) { if(last - first > detail::introsort_threshold()) { detail::insertion_sort( first, first + detail T min; U max; RANGES_ALGO_RESULT_AUX_2(min_max_result, T, min, U, max) }; template struct in1_in2_out_result { I1 in1; I2 in2; O out; RANGES_ALGO_RESULT_AUX_3(in1_in2_out_result, I1, in1, I2, in2, O, out) }; template struct in_out1_out2_result { I in; O1 out1; O2 out2; fine RANGES_ALGO_RESULT_AUX_2(C, T1, M1, T2, M2) \ template(typename X, typename Y)( \ requires convertible_to AND convertible_to) \ operator C() const & \ { \ return {M1, M2}; \ } typename P1 = identity, typename P2 = identity)( requires sentinel_for AND sentinel_for AND mergeable) constexpr set_difference_result RANGES_FUNC(set_difference)(I1 begin1, S1 end1, I2 begin2, S2 end2, end(rng1), begin(rng2), end(rng2), std::move(pred), std::move(proj1), std::move(proj2)); } RANGES_FUNC_END(includes) namespace cpp20 { using ranges::includes; } template using set_union_result = detail::in1_in2_out_result; RANGES_FUNC_BEGIN(set_union) /// \brief function template \c set_union ult = detail::in_out_result; RANGES_FUNC_BEGIN(replace_copy) /// \brief function template \c replace_copy template(typename I, typename S, typename O, typename T1, typename T2, typename P = identity)( requires input_iterator AND sentinel_for AND output_iterator AND indirectly_copyable AND indirect_relation, T1 const *>) P proj, std::input_iterator_tag, std::false_type) { if(first != last) { // Must save a copy into a local because we will need this value // even after we advance the input iterator. iter_value_t value = *first; // This is guaranteed by indirectly_copyable *out = value; ++out; ename F> using generate_n_result = detail::out_fun_result; RANGES_FUNC_BEGIN(generate_n) /// \brief function template \c generate_n template(typename O, typename F)( requires invocable AND output_iterator>) constexpr generate_n_result // RANGES_FUNC(generate_n)(O first, iter_difference_t n, F fun) { RANGES_EXPECT(n >= 0); auto norig = n; auto b = uncounted(first); for(; 0 != n; ++ auto buf_size = ranges::min(len1, len2_and_end.first); std::pair buf{nullptr, 0}; std::unique_ptr h; if(detail::is_trivially_copy_assignable_v && 8 < buf_size) { buf = detail::get_temporary_buffer(buf_size); h.reset(buf.first); } detail::merge_adaptive(std::move(first), std::move(middle), I m1; // "median" of [first, middle) I m2; // "median" of [middle, last) D len11; // distance(first, m1) D len21; // distance(middle, m2) // binary search smaller range if(len1 < len2) { // len >= 1, len2 >= 2 len21 = len2 / 2; m2 = next(middle, len21); m1 = upper_bound(first, middle, , range_value_t *>) constexpr range_value_t // RANGES_FUNC(max)(Rng && rng, C pred = C{}, P proj = P{}) // { auto first = ranges::begin(rng); auto last = ranges::end(rng); RANGES_EXPECT(first != last); range_value_t result = *first; while(++first != last) { auto && tmp = *first; if(invoke(pred, invoke(proj, result), invoke(proj, tmp))) result = (decltype(tmp) &&)tmp;_BEGIN(find_if_not) /// \brief template function \c find_if_not /// /// range-based version of the \c find_if_not std algorithm /// /// \pre `Rng` is a model of the `range` concept /// \pre `I` is a model of the `input_iterator` concept /// \pre `S` is a model of the `sentinel_for` concept /// \pre `P` is a model of the `invocable` concept, where `V` is the /// value type of I. /// \pre `F` models `predicate`, where `X` is the result type detail::merge_sort_loop(first, last, buffer, step_size, pred, proj); step_size *= 2; goto loop; } // buffer points to raw memory template void stable_sort_adaptive(I first, I last, V * buffer, std::ptrdiff_t buffer_size, C & pred, P & proj) { iter_difference_t len = (last - first + 1) / 2; I middle = first + len; if(len > buffer_size) // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Hewlett-Packard Company makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // // Copyright (c) 1996 // Silicon Graphic RANGES_FUNC(partition_point)(I first, S last, C pred, P proj = P{}) { if(RANGES_CONSTEXPR_IF(sized_sentinel_for)) { auto len = distance(first, std::move(last)); return aux::partition_point_n( std::move(first), len, std::move(pred), std::move(proj)); } // Probe exponentially for either last-of-range or an iterator // that is past the partition point (i.e., does not satisfy pred). auto len = iteremplate \c for_each_n template(typename I, typename F, typename P = identity)( requires input_iterator AND indirectly_unary_invocable>) constexpr I RANGES_FUNC(for_each_n)(I first, iter_difference_t n, F fun, P proj = P{}) { RANGES_EXPECT(0 <= n); auto norig = n; auto b = uncounted(first); for(; 0 < n; ++b, --n) invoke(fun, invoke(proj, *b)); return recounted(first, b, norig); ires sortable AND random_access_iterator AND sentinel_for) constexpr I RANGES_FUNC(partial_sort)( I first, I middle, S last, C pred = C{}, P proj = P{}) // { make_heap(first, middle, ranges::ref(pred), ranges::ref(proj)); auto const len = middle - first; I i = middle; for(; i != last; ++i) { if(invoke(pred, invoke(proj, *i), invoke(proj, *first))) { iter_swap(i proj2, *m2))) // if there is a mismatch, restart with a new begin1 { ++begin1; break; } // else there is a match, check next elements } } } } // namespace detail /// \endcond RANGES_FUNC_BEGIN(search) /// \brief function template \c search template(typename I1, typename S1, typename I2, ++begin1; --d1; } // *begin1 matches *begin2, now match elements after here auto m1 = begin1; I2 m2 = begin2; while(true) { if(++m2 == end2) // If pattern exhausted, begin1 is the answer (works // for 1 element pattern) { return {recounted(begin1_, std::move(begin1), d1_ - d1), reco // Move falses back into range, but don't mess up first which points to // first false ranges::move(p.first, res.out2.base().base(), first); // h destructs moved-from values out of the temp buffer, but doesn't // deallocate buffer return first; } // Else not enough buffer, do in place // len >= 4 I middle = first; D half = len / 2; // half >= 2 advance(middle, half); detail::stable_partition_impl(first, middle, pred, proj, half, p, fi); // TTTFFFFF?????????? // f ff m l // recurse on [middle, last], except increase middle until *(middle) is false, // *last know to be true I m1 = middle; D len_half = len - half; while(invoke(pred, invoke(proj, *m1))) { if(++m1 == last) return ranges::rotate(begin_false, middle, last).begin(); --len_half; 1 = identity)( requires input_iterator AND sentinel_for AND input_iterator AND sentinel_for AND weakly_incrementable AND copy_constructible AND indirectly_writable< O, indirect_result_t, projected>>) constexpr binary_transform_result // RANGES_FUNC(transform)(I0 begin0, S0 end0, I1 begiectly_comparable, iterator_t, C, P0, P1>) constexpr bool RANGES_FUNC(ends_with)( Rng0 && rng0, Rng1 && rng1, C pred = C{}, P0 proj0 = P0{}, P1 proj1 = P1{}) // { const auto drop = distance(rng0) - distance(rng1); if(drop < 0) return false; return equal(next(begin(rng0), drop), end(rng0), begin(rng1), end(rng1), std::move(pred), uniform_random_bit_generator> AND (random_access_iterator || forward_range || sized_range)) sample_result, O> RANGES_FUNC(sample)( Rng && rng, O out, iter_difference_t const n, Gen && gen = detail::get_random_engine()) // { if(RANGES_CONSTEXPR_IF(forward_range || sized_range)) // { return detail::sample_sized_impl(begin(rng), tility/tagged_pair.hpp> RANGES_DEPRECATED_HEADER( "This file is deprecated. Please discontinue using the tag types defined here and " "define your own.") #include namespace ranges { /// \cond RANGES_DEFINE_TAG_SPECIFIER(in) RANGES_DEFINE_TAG_SPECIFIER(in1) RANGES_DEFINE_TAG_SPECIFIER(in2) RANGES_DEFINE_TAG_SPECIFIER(out) RANGES_DEFINE_TAG_SPECIFIER(out1) RANGES_DEFINE_TAG_SPECIFIER(out2) RANGES_DEFINE_TAG_SPECIFIER(fun) RANGES_DEFINE_TAG_SPECIFIER(min) return partition_point(std::move(first), std::move(last), detail::make_lower_bound_predicate(pred, val), std::move(proj)); } /// \overload template(typename Rng, typename V, typename C = less, typename P = identity)( requires forward_range AND indirect_strict_weak_order, P>>) constexpr borrowed_iterator_t // v3 library // // Copyright Eric Niebler 2013-present // Copyright Gonzalo Brito Gadeschi 2014 // // Use, modification and distribution is subject to the // Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Project home: https://github.com/ericniebler/range-v3 // // Implementation based on the code in libc++ // http://http://libcxx.llvm.org/ #ifndef RANGES_V3_ALGORITHM_IS_SORTED_UNTIL_HPP #define RANGES_V3_ALGORITHM_IS_SORTED_UNTIL_HPP #e> AND indirectly_copyable) constexpr replace_copy_if_result RANGES_FUNC(replace_copy_if)( I first, S last, O out, C pred, T const & new_value, P proj = {}) // { for(; first != last; ++first, ++out) { auto && x = *first; if(invoke(pred, invoke(proj, x))) *out = new_value; else *out = (decltype(x) &&)x; } return {first, out};ename D, typename V, typename C, typename P> constexpr subrange search_n_impl(I first, S last, D cnt, V const & val, C & pred, P & proj) { while(true) { // Find first element in sequence 1 that matches val, with a mininum of // loop check_swap(i, j); ranges::reverse(ip1, last); return true; } if(i == first) { ranges::reverse(first, last); return false; } } } /// \overload template(typename Rng, typename C = less, typename P = identity)( requires bidirectional_range AND sortable, C, P>) constexpr bool RANGES_FUNC(prev_permutation)(Rng && rng, C preame Rng1, typename I2Ref, typename C = equal_to, typename P1 = identity, typename P2 = identity)( requires forward_range AND forward_iterator> AND indirectly_comparable, uncvref_t, C, P1, P2>) RANGES_DEPRECATED( "Use the variant of ranges::is_permutation that takes an upper bound " "for both sequences") bool RANGES_FUNC(is_permutation)(ranges::mismatch(begin1, end1, begin2, end2, pred, proj1, proj2); begin1 = mismatch.in1; begin2 = mismatch.in2; if(begin1 == end1 || begin2 == end2) { return begin1 == end1 && begin2 == end2; } // begin1 != end1 && begin2 != end2 && *begin1 != *begin2 auto l1 = distance(begin1, end1); auto l2 = distance(begin2, end2); if(l1 != l2) return false; // For each element in [f1, l1) see iame I, typename O> using copy_backward_result = detail::in_out_result; RANGES_FUNC_BEGIN(copy_backward) /// \brief function template \c copy_backward template(typename I, typename S, typename O)( requires bidirectional_iterator AND sentinel_for AND bidirectional_iterator AND indirectly_copyable) constexpr copy_backward_result RANGES_FUNC(copy_backward)(I first, S end_, O out) { I i = ranges::next(first, end_), last = i; if(!invoke(pred, invoke(proj, *first))) break; return first == last; } /// \overload template(typename Rng, typename F, typename P = identity)( requires input_range AND indirect_unary_predicate, P>>) constexpr bool RANGES_FUNC(all_of)(Rng && rng, F pred, P proj = P{}) // { return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj)); } RANGES_FUNC_END(all_of) > AND permutable AND indirect_unary_predicate>) constexpr I RANGES_FUNC(unstable_remove_if)(I first, I last, C pred, P proj = {}) { while(true) { first = find_if(std::move(first), last, ranges::ref(pred), ranges::ref(proj)); if(first == last) return first; last = next(find_if_not(make_reverse_iterator(std::move(last)), make_reverse_iterator(next(first)out) *out = *--last; return {res, out}; } /// \overload template(typename Rng, typename O)( requires bidirectional_range AND weakly_incrementable AND indirectly_copyable, O>) constexpr reverse_copy_result, O> // RANGES_FUNC(reverse_copy)(Rng && rng, O out) // { return (*this)(begin(rng), end(rng), std::move(out)); } RANGES_FUNC_END(reverse_copy) erator AND sentinel_for AND indirect_strict_weak_order>) constexpr bool RANGES_FUNC(binary_search)( I first, S last, V const & val, C pred = C{}, P proj = P{}) { first = lower_bound(std::move(first), last, val, ranges::ref(pred), ranges::ref(proj)); return first != last && !invoke(pred, val, invoke(proj, *first)); } /// \overload template(typename Rng, typename V, typename C = less, typ group-algorithms /// @{ RANGES_FUNC_BEGIN(adjacent_find) /// \brief function template \c adjacent_find /// /// range-based version of the \c adjacent_find std algorithm /// /// \pre `Rng` is a model of the `range` concept /// \pre `C` is a model of the `BinaryPredicate` concept template(typename I, typename S, typename C = equal_to, typename P = identity)( requires forward_iterator AND sentinel_for AND indirect_relation RANGES_FUNC(mismatch)(I1 begin1, S1 end1, I2 begin2, C pred = C{}, P1 proj1 = P1{}, P2 proj2 = P2{}) // { for(; begin1 != end1; ++begin1, ++begin2) if(!invoke(pred, invoke(proj1, *begin1), invoke(proj2, *begin2)))lude #include #include #include #include #include #include #include #include #include #include #include #include #include sentinel_for AND sentinel_for AND equality_comparable_with) bool operator==(common_iterator const & x, common_iterator const & y) { return detail::cidata(x).index() == 1u ? (detail::cidata(y).index() == 1u || ranges::get<0>(detail::cidata(y)) == ranges::get<1>(detail::cidata(x))) : (detail::cidata(y).index() == 1u ? ranges::get<0>(detail::cidata(x)) == _t; common_iterator() = default; common_iterator(I i) : data_(emplaced_index<0>, std::move(i)) {} common_iterator(S s) : data_(emplaced_index<1>, std::move(s)) {} template(typename I2, typename S2)( requires convertible_to AND convertible_to) common_iterator(common_iterator const & that) : data_(detail::variant_core_access::make_empty()) { detail::cidata(that).visit_i(emplace_fn{&data_order_ concept template(typename C, typename I1, typename P1, typename I2, typename P2)( concept (projected_indirect_strict_weak_order_)(C, I1, P1, I2, P2), indirect_strict_weak_order, projected> ); template CPP_concept mergeable = input_iterator && input_iterator && weakly_incrementable && indirectly_copyable && copy_constructible && CPP_concept_ref(ranges::indirect_strict_weak_order_, F, I1, I2); // clang-format on ////////////////////////////////////////////////////////////////////////////////////// // projected struct, for "projecting" a readable with a unary callable /// \cond namespace detail { RANGES_DIAGNOSTIC_PUSH RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL template struct projected_ { struct type ncept_ref(ranges::indirectly_regular_unary_invocable_, F, I); /// \cond // Non-standard indirect invocable concepts /// \concept indirectly_binary_invocable_impl_ /// \brief The \c indirectly_binary_invocable_impl_ concept template(typename F, typename I1, typename I2)( concept (indirectly_binary_invocable_impl_)(F, I1, I2), invocable &, iter_value_t &> AND invocable &, iter_reference_t> AND invocable, iterordered && sized_sentinel_for && CPP_requires_ref(ranges::random_access_iterator_, I) && CPP_concept_ref(ranges::with_category_, I, std::random_access_iterator_tag); /// \concept contiguous_iterator_ /// \brief The \c contiguous_iterator_ concept template(typename I)( concept (contiguous_iterator_)(I), std::is_lvalue_reference>::value AND same_as, uncvref_t>> AND derived_from, rence_t &&, iter_value_t const &> ); /// \concept indirectly_readable /// \brief The \c indirectly_readable concept template CPP_concept indirectly_readable = // CPP_concept_ref(ranges::readable_, uncvref_t); template RANGES_DEPRECATED("Please use ranges::indirectly_readable instead") RANGES_INLINE_VAR constexpr bool readable = // indirectly_readable; /// \concept writable_ /// \brief The \c writable_ concept template using iter_traits_t = meta::conditional_t, std::iterator_traits, I>; #if defined(_GLIBCXX_DEBUG) template(typename I, typename T, typename Seq)( requires same_as>) auto iter_concept_(__gnu_debug::_Safe_iterator, priority_tag<3>) -> ranges::contigu> struct ostream_joiner { CPP_assert(semiregular); using difference_type = std::ptrdiff_t; using char_type = Char; using traits_type = Traits; using ostream_type = std::basic_ostream; constexpr ostream_joiner() = default; ostream_joiner(ostream_type & s, Delim const & d) : delim_(d) , sout_(std::addressof(s)) , first_(true) TQual, UQual> : basic_common_reference<::ranges::detail::cursor_reference_t, ::ranges::detail::cursor_reference_t, TQual, UQual> {}; // common_type specializations for basic_proxy_reference template struct common_type<::ranges::detail::basic_proxy_reference_, U> : common_type<::ranges::range_access::cursor_value_t, U> {}; template struct common_type) constexpr typename basic_iterator::difference_type // operator-(basic_iterator const & left, S const & right) { return -(right - left); } // Asymmetric comparisons template(typename Left, typename Right)( requires detail::sized_sentinel_for_cursor) constexpr bool operator<(basic_iterator const & left, typename OtherCur)( requires (!same_as) AND convertible_to) constexpr basic_iterator & operator=(basic_iterator that) { pos() = std::move(that.pos()); return *this; } CPP_member constexpr auto operator*() const noexcept(noexcept(range_access::read(std::declval()))) -> CPP_ret(const_reference_t)( requires detail::readable_cursor && (!detail:ss::cursor_value_t; using reference = iter_reference_t; using iterator_concept = cpp20_iter_cat_of_t; using pointer = meta::_t< meta::conditional_t< (bool)has_cursor_arrow, meta::defer, std::add_pointer>>; using common_reference = common_reference_t; iterator_associated_types_base_() = default; using readable_itera forward_cursor, // std::forward_iterator_tag, // std::input_iterator_tag>>>>>; // clang-format off /// \concept cpp17_input_cursor_ /// \brief The \c cpp17_input_cursor_ concept template(typename C)( concept (cpp17_input_cursor_)(C), // Either it is not single-pass, or else we can create a // proxy for postfix increment. !range_access::single_pass_t>::val using cursor_value_t = typename cursor_traits::value_t_; template struct basic_proxy_reference_; template using basic_proxy_reference = basic_proxy_reference_>; // The One Proxy Reference type to rule them all. basic_iterator uses this // as the return type of operator* when the cursor type has a set() member // function of the correct signature (i.e., if it can accept a value_ requires indirectly_writable>) void write(T && t) const noexcept(noexcept(*it_ = std::move(t))) { *it_ = std::move(t); } CPP_member auto read() const noexcept(noexcept(*std::declval())) -> CPP_ret(iter_reference_t)( requires indirectly_readable) { return *it_; } CPP_member auto equal(move_into_cursor const & that) constor-=(difference_type n) // -> CPP_ret(move_iterator &)( requires random_access_iterator) { current_ -= n; return *this; } CPP_member auto operator[](difference_type n) const // -> CPP_ret(reference)( requires random_access_iterator) { return iter_move(current_ + n); } template friend auto operator==(move_iterator const & x, move_iterator const & y) rsor &&>(cur)) {} constexpr explicit mixin(reverse_cursor const & cur) : basic_mixin(cur) {} #endif constexpr mixin(I it) : mixin{reverse_cursor{it}} {} constexpr I base() const { return this->get().base(); } }; I it_; constexpr reverse_cursor(I it) : it_(std::move(it)t_inserter_fn, front_inserter) template struct insert_iterator { using container_type = Container; using difference_type = std::ptrdiff_t; constexpr insert_iterator() = default; constexpr explicit insert_iterator(Container & x, typename Container::iterator w) : container_(detail::addressof(x)) , where_(w) {} insert_iterator & operator=(typename Container::value_type const & value) { where_ = ranges::next(contain requires indirectly_swappable) { return ranges::iter_swap(_counted_iterator_::access::current(x), _counted_iterator_::access::current(y)); } } // namespace _counted_iterator_ #endif /// endcond template(typename I1, typename I2)( requires common_with) constexpr bool operator==(counted_iterator const & x, counted_iterator const & y) { return x.count() == y.count(); stexpr counted_iterator & operator++() { RANGES_EXPECT(cnt_ > 0); ++current_; --cnt_; return *this; } #ifdef RANGES_WORKAROUND_MSVC_677925 template(typename I2 = I)( requires (!forward_iterator)) // constexpr auto operator++(int) -> decltype(std::declval()++) #else // ^^^ workaround ^^^ / vvv no workaround vvv CPP_member constexpr auto operator++(int) // -> CPP_ret(decltype(std::declval()++))( xpr auto operator!=(unreachable_sentinel_t, I const &) noexcept -> CPP_broken_friend_ret(bool)( requires weakly_incrementable) { return true; } }; RANGES_INLINE_VARIABLE(unreachable_sentinel_t, unreachable) namespace cpp20 { using ranges::unreachable; using ranges::unreachable_sentinel_t; } // namespace cpp20 /// @} } // namespace ranges #include #endif // RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP }; #if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17 template<> inline constexpr bool _is_integer_like_ = true; #else template constexpr bool _is_integer_like_ = true; #endif } // namespace detail /// \endcond } // namespace ranges /// \cond RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS namespace std { template<> struct numeric_limits<::ranges::detail::diffmax_t> { static constexpr bool is_specialized = truet { return _normalize( bool(a.neg_ ^ b.neg_), compl_if(bool(a.neg_ ^ b.neg_), compl_if(a.neg_, a.val_) ^ compl_if(b.neg_, b.val_))); } friend constexpr diffmax_t operator<<(diffmax_t a, diffmax_t b) noexcept { RANGES_ENSURE(!a.neg_); return b.neg_ ? diffmax_t{tag{}, false, a.val_ >> b.val_} : diffmax_t{tag{}, false, a.val_ << b.val_}; trying to compute the distance of an infinite range: RANGES_EXPECT(!is_infinite::value); return enumerate_fn::impl_r( rng, common_range_tag_of(), sized_range_tag_of()); } }; /// \sa `enumerate_fn` RANGES_INLINE_VARIABLE(enumerate_fn, enumerate) struct distance_fn : iter_distance_fn { private: template static range_difference_t impl_r(Rng & rng, range_tag) { return enumerate(rng).first; ce_t d = 0; for(; first != last; ++first) ++d; return {d, first}; } template(typename I, typename S)( requires sized_sentinel_for) static constexpr std::pair, I> // impl_i(I first, S end_, sentinel_tag) { I last = ranges::next(first, end_); auto n = static_cast>(last - first); RANGES_EXPECT(((bool)same_as || 0 <= n)); return {n, last}; I bound, sentinel_tag, std::bidirectional_iterator_tag) { if(0 <= n) for(; 0 != n && it != bound; --n) ++it; else for(; 0 != n && it != bound; ++n) --it; return n; } template constexpr iter_difference_t advance_fn::bounded_(I & it, iter_difference_t n, S bound, sized_s /// \cond template // requires input_or_output_iterator struct counted_iterator; /// \endcond struct advance_fn { #if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17 template(typename I)( requires input_or_output_iterator) constexpr void operator()(I & i, iter_difference_t n) const // [[expects: n >= 0 || bidirectional_iterator]] { if constexpr(random_access_iterator) { i += n; _movable_storable, implement as: // iter_value_t tmp = iter_move(a); // *a = iter_move(b); // *b = std::move(tmp); template constexpr detail::enable_if_t< !is_adl_indirectly_swappable_v && !is_swappable_with, iter_reference_t>::value && is_indirectly_movable_v && is_indirectly_movable_v> operator()(I0 && a, I1 && b) constusing size_type_t RANGES_DEPRECATED("size_type_t is deprecated.") = detail::iter_size_t; /// \endcond namespace cpp20 { using ranges::iter_common_reference_t; using ranges::iter_difference_t; using ranges::iter_reference_t; using ranges::iter_rvalue_reference_t; using ranges::iter_value_t; // Specialize these in the ranges:: namespace using ranges::disable_sized_sentinel; template using incrementable_traits = ranges::incremendard iterator tags") = std::bidirectional_iterator_tag; using random_access_iterator_tag RANGES_DEPRECATED( "Please switch to the standard iterator tags") = std::random_access_iterator_tag; /// \endcond struct contiguous_iterator_tag : std::random_access_iterator_tag {}; /// \cond namespace detail { template, typename R = decltype(iter_move(std::declval())), typename = R &> using iter_rvalue_reference_t = R; P proj = P{}) const { // BUGBUG think about the use of coerce here. using V = iter_value_t; using X = invoke_result_t

; coerce v; coerce x; if(first != last && result != end_result) { auto t1(x(invoke(proj, v(*first)))); *result = t1; for(++first, ++result; first != last && result != end_result; ++first, ++result)me Op = plus, typename P = identity)( requires input_range AND indirectly_binary_invocable_, P>> AND assignable_from< T &, indirect_result_t, P>>>) T operator()(Rng && rng, T init, Op op = Op{}, P proj = P{}) const { return (*this)( begin(rng), end(rng), std::move(init), std::move(op), std::move(proj)); } }; RANGES_INLINE_VARIABLE(acOp2 = multiplies, typename P1 = identity, typename P2 = identity, typename I1 = iterator_t, typename I2 = iterator_t)( requires range AND range AND inner_product_constraints) T operator()(Rng1 && rng1, Rng2 && rng2, T init, BOp1 bop1 = BOp1{}, BOp2 bop2 = BOp2{}, P1 proj1 = P1{}, P2 proj2 = P2{}) const { return (*this)(begin(rng1), end(rng1), template(typename Rng)( requires range AND (!viewable_range)AND constructible_from, Rng>) shared_view> operator()(Rng && rng) const { return shared_view>{static_cast(rng)}; } }; /// \relates shared_fn /// \ingroup group-views RANGES_INLINE_VARIABLE(shared_closure, shared) _t> struct sized_generator; template> struct generator : view_facade> { using promise_type = detail::generator_promise; constexpr generator() noexcept = default; generator(promise_type * p) : coro_{handle::from_promise(*p)} { RANGES_EXPECT(coro_); } private: friend range_access; sized_generator enum struct generator_size : generator_size_t { invalid = ~generator_size_t(0) }; template struct RANGES_EMPTY_BASES coroutine_owner; class enable_coroutine_owner { template friend struct coroutine_owner; std::atomic refcount_{1}; }; } // namespace experimental /// \cond namespace detail { inline void resume(RANGES_COROUTINES_NS::cor/range_fwd.hpp> #include #include #endif // Range v3 library // // Copyright Eric Niebler 2013-present // Copyright Casey Carter 2016 // // Use, modification and distribution is subject to the // Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Project home: https://github.com/ericniebler/range-v3 // #ifndef RANGES_V3_UTILITY_INVOKE_HPP #define RANGES_V3_UTILITY_INVOKE_HPP #, meta::quote> {}; // common reference for pairs template class Qual1, template class Qual2> struct basic_common_reference, std::pair, Qual1, Qual2> : ranges::detail::common_ref_tuple_like< ranges::common_pair, Qual1>, std::pair, Qual2>, ranges::common_pair, meta::quote> {}; // common_type for tuples template struct common_type, std::tuple> : ranges::detail::common_type_tuple_like< ranges::common_tuple, std::tuple, meta::quote> {}; template struct common_type, ranges::value) { this->first = static_cast(that.first); this->second = static_cast(that.second); return *this; } }; // Logical operators template(typename F1, typename S1, typename F2, typename S2)( requires equality_comparable_with AND equality_comparable_with) bool operator==(common_pair const & a, common_pair const & b) { return a.first == b.first && a.second == b.second; } te LOGICAL_OP(>, totally_ordered_with) LOGICAL_OP(>=, totally_ordered_with) #undef LOGICAL_OP struct make_common_tuple_fn { template common_tuple...> operator()(Args &&... args) const noexcept( meta::and_c, unwrap_reference_t>::value...>::value) { return common_tuple...>{ unwrap_reference(static_cast(args))...}; } std::tuple const & base() const noexcept { return *this; } // Assignment template(typename... Us)( requires std::is_assignable &, detail::rargs>::value) // common_tuple & operator=(std::tuple & that) noexcept( meta::and_c::value...>::value) { (void)tuple_transform(base(), that, element_assign_{}); quires forward_iterator) { auto tmp = *this; ++out_; return tmp; } O base() const { return out_; } }; template struct iterator_wrapper { private: CPP_assert(input_or_output_iterator); mutable I * i_ = nullptr; public: using difference_type = iter_difference_t; iterator_wrapper() = default; iterator_wrapper(iterator_wrapper const & that) : i_(that.i_)icniebler/range-v3 // //===-------------------------- algorithm ---------------------------------===// // // The LLVM Compiler Infrastructure // // This file is dual licensed under the MIT and the University of Illinois Open // Source Licenses. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #ifndef RANGES_V3_UTILITY_MEMORY_HPP #define RANGES_V3_UTILITY_MEMORY_HPP #include #include #include #include #incIGNORE_DEPRECATED_DECLARATIONS namespace ranges { struct bad_any_cast : std::bad_cast { virtual const char * what() const noexcept override { return "bad any_cast"; } }; struct RANGES_DEPRECATED( "ranges::any will be going away in the not-too-distant future. " "We suggest you use std::any or boost::any instead (or simply steal " "this header and maintain it yourself).") any; template meta::if_c() || copyable, Ting_cache && that) noexcept { that.optional::reset(); optional::reset(); return *this; } using optional::operator=; template constexpr T & emplace_deref(const I & i) { return optional::emplace(*i); } }; template struct non_propagating_cache {}; } // namespace detail /// \endcond } // n template constexpr bool operator>=(nullopt_t, optional const & x) noexcept { return !x; } // Comparisons with T [optional.comp_with_t] template constexpr auto operator==(optional const & x, U const & y) // noexcept(noexcept(convert_bool(*x == y))) // -> decltype(convert_bool(*x == y)) { return x && convert_bool(*x == y); tible &, Args...>::value) { reset(); return base_t::construct_from(il, static_cast(args)...); } using base_t::swap; using base_t::operator->; using base_t::operator*; constexpr explicit operator bool() const noexcept { return has_value(); } using base_t::has_value; constexpr T const & value() const & { return (has_value() || detail::throw_bad_optional_access(ible::value && std::is_move_assignable::value, meta::if_c::value || !(detail::is_trivially_move_constructible_v && detail::is_trivially_move_assignable_v), optional_move_assign, copy_assign_layer>, deleted_move_assign>; } // namespace optional_adl } // namespace detail /// \endcond // clang-format off /// \concept optional_should_convert RANGES_EXPECT(!ptr_); ptr_ = detail::addressof(ref); return *ptr_; } template constexpr void assign_from(U && that) { if(ptr_ && that.ptr_) *ptr_ = *that.ptr_; else ptr_ = that.ptr_; } private: T * ptr_ = nullptr; }; template struct option char dummy_; meta::_t> data_; }; bool engaged_; constexpr optional_storage() noexcept : optional_storage( tag{}, meta::bool_ && detail::is_trivially_copyable_v>{}) {} template(typename... Args)( requires constructible_from) ranges::swap(static_cast(*this), static_cast(that)); } #if !RANGES_BROKEN_CPO_LOOKUP template friend constexpr auto swap(tagged & x, tagged & y) // noexcept(is_nothrow_swappable::value) -> CPP_broken_friend_ret(void)( requires is_swappable::value) { x.swap(y); } #endif }; #if RANGES_BROKEN_CPO_LOOKUP namespace _tagged_ { template(typename Base, typename... Tags)( auto operator=(indexed_datum const & that) // -> CPP_ret(indexed_datum &)( requires assignable_from) { ranges::copy(that.data_, data_); return *this; } // \pre Requires ranges::distance(r) <= N template(typename R)( requires input_range AND assignable_from>) indexed_datum & operator=(R && r) { ranges::copy(r, data_/range/access.hpp> #include #include #include namespace ranges { /// \cond namespace detail { template struct indexed_datum { private: union { char c; T data_[N]; }; void fill_default_(T * p, std::true_type) { for(; p != ranges::end(dpename O)( requires weakly_incrementable AND indirectly_copyable) RANGES_INTENDED_MODULAR_ARITHMETIC void param(O dest) const { constexpr IntRep INV_A = randutils::fast_exp(MULT_A, IntRep(-1)); constexpr IntRep MIX_INV_L = randutils::fast_exp(MIX_MULT_L, IntRep(-1)); auto mixer_copy = mixer_; for(std::size_t round = 0; rouuint32_t XSHIFT = sizeof(IntRep) * 8 / 2; std::array mixer_; template(typename I, typename S)( requires input_iterator AND sentinel_for AND convertible_to, IntRep>) void mix_entropy(I first, S last) { auto hash_const = INIT_A; auto hash = [&](IntRep value) RANGES_INTENDED_MODULAR_ARITHMETIC { value ^= hash_const; // Hopefully high-quality entropy from random_device. #if defined(__GLIBCXX__) && defined(RANGES_WORKAROUND_VALGRIND_RDRAND) std::random_device rd{"/dev/urandom"}; #else std::random_device rd; #endif std::uniform_int_distribution dist{}; ranges::generate(seeds, [&] { return dist(rd); }); return seeds; } template(typename I)( requires unsigned_integral) constexpr I fast_exp(I x, _box() = default; template(typename Arg)( requires constructible_from, Arg &>) semiregular_box(in_place_t, Arg & arg) noexcept // : ranges::reference_wrapper(arg) {} using ranges::reference_wrapper::get; using ranges::reference_wrapper::operator T &; using ranges::reference_wrapper::operator(); #if defined(_MSC_VER) template(typename U)( requires (!same_as, semiregular_box>) AND /// @{ template struct semiregular_box : private detail::semiregular_get { private: struct tag {}; template void construct_from(Args &&... args) { new((void *)std::addressof(data_)) T(static_cast(args)...); engaged_ = true; } void move_assign(T && t, std::true_type) { data_ = detail::move(t); } void move_assign(T && t, std::false_type) { reset( explicit scope_exit(Fun && fun) noexcept(noexcept(scope_exit(std::move(fun), nothrow_move_t{}))) : scope_exit(std::move(fun), nothrow_move_t{}) {} scope_exit(scope_exit const &) = delete; scope_exit(scope_exit && that) noexcept( std::is_nothrow_move_constructible::value) : scope_exit(std::move((that.dismiss(), that)).fun_) {} ~scope_exit() { if(!dismissed_) ypename> class Qual2> struct basic_common_reference<::ranges::common_tuple, ::ranges::common_tuple, Qual1, Qual2>; } // namespace concepts #if RANGES_CXX_VER > RANGES_CXX_STD_17 RANGES_DIAGNOSTIC_PUSH RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS RANGES_BEGIN_NAMESPACE_STD RANGES_BEGIN_NAMESPACE_VERSION template struct common_type; // common_type for std::pairs template struct common_type, ::ranges::common_pair struct tuple_size<::ranges::compressed_tuple_detail::compressed_tuple_< ::meta::list, ::meta::index_sequence>> : integral_constant {}; template struct tuple_element meta::if_, decltype((static_cast(std::declval()), dynamic_cast(std::declval())))> { auto && result = static_cast(static_cast(x)); #ifndef NDEBUG auto && dresult = dynamic_cast(static_cast(x)); RANGES_ASSERT(std::addressof(dresult) == std::addressof(result)); #endif return static_cast(result); } } // namespace ranges #inclpename Val, typename Fun> constexpr auto CPP_auto_fun(operator())(Tup &&tup, Val val, Fun fun)(const) ( return tuple_foldl_fn::impl2(static_cast(tup), std::move(val), fun, tuple_indices_t{}) ) // clang-format on }; /// \ingroup group-utility /// \sa `tuple_foldl_fn` RANGES_INLINE_VARIABLE(tuple_foldl_fn, tuple_foldl) struct tuple_fore_from AND (!convertible_to)) constexpr explicit box(E && e) noexcept(std::is_nothrow_constructible::value) // : value(static_cast(e)) {} #endif constexpr Element & get() & noexcept { return value; } constexpr Element const & get() const & noexcept { return value; } constexpr Element && get() && noexcept { return detail::move(value); ; public: CPP_member constexpr CPP_ctor(box)()( // noexcept(std::is_nothrow_default_constructible::value) // requires std::is_default_constructible::value) : value{} {} #if defined(__cpp_conditional_explicit) && __cpp_conditional_explicit > 0 template(typename E)( requires (!same_as>) AND constructible_from) constexpr explicit(!c/v3/iterator/common_iterator.hpp> #include #include #include #include #include #include #include #include #include #include ct iter_zip_with_view; template struct zip_with_view; template struct zip_view; namespace views { struct iter_zip_with_fn; struct zip_with_fn; struct zip_fn; } // namespace views } // namespace ranges /// \cond namespace ranges { namespace concepts = ::concepts; using namespace ::concepts::defs; using ::concepts::and_v; } // namespace ranges /// \endcond RANGES_DIAGNOSTIC_POP #include ()> struct RANGES_EMPTY_BASES cycled_view; namespace views { struct cycle_fn; } /// \cond namespace detail { template struct reverse_cursor; } /// \endcond template using reverse_iterator = basic_iterator>; template struct empty_view; namespace views { struct empty_fn; } template struct group_by_view;ignable_v = is_trivially_move_assignable::value; #endif #endif template RANGES_INLINE_VAR constexpr bool is_trivial_v = is_trivially_copyable_v && is_trivially_default_constructible_v; template struct is_trivial : meta::bool_> {}; #if RANGES_CXX_LIB_IS_FINAL > 0 #if defined(__clang__) && !defined(_LIBCPP_VERSION) template RANGES_INLINE_VAR constexpr bool is_final_v = _s deprecated. Use " "ranges::indirectly_readable_traits::value_type instead.") = detail::value_type_; template struct size_type; /// \endcond /// \cond namespace detail { struct ignore_t { ignore_t() = default; template constexpr ignore_t(T &&) noexcept {} template constexpr ignore_t const & operator=(T &&) const noexcept { return *this; lude #include #include #include #include #include #include #include #include #include #include #include #endif // n /// \overload template(std::size_t N)( requires (N == 2)) // friend constexpr size_type get(sized_iterator_range const & p) noexcept { return p.size(); } }; struct make_iterator_range_fn { /// \return `{first, last}` template(typename I, typename S)( requires sentinel_for) constexpr iterator_range operator()(I first, S last) const { return {detail::move(first), detail::move(last)}; #include #include #include #include #include RANGES_DEPRECATED_HEADER( "This header is deprecated. Please switch to subrange in " ".") #include namespace ranges { /// \addtogroup group-views /// @{ template RANGES_INLINEnge/v3/iterator/operations.hpp> #endif /// \file // Range v3 library // // Copyright Eric Niebler 2013-present // // Use, modification and distribution is subject to the // Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Project home: https://github.com/ericniebler/range-v3 // #ifndef RANGES_V3_ALGORITHM_HPP #define RANGES_V3_ALGORITHM_HPP #include #include RANGES_DEPRECATED_HEADER( "This header is deprecated. Please #include instead.") #include #endif // RANGES_V3_DATA_HPP // Range v3 library // // Copyright Eric Niebler 2014-presen struct transform_, list, Fn>, void_...>> { using type = list...>; }; #endif } // namespace detail /// \endcond /// Return a new \c meta::list constructed by transforming all the /// elements in \p L with the unary invocable \p Fn. \c transform can /// also be called with two lists of the same length and a binary /// invocable, in which case it returns a new list constructed with : concat_, Rest...> { }; } // namespace detail /// \endcond /// Concatenates several lists into a single list. /// \pre The parameters must all be instantiations of \c meta::list. /// \par Complexity /// `O(L)` where `L` is the number of lists in the list of lists. /// \ingroup transformation template using concat_ = _t, invoke, Fn> { }; template requires valid, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State> struct fold_, State, Fn> : fold_, invoke #if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356) using and_c = bool_>; #else using and_c = bool_<(true && ... && Bs)>; #endif #else #if defined(META_WORKAROUND_GCC_66405) template using and_c = meta::bool_< META_IS_SAME(integer_sequence, integer_sequence, Then> { }; template requires integral struct _if_ : std::conditional<_v, Then, Else> { }; #elif defined(__clang__) // Clang is faster with this implementation template struct _if_ { }; template struct _if_, decltype(bool(If::type::value))> : std::enable_if invocable that partially applies the invocable \p Fn by binding the /// arguments \p Us to the \e back of \p Fn. /// \ingroup composition template struct bind_back { template using invoke = invoke; }; namespace lazy { /// \sa 'meta::bind_front' /// \ingroup lazy_composition template using bind_front = defer; _trait = _t>; /// An alias for `std::true_type` if `T::invoke` exists and names a class /// template or alias template; otherwise, it's an alias for /// `std::false_type`. /// \ingroup trait template using is_callable = _t>; #endif /// \cond namespace detail { #ifdef META_CONCEPT template