This is an archive of the discontinued LLVM Phabricator instance.

Differential D123912

[libc++] Granularize <functional> includes
ClosedPublic

Authored by philnik on Apr 17 2022, 7:02 AM.

Details

Reviewers
Mordante
var-const
Group Reviewers
Restricted Project
Commits
rGfaef447e72a5: [libc++] Granularize <functional> includes

Diff Detail

Event Timeline

philnik created this revision.Apr 17 2022, 7:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 17 2022, 7:02 AM
Herald added a subscriber: miyuki. · View Herald Transcript
philnik requested review of this revision.Apr 17 2022, 7:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 17 2022, 7:02 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B159975: Diff 423293.Apr 17 2022, 9:34 AM
Mordante accepted this revision.Apr 20 2022, 11:42 AM

Nice cleanup, LGTM!

libcxx/include/experimental/coroutine
52

I wonder do we need to update this header? It's slated for removal.

libcxx/include/numeric
150

Interesting to see how many headers include this header and don't use it.

This revision is now accepted and ready to land.Apr 20 2022, 11:42 AM
Closed by commit rGfaef447e72a5: [libc++] Granularize <functional> includes (authored by philnik). · Explain WhyApr 20 2022, 1:49 PM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rGfaef447e72a5: [libc++] Granularize <functional> includes.

Revision Contents

PathSize
libcxx/
include/
__ranges/
7 lines
2 lines
experimental/
3 lines
4 lines
4 lines
ext/
2 lines
2 lines
2 lines
2 lines
2 lines
9 lines
2 lines
1 line
2 lines
2 lines
2 lines
2 lines
7 lines
test/
std/
algorithms/
alg.modifying.operations/
alg.transform/
1 line
alg.nonmodifying/
mismatch/
1 line
alg.sorting/
alg.min.max/
1 line
1 line
1 line
1 line
1 line
1 line
ranges/
range.adaptors/
range.lazy.split/
1 line

Diff 424014

libcxx/include/__ranges/join_view.h

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___RANGES_JOIN_VIEW_H #ifndef _LIBCPP___RANGES_JOIN_VIEW_H
#define _LIBCPP___RANGES_JOIN_VIEW_H #define _LIBCPP___RANGES_JOIN_VIEW_H
#include <__concepts/constructible.h>
#include <__concepts/convertible_to.h>
#include <__concepts/copyable.h>
#include <__concepts/derived_from.h>
#include <__concepts/equality_comparable.h>
#include <__config> #include <__config>
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/iter_move.h>
#include <__iterator/iter_swap.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/all.h> #include <__ranges/all.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/non_propagating_cache.h> #include <__ranges/non_propagating_cache.h>
#include <__ranges/ref_view.h> #include <__ranges/ref_view.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__ranges/view_interface.h> #include <__ranges/view_interface.h>
▲ Show 20 Lines • Show All 327 Lines • Show Last 20 Lines

libcxx/include/algorithm

Show First 20 Lines • Show All 875 Lines • ▼ Show 20 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__bits> #include <__bits>
#include <__config> #include <__config>
#include <__debug> #include <__debug>
#include <cstddef> #include <cstddef>
#include <cstring> #include <cstring>
#include <functional> #include <functional> // TODO: Remove this include
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#include <__algorithm/adjacent_find.h> #include <__algorithm/adjacent_find.h>
#include <__algorithm/all_of.h> #include <__algorithm/all_of.h>
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

libcxx/include/experimental/coroutine

Show All 40 Lines
} // namespace coroutines_v1 } // namespace coroutines_v1
} // namespace experimental } // namespace experimental
} // namespace std } // namespace std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__functional/hash.h>
#include <cstddef> #include <cstddef>
#include <experimental/__config> #include <experimental/__config>
#include <functional> #include <functional> // TODO: Remove this include
MordanteUnsubmitted
Not Done
ReplyInline Actions

I wonder do we need to update this header? It's slated for removal.

Mordante: I wonder do we need to update this header? It's slated for removal.
#include <memory> // for hash<T*> #include <memory> // for hash<T*>
#include <new> #include <new>
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 267 Lines • Show Last 20 Lines

