Lines Matching defs:std
39 #include <random> // for std::mt19937
51 using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
60 struct negation : std::integral_constant<bool, !bool(T::value)> {};
62 template <typename...> struct conjunction : std::true_type {};
66 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
70 typename std::add_pointer<typename std::add_const<T>::type>::type;
74 using type = typename std::add_lvalue_reference<
75 typename std::add_const<T>::type>::type;
109 std::forward<Params>(params)...);
114 function_ref(std::nullptr_t) {}
118 typename std::enable_if<
119 !std::is_same<typename std::remove_reference<Callable>::type,
121 : callback(callback_fn<typename std::remove_reference<Callable>::type>),
125 return callback(callable, std::forward<Params>(params)...);
146 using std::begin;
150 -> decltype(begin(std::forward<ContainerTy>(container))) {
151 return begin(std::forward<ContainerTy>(container));
154 using std::end;
158 -> decltype(end(std::forward<ContainerTy>(container))) {
159 return end(std::forward<ContainerTy>(container));
162 using std::swap;
165 void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
166 std::declval<T>()))) {
167 swap(std::forward<T>(lhs), std::forward<T>(rhs));
174 -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
175 return adl_detail::adl_begin(std::forward<ContainerTy>(container));
180 -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
181 return adl_detail::adl_end(std::forward<ContainerTy>(container));
186 noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
187 adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
190 /// Test whether \p RangeOrContainer is empty. Similar to C++17 std::empty.
201 return make_range(std::next(adl_begin(RangeOrContainer), N),
210 decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
214 typename std::iterator_traits<ItTy>::iterator_category,
215 typename std::remove_reference<FuncReturnTy>::type> {
218 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
232 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
259 struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
266 typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
271 // Returns a std::reverse_iterator wrapped around the given iterator.
273 std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
274 return std::reverse_iterator<IteratorTy>(It);
283 typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
284 -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
285 llvm::make_reverse_iterator(std::begin(C)))) {
286 return make_range(llvm::make_reverse_iterator(std::end(C)),
287 llvm::make_reverse_iterator(std::begin(C)));
311 typename std::common_type<
312 IterTag, typename std::iterator_traits<
317 typename std::common_type<
318 IterTag, typename std::iterator_traits<
351 typename IterTag = std::forward_iterator_tag>
365 std::bidirectional_iterator_tag>
367 std::bidirectional_iterator_tag> {
369 std::bidirectional_iterator_tag>;
392 using type = std::forward_iterator_tag;
396 using type = std::bidirectional_iterator_tag;
403 using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
404 std::bidirectional_iterator_tag,
405 typename std::iterator_traits<IterT>::iterator_category>::value>::type;
430 FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
431 std::end(std::forward<RangeT>(Range)), Pred),
432 FilterIteratorT(std::end(std::forward<RangeT>(Range)),
433 std::end(std::forward<RangeT>(Range)), Pred));
456 WrappedIteratorT, std::input_iterator_tag> {
459 WrappedIteratorT, std::input_iterator_tag>;
461 using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
515 return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
516 EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
527 using std::declval;
532 using type = std::tuple<decltype(*declval<Iters>())...>;
537 ZipType, typename std::common_type<std::bidirectional_iterator_tag,
538 typename std::iterator_traits<
542 typename std::iterator_traits<typename std::tuple_element<
543 0, std::tuple<Iters...>>::type>::difference_type,
556 std::tuple<Iters...> iterators;
559 template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
560 return value_type(*std::get<Ns>(iterators)...);
564 decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
565 return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
569 decltype(iterators) tup_dec(std::index_sequence<Ns...>) const {
570 return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
574 zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
576 value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
579 return deref(std::index_sequence_for<Iters...>{});
583 iterators = tup_inc(std::index_sequence_for<Iters...>{});
590 iterators = tup_dec(std::index_sequence_for<Iters...>{});
600 return std::get<0>(this->iterators) == std::get<0>(other.iterators);
603 zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
610 std::index_sequence<Ns...>) const {
611 return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
612 std::get<Ns>(other.iterators)...},
619 zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
622 return !test(other, std::index_sequence_for<Iters...>{});
628 using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
636 std::tuple<Args...> ts;
639 iterator begin_impl(std::index_sequence<Ns...>) const {
640 return iterator(std::begin(std::get<Ns>(ts))...);
642 template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
643 return iterator(std::end(std::get<Ns>(ts))...);
647 zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
650 return begin_impl(std::index_sequence_for<Args...>{});
652 iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
662 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
671 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
679 return std::next(I);
684 -> llvm::Optional<typename std::remove_const<
685 typename std::remove_reference<decltype(*I)>::type>::type> {
693 llvm::Optional<typename std::remove_const<typename std::remove_reference<
694 decltype(*std::declval<Iter>())>::type>::type>;
698 using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
705 typename std::common_type<
706 std::forward_iterator_tag,
707 typename std::iterator_traits<Iters>::iterator_category...>::type,
709 typename std::iterator_traits<typename std::tuple_element<
710 0, std::tuple<Iters...>>::type>::difference_type,
717 std::tuple<Iters...> iterators;
718 std::tuple<Iters...> end_iterators;
722 std::index_sequence<Ns...>) const {
724 std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
725 std::get<Ns>(other.iterators)...},
729 template <size_t... Ns> value_type deref(std::index_sequence<Ns...>) const {
731 deref_or_none(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
735 decltype(iterators) tup_inc(std::index_sequence<Ns...>) const {
736 return std::tuple<Iters...>(
737 next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
741 zip_longest_iterator(std::pair<Iters &&, Iters &&>... ts)
742 : iterators(std::forward<Iters>(ts.first)...),
743 end_iterators(std::forward<Iters>(ts.second)...) {}
745 value_type operator*() { return deref(std::index_sequence_for<Iters...>{}); }
748 return deref(std::index_sequence_for<Iters...>{});
752 iterators = tup_inc(std::index_sequence_for<Iters...>{});
757 return !test(other, std::index_sequence_for<Iters...>{});
764 zip_longest_iterator<decltype(adl_begin(std::declval<Args>()))...>;
772 std::tuple<Args...> ts;
775 iterator begin_impl(std::index_sequence<Ns...>) const {
776 return iterator(std::make_pair(adl_begin(std::get<Ns>(ts)),
777 adl_end(std::get<Ns>(ts)))...);
780 template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) const {
781 return iterator(std::make_pair(adl_end(std::get<Ns>(ts)),
782 adl_end(std::get<Ns>(ts)))...);
786 zip_longest_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
789 return begin_impl(std::index_sequence_for<Args...>{});
791 iterator end() const { return end_impl(std::index_sequence_for<Args...>{}); }
802 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
818 std::forward_iterator_tag, ValueT> {
827 std::tuple<IterTs...> Begins;
828 std::tuple<IterTs...> Ends;
835 auto &Begin = std::get<Index>(Begins);
836 auto &End = std::get<Index>(Ends);
847 template <size_t... Ns> void increment(std::index_sequence<Ns...>) {
864 auto &Begin = std::get<Index>(Begins);
865 auto &End = std::get<Index>(Ends);
876 template <size_t... Ns> ValueT &get(std::index_sequence<Ns...>) const {
896 : Begins(std::begin(Ranges)...), Ends(std::end(Ranges)...) {}
901 increment(std::index_sequence_for<IterTs...>());
906 return get(std::index_sequence_for<IterTs...>());
925 decltype(std::begin(std::declval<RangeTs &>()))...>;
928 std::tuple<RangeTs...> Ranges;
930 template <size_t... Ns> iterator begin_impl(std::index_sequence<Ns...>) {
931 return iterator(std::get<Ns>(Ranges)...);
933 template <size_t... Ns> iterator end_impl(std::index_sequence<Ns...>) {
934 return iterator(make_range(std::end(std::get<Ns>(Ranges)),
935 std::end(std::get<Ns>(Ranges)))...);
940 : Ranges(std::forward<RangeTs>(Ranges)...) {}
942 iterator begin() { return begin_impl(std::index_sequence_for<RangeTs...>{}); }
943 iterator end() { return end_impl(std::index_sequence_for<RangeTs...>{}); }
956 std::forward<RangeTs>(Ranges)...);
963 /// Function object to check whether the first component of a std::pair
964 /// compares less than the first component of another std::pair.
971 /// Function object to check whether the second component of a std::pair
972 /// compares less than the second component of another std::pair.
980 /// a std::pair.
1006 std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
1018 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
1026 template <class T, std::size_t N>
1031 /// Adapt std::less<T> for array_pod_sort.
1034 if (std::less<T>()(*reinterpret_cast<const T*>(P1),
1037 if (std::less<T>()(*reinterpret_cast<const T*>(P2),
1055 static unsigned Result(std::random_device{}());
1061 std::mt19937 Generator(presortShuffleEntropy());
1062 std::shuffle(Start, End, Generator);
1069 /// extent. This is just like std::sort, except that it calls qsort instead of
1070 /// using an inlined template. qsort is slightly slower than std::sort, but
1071 /// most sorts are not performance critical in LLVM and std::sort has to be
1073 /// bloat. This function should generally be used instead of std::sort where
1077 /// compared with std::less and can be moved with memcpy. If this isn't true,
1078 /// you should use std::sort.
1081 /// default to std::less.
1098 const typename std::iterator_traits<IteratorTy>::value_type *,
1099 const typename std::iterator_traits<IteratorTy>::value_type *)) {
1111 // Provide wrappers to std::sort which shuffle the elements before sorting
1118 std::sort(Start, End);
1130 std::sort(Start, End, Comp);
1160 /// Get the size of a range. This is a wrapper function around std::distance
1163 auto size(R &&Range, typename std::enable_if<
1164 std::is_same<typename std::iterator_traits<decltype(
1166 std::random_access_iterator_tag>::value,
1168 -> decltype(std::distance(Range.begin(), Range.end())) {
1169 return std::distance(Range.begin(), Range.end());
1172 /// Provide wrappers to std::for_each which take ranges instead of having to
1176 return std::for_each(adl_begin(Range), adl_end(Range), P);
1179 /// Provide wrappers to std::all_of which take ranges instead of having to pass
1183 return std::all_of(adl_begin(Range), adl_end(Range), P);
1186 /// Provide wrappers to std::any_of which take ranges instead of having to pass
1190 return std::any_of(adl_begin(Range), adl_end(Range), P);
1193 /// Provide wrappers to std::none_of which take ranges instead of having to pass
1197 return std::none_of(adl_begin(Range), adl_end(Range), P);
1200 /// Provide wrappers to std::find which take ranges instead of having to pass
1204 return std::find(adl_begin(Range), adl_end(Range), Val);
1207 /// Provide wrappers to std::find_if which take ranges instead of having to pass
1211 return std::find_if(adl_begin(Range), adl_end(Range), P);
1216 return std::find_if_not(adl_begin(Range), adl_end(Range), P);
1219 /// Provide wrappers to std::remove_if which take ranges instead of having to
1223 return std::remove_if(adl_begin(Range), adl_end(Range), P);
1226 /// Provide wrappers to std::copy_if which take ranges instead of having to
1230 return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
1235 return std::copy(adl_begin(Range), adl_end(Range), Out);
1238 /// Wrapper function around std::find to detect if an element exists
1242 return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
1245 /// Wrapper function around std::count to count the number of times an element
1249 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1250 return std::count(adl_begin(Range), adl_end(Range), Element);
1253 /// Wrapper function around std::count_if to count the number of times an
1257 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1258 return std::count_if(adl_begin(Range), adl_end(Range), P);
1261 /// Wrapper function around std::transform to apply a function to a range and
1265 return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
1268 /// Provide wrappers to std::partition which take ranges instead of having to
1272 return std::partition(adl_begin(Range), adl_end(Range), P);
1275 /// Provide wrappers to std::lower_bound which take ranges instead of having to
1279 return std::lower_bound(adl_begin(Range), adl_end(Range),
1280 std::forward<T>(Value));
1286 return std::lower_bound(adl_begin(Range), adl_end(Range),
1287 std::forward<T>(Value), C);
1290 /// Provide wrappers to std::upper_bound which take ranges instead of having to
1294 return std::upper_bound(adl_begin(Range), adl_end(Range),
1295 std::forward<T>(Value));
1301 return std::upper_bound(adl_begin(Range), adl_end(Range),
1302 std::forward<T>(Value), C);
1307 std::stable_sort(adl_begin(Range), adl_end(Range));
1312 std::stable_sort(adl_begin(Range), adl_end(Range), C);
1318 typename Val = decltype(*adl_begin(std::declval<R>()))>
1320 return std::partition_point(adl_begin(Range), adl_end(Range), P);
1323 /// Wrapper function around std::equal to detect if all elements
1329 std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
1364 template<typename Container, typename Range = std::initializer_list<
1383 size_t operator()(const std::pair<First, Second> &P) const {
1384 return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1410 typename std::iterator_traits<IterOfRange<R>>::reference;
1415 result_pair(std::size_t Index, IterOfRange<R> Iter)
1426 std::size_t index() const { return Index; }
1431 std::size_t Index = std::numeric_limits<std::size_t>::max();
1438 enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1439 typename std::iterator_traits<IterOfRange<R>>::difference_type,
1440 typename std::iterator_traits<IterOfRange<R>>::pointer,
1441 typename std::iterator_traits<IterOfRange<R>>::reference> {
1446 : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1448 enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1455 assert(Result.Index != std::numeric_limits<size_t>::max());
1464 // by calling std::end() versus incrementing a valid iterator.
1480 explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1483 return enumerator_iter<R>(0, std::begin(TheRange));
1487 return enumerator_iter<R>(std::end(TheRange));
1500 /// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1512 return detail::enumerator<R>(std::forward<R>(TheRange));
1517 template <typename F, typename Tuple, std::size_t... I>
1518 auto apply_tuple_impl(F &&f, Tuple &&t, std::index_sequence<I...>)
1519 -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1520 return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1530 std::forward<F>(f), std::forward<Tuple>(t),
1531 std::make_index_sequence<
1532 std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1533 using Indices = std::make_index_sequence<
1534 std::tuple_size<typename std::decay<Tuple>::type>::value>;
1536 return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1545 typename std::enable_if<
1546 !std::is_same<
1547 typename std::iterator_traits<typename std::remove_reference<
1549 std::random_access_iterator_tag>::value,
1562 typename std::enable_if<
1563 !std::is_same<
1564 typename std::iterator_traits<typename std::remove_reference<
1566 std::random_access_iterator_tag>::value,
1578 /// once we move to C++20 where it's defined as std::to_addres()
1580 /// The std::pointer_traits<>::to_address(p) variations of these overloads has