libcxx/include/experimental/propagate_const

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines/*
template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>; template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>; template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
} // namespace std } // namespace std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__functional/operations.h>
#include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <experimental/__config> #include <experimental/__config>
#include <functional> #include <functional> // TODO: Remove this include
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
▲ Show 20 Lines • Show All 457 Lines • Show Last 20 Lines

libcxx/include/experimental/simd

Show First 20 Lines • Show All 644 Lines • ▼ Show 20 Lines
}; };
} // parallelism_v2 } // parallelism_v2
} // std::experimental } // std::experimental
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__functional/operations.h>
#include <array> #include <array>
#include <cstddef> #include <cstddef>
#include <experimental/__config> #include <experimental/__config>
#include <functional> #include <functional> // TODO: Remove this include
#include <tuple>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
▲ Show 20 Lines • Show All 912 Lines • Show Last 20 Lines

libcxx/include/ext/hash_map

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <algorithm> #include <algorithm>
#include <ext/__hash> #include <ext/__hash>
#include <functional> #include <functional> // TODO: Remove this include
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#if defined(__DEPRECATED) && __DEPRECATED #if defined(__DEPRECATED) && __DEPRECATED
#if defined(_LIBCPP_WARNING) #if defined(_LIBCPP_WARNING)
_LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>") _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>")
#else #else
# warning Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map> # warning Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>
▲ Show 20 Lines • Show All 769 Lines • Show Last 20 Lines

libcxx/include/ext/hash_set

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__hash_table> #include <__hash_table>
#include <algorithm> #include <algorithm>
#include <ext/__hash> #include <ext/__hash>
#include <functional> #include <functional> // TODO: Remove this include
#if defined(__DEPRECATED) && __DEPRECATED #if defined(__DEPRECATED) && __DEPRECATED
#if defined(_LIBCPP_WARNING) #if defined(_LIBCPP_WARNING)
_LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>") _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>")
#else #else
# warning Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set> # warning Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>
#endif #endif
#endif #endif
▲ Show 20 Lines • Show All 457 Lines • Show Last 20 Lines

libcxx/include/map

Show First 20 Lines • Show All 533 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <__functional/is_transparent.h> #include <__functional/is_transparent.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__node_handle> #include <__node_handle>
#include <__tree> #include <__tree>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <compare> #include <compare>
#include <functional> #include <functional> // TODO: Remove this include
#include <initializer_list> #include <initializer_list>
#include <iterator> // __libcpp_erase_if_container #include <iterator> // __libcpp_erase_if_container
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
▲ Show 20 Lines • Show All 1,789 Lines • Show Last 20 Lines

libcxx/include/mutex

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Lines
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__mutex_base> #include <__mutex_base>
#include <__threading_support> #include <__threading_support>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <cstdint> #include <cstdint>
#include <functional> #include <functional> // TODO: Remove this include
#include <memory> #include <memory>
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
# include <tuple> # include <tuple>
#endif #endif
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
▲ Show 20 Lines • Show All 503 Lines • Show Last 20 Lines

libcxx/include/numeric

Show First 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
} // std } // std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <cmath> // for isnormal #include <cmath> // for isnormal
#include <functional> #include <functional> // TODO: Remove this include
MordanteUnsubmitted
Not Done
ReplyInline Actions

Interesting to see how many headers include this header and don't use it.

Mordante: Interesting to see how many headers include this header and don't use it.
#include <iterator> #include <iterator>
#include <version> #include <version>
#include <__numeric/accumulate.h> #include <__numeric/accumulate.h>
#include <__numeric/adjacent_difference.h> #include <__numeric/adjacent_difference.h>
#include <__numeric/exclusive_scan.h> #include <__numeric/exclusive_scan.h>
#include <__numeric/gcd_lcm.h> #include <__numeric/gcd_lcm.h>
#include <__numeric/inclusive_scan.h> #include <__numeric/inclusive_scan.h>
Show All 18 Lines

libcxx/include/optional

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Lines
} // namespace std } // namespace std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__availability> #include <__availability>
#include <__concepts/invocable.h> #include <__concepts/invocable.h>
#include <__config> #include <__config>
#include <__functional/hash.h>
#include <__functional/invoke.h>
#include <__functional/unary_function.h>
#include <__memory/construct_at.h>
#include <__tuple>
#include <__utility/forward.h>
#include <__utility/in_place.h> #include <__utility/in_place.h>
#include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <compare> #include <compare>
#include <functional> #include <functional> // TODO: Remove this include
#include <initializer_list> #include <initializer_list>
#include <new> #include <new>
#include <stdexcept> #include <stdexcept>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
// TODO: remove these headers // TODO: remove these headers
#include <__memory/allocator_arg_t.h> #include <__memory/allocator_arg_t.h>
▲ Show 20 Lines • Show All 1,396 Lines • Show Last 20 Lines

libcxx/include/queue

Show First 20 Lines • Show All 221 Lines • ▼ Show 20 Lines
#include <__algorithm/push_heap.h> #include <__algorithm/push_heap.h>
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/uses_allocator.h> #include <__memory/uses_allocator.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <compare> #include <compare>
#include <deque> #include <deque>
#include <functional> #include <functional> // TODO: Remove this include
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 718 Lines • Show Last 20 Lines

libcxx/include/regex

Show First 20 Lines • Show All 757 Lines • ▼ Show 20 Lines
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
} // std } // std
*/ */
#include <__algorithm/find.h> #include <__algorithm/find.h>
#include <__algorithm/search.h>
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__iterator/wrap_iter.h> #include <__iterator/wrap_iter.h>
#include <__locale> #include <__locale>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/swap.h> #include <__utility/swap.h>
#include <compare> #include <compare>
#include <deque> #include <deque>
▲ Show 20 Lines • Show All 6,062 Lines • Show Last 20 Lines

libcxx/include/set

Show First 20 Lines • Show All 475 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__functional/is_transparent.h> #include <__functional/is_transparent.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__node_handle> #include <__node_handle>
#include <__tree> #include <__tree>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <compare> #include <compare>
#include <functional> #include <functional> // TODO: Remove this include
#include <initializer_list> #include <initializer_list>
#include <iterator> // __libcpp_erase_if_container #include <iterator> // __libcpp_erase_if_container
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 1,072 Lines • Show Last 20 Lines

libcxx/include/thread

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__mutex_base> #include <__mutex_base>
#include <__thread/poll_with_backoff.h> #include <__thread/poll_with_backoff.h>
#include <__thread/timed_backoff_policy.h> #include <__thread/timed_backoff_policy.h>
#include <__threading_support> #include <__threading_support>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <cstddef> #include <cstddef>
#include <functional> #include <functional> // TODO: Remove this include
#include <iosfwd> #include <iosfwd>
#include <memory> #include <memory>
#include <system_error> #include <system_error>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
▲ Show 20 Lines • Show All 308 Lines • Show Last 20 Lines

libcxx/include/unordered_map

Show First 20 Lines • Show All 519 Lines • ▼ Show 20 Lines
#include <__debug> #include <__debug>
#include <__functional/is_transparent.h> #include <__functional/is_transparent.h>
#include <__hash_table> #include <__hash_table>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__node_handle> #include <__node_handle>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <compare> #include <compare>
#include <functional> #include <functional> // TODO: Remove this include
#include <iterator> // __libcpp_erase_if_container #include <iterator> // __libcpp_erase_if_container
#include <stdexcept> #include <stdexcept>
#include <tuple> #include <tuple>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 2,083 Lines • Show Last 20 Lines

libcxx/include/unordered_set

Show First 20 Lines • Show All 463 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <__debug> #include <__debug>
#include <__functional/is_transparent.h> #include <__functional/is_transparent.h>
#include <__hash_table> #include <__hash_table>
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__node_handle> #include <__node_handle>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <compare> #include <compare>
#include <functional> #include <functional> // TODO: Remove this include
#include <iterator> // __libcpp_erase_if_container #include <iterator> // __libcpp_erase_if_container
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
▲ Show 20 Lines • Show All 1,313 Lines • Show Last 20 Lines

libcxx/include/valarray

Show First 20 Lines • Show All 344 Lines • ▼ Show 20 Lines
#include <__algorithm/count.h> #include <__algorithm/count.h>
#include <__algorithm/fill.h> #include <__algorithm/fill.h>
#include <__algorithm/max_element.h> #include <__algorithm/max_element.h>
#include <__algorithm/min.h> #include <__algorithm/min.h>
#include <__algorithm/min_element.h> #include <__algorithm/min_element.h>
#include <__algorithm/unwrap_iter.h> #include <__algorithm/unwrap_iter.h>
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__functional/operations.h>
#include <__memory/allocator.h>
#include <__memory/uninitialized_algorithms.h>
#include <__utility/move.h>
#include <__utility/swap.h>
#include <cmath> #include <cmath>
#include <cstddef> #include <cstddef>
#include <functional> #include <functional> // TODO: Remove this include
#include <initializer_list> #include <initializer_list>
#include <new> #include <new>
#include <version> #include <version>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
▲ Show 20 Lines • Show All 4,581 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/ranges.transform.pass.cpp

Show All 34 Lines
// projected<iterator_t<R2>, Proj2>>> // projected<iterator_t<R2>, Proj2>>>
// constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O> // constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
// ranges::transform(R1&& r1, R2&& r2, O result, // ranges::transform(R1&& r1, R2&& r2, O result,
// F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "almost_satisfies_types.h" #include "almost_satisfies_types.h"
struct BinaryFunc { struct BinaryFunc {
int operator()(int, int); int operator()(int, int);
}; };
▲ Show 20 Lines • Show All 534 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

Show All 18 Lines
// class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> // class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
// requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> // requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
// constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> // constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
// ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
template <class Iter1, class Iter2> template <class Iter1, class Iter2>
constexpr void test_iterators(Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2, int* expected1, int* expected2) { constexpr void test_iterators(Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2, int* expected1, int* expected2) {
using Expected = std::ranges::mismatch_result<Iter1, Iter2>; using Expected = std::ranges::mismatch_result<Iter1, Iter2>;
std::same_as<Expected> auto ret = std::ranges::mismatch(std::move(begin1), sentinel_wrapper<Iter1>(std::move(end1)), std::same_as<Expected> auto ret = std::ranges::mismatch(std::move(begin1), sentinel_wrapper<Iter1>(std::move(end1)),
▲ Show 20 Lines • Show All 259 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.max.pass.cpp

Show All 22 Lines
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> // requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
// constexpr range_value_t<R> // constexpr range_value_t<R>
// ranges::max(R&& r, Comp comp = {}, Proj proj = {}); // ranges::max(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "almost_satisfies_types.h" #include "almost_satisfies_types.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
concept HasMaxR = requires { std::ranges::max(std::declval<T>()); }; concept HasMaxR = requires { std::ranges::max(std::declval<T>()); };
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.max_element.pass.cpp

Show All 16 Lines
// //
// template<forward_range R, class Proj = identity, // template<forward_range R, class Proj = identity,
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {}); // constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <random> #include <random>
#include <ranges> #include <ranges>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
template <class T> template <class T>
concept HasMaxElement = requires (T t) { std::ranges::max_element(t); }; concept HasMaxElement = requires (T t) { std::ranges::max_element(t); };
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.min.pass.cpp

Show All 20 Lines
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> // requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
// constexpr range_value_t<R> // constexpr range_value_t<R>
// ranges::min(R&& r, Comp comp = {}, Proj proj = {}); // ranges::min(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "almost_satisfies_types.h" #include "almost_satisfies_types.h"
#include "test_iterators.h" #include "test_iterators.h"
#include "test_macros.h" #include "test_macros.h"
template <class T> template <class T>
concept HasMinR = requires { std::ranges::min(std::declval<T>()); }; concept HasMinR = requires { std::ranges::min(std::declval<T>()); };
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.min_element.pass.cpp

Show All 16 Lines
// //
// template<forward_range R, class Proj = identity, // template<forward_range R, class Proj = identity,
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// constexpr borrowed_iterator_t<R> ranges::min_element(R&& r, Comp comp = {}, Proj proj = {}); // constexpr borrowed_iterator_t<R> ranges::min_element(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <random> #include <random>
#include <ranges> #include <ranges>
#include "test_macros.h" #include "test_macros.h"
#include "test_iterators.h" #include "test_iterators.h"
template <class T> template <class T>
concept HasMinElement = requires (T t) { std::ranges::min_element(t); }; concept HasMinElement = requires (T t) { std::ranges::min_element(t); };
▲ Show 20 Lines • Show All 161 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax.pass.cpp

Show All 22 Lines
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*> // requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
// constexpr ranges::minmax_result<range_value_t<R>> // constexpr ranges::minmax_result<range_value_t<R>>
// ranges::minmax(R&& r, Comp comp = {}, Proj proj = {}); // ranges::minmax(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
template <class T> template <class T>
concept HasMinMax = requires { std::ranges::minmax(std::declval<T>()); }; concept HasMinMax = requires { std::ranges::minmax(std::declval<T>()); };
struct NoLessThanOp {}; struct NoLessThanOp {};
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

libcxx/test/std/algorithms/alg.sorting/alg.min.max/ranges.minmax_element.pass.cpp

Show All 17 Lines
// template<forward_range R, class Proj = identity, // template<forward_range R, class Proj = identity,
// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
// constexpr ranges::minmax_element_result<borrowed_iterator_t<R>> // constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
// ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {}); // ranges::minmax_element(R&& r, Comp comp = {}, Proj proj = {});
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <functional>
#include <ranges> #include <ranges>
#include "almost_satisfies_types.h" #include "almost_satisfies_types.h"
#include "test_iterators.h" #include "test_iterators.h"
template <class T> template <class T>
concept HasMinMaxElementR = requires(T t) { std::ranges::minmax_element(t); }; concept HasMinMaxElementR = requires(T t) { std::ranges::minmax_element(t); };
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

libcxx/test/std/ranges/range.adaptors/range.lazy.split/constraints.compile.pass.cpp

Show All 9 Lines
// UNSUPPORTED: libcpp-has-no-incomplete-ranges // UNSUPPORTED: libcpp-has-no-incomplete-ranges
// template<input_range V, forward_range Pattern> // template<input_range V, forward_range Pattern>
// requires view<V> && view<Pattern> && // requires view<V> && view<Pattern> &&
// indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> && // indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
// (forward_range<V> || tiny-range<Pattern>) // (forward_range<V> || tiny-range<Pattern>)
// class lazy_split_view; // class lazy_split_view;
#include <functional>
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#include "types.h" #include "types.h"
struct ForwardRange { struct ForwardRange {
forward_iterator<int*> begin() const; forward_iterator<int*> begin() const;
forward_iterator<int*> end() const; forward_iterator<int*> end() const;
▲ Show 20 Lines • Show All 185 Lines • Show Last 20 Lines