maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/utility

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

252 lines
9.3 KiB
Plaintext
Raw Normal View History

libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
// -*- C++ -*-
[runtimes][NFC] Remove filenames at the top of the license notice We've stopped doing it in libc++ for a while now because these names would end up rotting as we move things around and copy/paste stuff. This cleans up all the existing files so as to stop the spreading as people copy-paste headers around.
2021-11-18 05:25:01 +08:00
//===----------------------------------------------------------------------===//
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
//
Update more file headers across all of the LLVM projects in the monorepo to reflect the new license. These used slightly different spellings that defeated my regular expressions. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351648
2019-01-19 18:56:40 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef _LIBCPP_UTILITY
#define _LIBCPP_UTILITY
/*
utility synopsis
[NFC] Add <initializer_list> to the synopsis of <utility> Summary: It is part of the synopsis in the Standard and <utility> does include it, but it was left out of the synopsis comment. Reviewers: EricWF, mclow.lists Subscribers: christof, llvm-commits Differential Revision: https://reviews.llvm.org/D48611 llvm-svn: 336368
2018-07-06 00:16:03 +08:00
#include <initializer_list>
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
namespace std
{
template <class T>
void
swap(T& a, T& b);
namespace rel_ops
{
template<class T> bool operator!=(const T&, const T&);
template<class T> bool operator> (const T&, const T&);
template<class T> bool operator<=(const T&, const T&);
template<class T> bool operator>=(const T&, const T&);
}
noexcept for <utility>. This included a little repair on pair, and some noexcept workarounds. llvm-svn: 132186
2011-05-27 23:04:19 +08:00
template<class T>
void
swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
is_nothrow_move_assignable<T>::value);
template <class T, size_t N>
void
swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Make std::forward and std::move (and std::move_if_noexcept) constexpr in C++14 llvm-svn: 186344
2013-07-16 04:46:11 +08:00
template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; // constexpr in C++14
template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14
noexcept for <utility>. This included a little repair on pair, and some noexcept workarounds. llvm-svn: 132186
2011-05-27 23:04:19 +08:00
Make std::forward and std::move (and std::move_if_noexcept) constexpr in C++14 llvm-svn: 186344
2013-07-16 04:46:11 +08:00
template <class T> typename remove_reference<T>::type&& move(T&&) noexcept; // constexpr in C++14
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class T>
typename conditional
<
N3142. Many of these traits are just placeholders with medium quality emulation; waiting on compiler intrinsics to do it right. llvm-svn: 119854
2010-11-20 06:17:28 +08:00
!is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
const T&,
T&&
>::type
Make std::forward and std::move (and std::move_if_noexcept) constexpr in C++14 llvm-svn: 186344
2013-07-16 04:46:11 +08:00
move_if_noexcept(T& x) noexcept; // constexpr in C++14
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Fix a typo in the synopsis comment. NFC. Thanks to K-ballo for the catch llvm-svn: 324851
2018-02-12 05:51:49 +08:00
template <class T> constexpr add_const_t<T>& as_const(T& t) noexcept; // C++17
Implement P0007: Constant View: A proposal for a std::as_const helper function template. llvm-svn: 253274
2015-11-17 08:08:08 +08:00
template <class T> void as_const(const T&&) = delete; // C++17
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class T> typename add_rvalue_reference<T>::type declval() noexcept;
[libc++] [C++20] [P0586] Implement safe integral comparisons * https://wg21.link/P0586 Reviewed By: #libc, curdeius, Quuxplusone Differential Revision: https://reviews.llvm.org/D94511
2021-04-20 07:18:34 +08:00
template<class T, class U> constexpr bool cmp_equal(T t, U u) noexcept; // C++20
template<class T, class U> constexpr bool cmp_not_equal(T t, U u) noexcept; // C++20
template<class T, class U> constexpr bool cmp_less(T t, U u) noexcept; // C++20
template<class T, class U> constexpr bool cmp_greater(T t, U u) noexcept; // C++20
template<class T, class U> constexpr bool cmp_less_equal(T t, U u) noexcept; // C++20
template<class T, class U> constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
template<class R, class T> constexpr bool in_range(T t) noexcept; // C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(const pair&) = default;
noexcept for <utility>. This included a little repair on pair, and some noexcept workarounds. llvm-svn: 132186
2011-05-27 23:04:19 +08:00
pair(pair&&) = default;
[libc++] Take 2: Implement LWG 2510 Summary: LWG2510 makes tag types like allocator_arg_t explicitly default constructible instead of implicitly default constructible. It also makes the constructors for std::pair and std::tuple conditionally explicit based on the explicit-ness of the default constructibility for the pair/tuple's elements. This was previously committed as r372777 and reverted in r372832 due to the commit breaking LLVM's build in C++14 mode. This issue has now been addressed. Reviewers: mclow.lists Subscribers: christof, jkorous, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D65161 llvm-svn: 372983
2019-09-26 22:51:10 +08:00
explicit(see-below) constexpr pair();
[NFC][libc++] Add missing EXPLICIT to pair and tuple synopsis The constructors for std::pair and std::tuple have been made conditionally explicit, however the synopsis in the headers do not reflect that. llvm-svn: 366735
2019-07-23 04:45:23 +08:00
explicit(see-below) pair(const T1& x, const T2& y); // constexpr in C++14
[libc++] Implement P1951, default arguments for pair's forwarding constructor Differential Revision: https://reviews.llvm.org/D109066
2021-09-01 06:13:33 +08:00
template <class U = T1, class V = T2> explicit(see-below) pair(U&&, V&&); // constexpr in C++14
[NFC][libc++] Add missing EXPLICIT to pair and tuple synopsis The constructors for std::pair and std::tuple have been made conditionally explicit, however the synopsis in the headers do not reflect that. llvm-svn: 366735
2019-07-23 04:45:23 +08:00
template <class U, class V> explicit(see-below) pair(const pair<U, V>& p); // constexpr in C++14
template <class U, class V> explicit(see-below) pair(pair<U, V>&& p); // constexpr in C++14
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template <class... Args1, class... Args2>
pair(piecewise_construct_t, tuple<Args1...> first_args,
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
tuple<Args2...> second_args); // constexpr in C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
template <class U, class V> pair& operator=(const pair<U, V>& p); // constexpr in C++20
noexcept for <utility>. This included a little repair on pair, and some noexcept workarounds. llvm-svn: 132186
2011-05-27 23:04:19 +08:00
pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
is_nothrow_move_assignable<T2>::value); // constexpr in C++20
template <class U, class V> pair& operator=(pair<U, V>&& p); // constexpr in C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Add is_swappable/is_nothrow_swappable traits llvm-svn: 267079
2016-04-22 07:38:59 +08:00
void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
is_nothrow_swappable_v<T2>); // constexpr in C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
};
[libc++][P2321R2] Add specializations of basic_common_reference and common_type for pair Add specializations of basic_common_reference and common_type for pair Reviewed By: Quuxplusone, Mordante, #libc Spies: libcxx-commits Differential Revision: https://reviews.llvm.org/D117506
2022-02-02 04:36:50 +08:00
template<class T1, class T2, class U1, class U2, template<class> class TQual, template<class> class UQual>
struct basic_common_reference<pair<T1, T2>, pair<U1, U2>, TQual, UQual>; // since C++23
template<class T1, class T2, class U1, class U2>
struct common_type<pair<T1, T2>, pair<U1, U2>>; // since C++23
[libc++] P0433R2: add the remaining deduction guides. Add deduction guides to `valarray` and `scoped_allocator_adaptor`. This largely finishes implementation of the paper: * deduction guides for other classes mentioned in the paper were implemented previously (see the list below); * deduction guides for several classes contained in the proposal (`reference_wrapper`, `lock_guard`, `scoped_lock`, `unique_lock`, `shared_lock`) were removed by [LWG2981](https://wg21.link/LWG2981). Also add deduction guides to the synopsis for the few classes (e.g. `pair`) where they were missing. The only part of the paper that isn't fully implemented after this patch is making sure certain deduction guides don't participate in overload resolution when given incorrect template parameters. List of significant commits implementing the other parts of P0433 (omitting some minor fixes): * [pair](https://github.com/llvm/llvm-project/commit/af65856eec160d163c764faad250d93357be7c83) * [basic_string](https://github.com/llvm/llvm-project/commit/6d9f750dec29e8ae5366092e64cd343dae2c7464) * [array](https://github.com/llvm/llvm-project/commit/0ca8c0895c6034615593c295dd955f29b25bf3d4) * [deque](https://github.com/llvm/llvm-project/commit/dbb6f8a8179b0604e25707b5c1b72be6164f62d9) * [forward_list](https://github.com/llvm/llvm-project/commit/e076700b7786959206acef136ecf05d54078e4e1) * [list](https://github.com/llvm/llvm-project/commit/4a227e582b2f13880ea049b29988a37a0f7c0742) * [vector](https://github.com/llvm/llvm-project/commit/df8f75479278d5ce16eede342ceb5ba2fd71460b) * [queue/stack/priority_queue](https://github.com/llvm/llvm-project/commit/5b8b8b5dce587f1e5a4a31cc24f09b18bd53ff9a) * [basic_regex](https://github.com/llvm/llvm-project/commit/edd5e29cfe9f67ec8e7e0eda12eb05e616fdeebc) * [optional](https://github.com/llvm/llvm-project/commit/f35b4bc3954f3b01051fc0848535ff784809e9e2) * [map/multimap](https://github.com/llvm/llvm-project/commit/edfe8525de1f7278f4754f2bffd47b13ec291a17) * [set/multiset](https://github.com/llvm/llvm-project/commit/e20865c387e09ea0ebd5add15c762cd5271ff65f) * [unordered_set/unordered_multiset](https://github.com/llvm/llvm-project/commit/296a80102a9b72c3eda80558fb78a3ed8849b341) * [unordered_map/unordered_multimap](https://github.com/llvm/llvm-project/commit/dfcd4384cbcac0eeb7e5cbce350f875ba4da79d5) * [function](https://github.com/llvm/llvm-project/commit/e1eabcdfad89f67ae575b0c86aa4a72d277378b4) * [tuple](https://github.com/llvm/llvm-project/commit/1308011e1b5c5382281a63dd4191a1784f8d2295) * [shared_ptr/weak_ptr](https://github.com/llvm/llvm-project/commit/83564056d4b186c9fcf016cdbb388755009f7b5a) Additional notes: * It was revision 2 of the paper that was voted into the Standard. P0433R3 is a separate paper that is not part of the Standard. * The paper also mandates removing several `make_*_searcher` functions (e.g. `make_boyer_moore_searcher`) which are currently not implemented (except in `experimental/`). * The `__cpp_lib_deduction_guides` feature test macro from the paper was accidentally omitted from the Standard. Differential Revision: https://reviews.llvm.org/D112510
2021-10-28 15:36:19 +08:00
template<class T1, class T2> pair(T1, T2) -> pair<T1, T2>;
Bug 16599 part 2: Make std::pair's constructors and comparison operators (and make_pair) constexpr. llvm-svn: 186430
2013-07-17 01:45:44 +08:00
template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
[libc++][spaceship] Implement std::pair::operator<=> Implements parts of P1614, including synth-three-way and three way comparison for std::pair. Reviewed By: #libc, Quuxplusone, Mordante Differential Revision: https://reviews.llvm.org/D107721
2021-09-23 13:36:23 +08:00
template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14, removed in C++20
template <class T1, class T2>
constexpr common_comparison_type_t<synth-three-way-result<T1>,
synth-three-way-result<T2>>
operator<=>(const pair<T1,T2>&, const pair<T1,T2>&); // C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&); // constexpr in C++14
noexcept for <utility>. This included a little repair on pair, and some noexcept workarounds. llvm-svn: 132186
2011-05-27 23:04:19 +08:00
template <class T1, class T2>
void
[libc++] [P1032] Misc constexpr bits in <iterator>, <string_view>, <tuple>, <utility>. This completes the implementation of P1032's changes to <iterator>, <string_view>, <tuple>, and <utility> in C++20. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp". Differential Revision: https://reviews.llvm.org/D96385
2021-02-10 08:12:16 +08:00
swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y))); // constexpr in C++20
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
[libc++] Take 2: Implement LWG 2510 Summary: LWG2510 makes tag types like allocator_arg_t explicitly default constructible instead of implicitly default constructible. It also makes the constructors for std::pair and std::tuple conditionally explicit based on the explicit-ness of the default constructibility for the pair/tuple's elements. This was previously committed as r372777 and reverted in r372832 due to the commit breaking LLVM's build in C++14 mode. This issue has now been addressed. Reviewers: mclow.lists Subscribers: christof, jkorous, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D65161 llvm-svn: 372983
2019-09-26 22:51:10 +08:00
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
Implement most of P0607: Inline Variables for the Standard Library. This involved marking a lot of variables as inline (but only for C++17 and later). llvm-svn: 321658
2018-01-03 01:17:01 +08:00
inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Change from a to a . Fixes PR#39871. llvm-svn: 350972
2019-01-12 05:57:12 +08:00
template <class T> struct tuple_size;
[libc++] Declare std::tuple_element as struct instead of class Similarly to https://reviews.llvm.org/rL350972, this revision changes std::tuple_element from class to struct. Fixes PR41331. Thanks to Jan Wilken Dörrie for the patch. Differential Revision: https://reviews.llvm.org/D60069 llvm-svn: 357411
2019-04-02 00:39:34 +08:00
template <size_t I, class T> struct tuple_element;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;
template <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template<size_t I, class T1, class T2>
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
typename tuple_element<I, pair<T1, T2> >::type&
get(pair<T1, T2>&) noexcept; // constexpr in C++14
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
template<size_t I, class T1, class T2>
Fix some mistakes in the <utility> and <tuple> synopses. No functional change. Thannks to K-ballo for the patch llvm-svn: 253593
2015-11-20 03:45:29 +08:00
const typename tuple_element<I, pair<T1, T2> >::type&
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
get(const pair<T1, T2>&) noexcept; // constexpr in C++14
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
LWG 1191 llvm-svn: 119545
2010-11-18 03:52:17 +08:00
template<size_t I, class T1, class T2>
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
typename tuple_element<I, pair<T1, T2> >::type&&
get(pair<T1, T2>&&) noexcept; // constexpr in C++14
LWG 1191 llvm-svn: 119545
2010-11-18 03:52:17 +08:00
[libcxx] LWG2485: get() should be overloaded for const tuple&&. Patch from K-Ballo. Review: http://reviews.llvm.org/D14839 llvm-svn: 255941
2015-12-18 08:36:55 +08:00
template<size_t I, class T1, class T2>
const typename tuple_element<I, pair<T1, T2> >::type&&
get(const pair<T1, T2>&&) noexcept; // constexpr in C++14
Implement n3584 - Addressing Tuples by Type llvm-svn: 186237
2013-07-13 10:54:05 +08:00
template<class T1, class T2>
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
constexpr T1& get(pair<T1, T2>&) noexcept; // C++14
Implement n3584 - Addressing Tuples by Type llvm-svn: 186237
2013-07-13 10:54:05 +08:00
[libcxx] LWG2485: get() should be overloaded for const tuple&&. Patch from K-Ballo. Review: http://reviews.llvm.org/D14839 llvm-svn: 255941
2015-12-18 08:36:55 +08:00
template<class T1, class T2>
Fix some mistakes in the <utility> and <tuple> synopses. No functional change. Thannks to K-ballo for the patch llvm-svn: 253593
2015-11-20 03:45:29 +08:00
constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14
Implement n3584 - Addressing Tuples by Type llvm-svn: 186237
2013-07-13 10:54:05 +08:00
[libcxx] LWG2485: get() should be overloaded for const tuple&&. Patch from K-Ballo. Review: http://reviews.llvm.org/D14839 llvm-svn: 255941
2015-12-18 08:36:55 +08:00
template<class T1, class T2>
Implement LWG Paper n3887: Consistent Metafunction Aliases. This adds std::tuple_element_t<> as an alias for tuple_element<>::type. Clean up the synopsis for tuple_element in <utility> as well. llvm-svn: 202673
2014-03-03 14:18:11 +08:00
constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14
Implement n3584 - Addressing Tuples by Type llvm-svn: 186237
2013-07-13 10:54:05 +08:00
[libcxx] LWG2485: get() should be overloaded for const tuple&&. Patch from K-Ballo. Review: http://reviews.llvm.org/D14839 llvm-svn: 255941
2015-12-18 08:36:55 +08:00
template<class T1, class T2>
constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14
template<class T1, class T2>
constexpr T1& get(pair<T2, T1>&) noexcept; // C++14
template<class T1, class T2>
constexpr const T1& get(const pair<T2, T1>&) noexcept; // C++14
template<class T1, class T2>
constexpr T1&& get(pair<T2, T1>&&) noexcept; // C++14
template<class T1, class T2>
constexpr const T1&& get(const pair<T2, T1>&&) noexcept; // C++14
Implement n3658 - Compile-time integer sequences llvm-svn: 185343
2013-07-02 00:26:55 +08:00
// C++14
template<class T, T... I>
struct integer_sequence
{
typedef T value_type;
static constexpr size_t size() noexcept;
};
template<size_t... I>
using index_sequence = integer_sequence<size_t, I...>;
template<class T, T N>
using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
template<size_t N>
using make_index_sequence = make_integer_sequence<size_t, N>;
template<class... T>
using index_sequence_for = make_index_sequence<sizeof...(T)>;
Test commit; remove some spaces at EOL. No functional change. llvm-svn: 273121
2016-06-20 03:29:52 +08:00
template<class T, class U=T>
[libc++] P2401: conditional noexcept for std::exchange Implement P2401 which adds a `noexcept` specification to `std::exchange`. Treated as a defect fix which is the motivation for applying this change to all standards mode rather than just C++23 or later as the paper suggests. Reviewed By: Quuxplusone, Mordante, #libc Differential Revision: https://reviews.llvm.org/D111481
2021-10-12 02:34:37 +08:00
constexpr T exchange(T& obj, U&& new_value)
noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_assignable<T&, U>::value); // constexpr in C++17, noexcept in C++23
Implement the in_place tags from p0032r3. That paper also has changes to any/optional but those will be implemented later. llvm-svn: 276537
2016-07-24 06:19:19 +08:00
// 20.2.7, in-place construction // C++17
Implement P0504R0: Revisiting in-place tag types for any/optional/variant llvm-svn: 287250
2016-11-18 03:24:04 +08:00
struct in_place_t {
explicit in_place_t() = default;
};
inline constexpr in_place_t in_place{};
Implement the in_place tags from p0032r3. That paper also has changes to any/optional but those will be implemented later. llvm-svn: 276537
2016-07-24 06:19:19 +08:00
template <class T>
Implement P0504R0: Revisiting in-place tag types for any/optional/variant llvm-svn: 287250
2016-11-18 03:24:04 +08:00
struct in_place_type_t {
explicit in_place_type_t() = default;
};
Implement the in_place tags from p0032r3. That paper also has changes to any/optional but those will be implemented later. llvm-svn: 276537
2016-07-24 06:19:19 +08:00
template <class T>
Implement P0504R0: Revisiting in-place tag types for any/optional/variant llvm-svn: 287250
2016-11-18 03:24:04 +08:00
inline constexpr in_place_type_t<T> in_place_type{};
Implement the in_place tags from p0032r3. That paper also has changes to any/optional but those will be implemented later. llvm-svn: 276537
2016-07-24 06:19:19 +08:00
template <size_t I>
Implement P0504R0: Revisiting in-place tag types for any/optional/variant llvm-svn: 287250
2016-11-18 03:24:04 +08:00
struct in_place_index_t {
explicit in_place_index_t() = default;
};
template <size_t I>
inline constexpr in_place_index_t<I> in_place_index{};
Implement the in_place tags from p0032r3. That paper also has changes to any/optional but those will be implemented later. llvm-svn: 276537
2016-07-24 06:19:19 +08:00
[libc++] [C++2b] [P1682] Add to_underlying. * https://wg21.link/P1682 Reviewed By: ldionne, Mordante, #libc Differential Revision: https://reviews.llvm.org/D97365
2021-03-05 16:19:39 +08:00
// [utility.underlying], to_underlying
template <class T>
constexpr underlying_type_t<T> to_underlying( T value ) noexcept; // C++2b
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
} // std
*/
[libc++] Ensure that all public C++ headers include <__assert> This patch changes the requirement for getting the declaration of the assertion handler from including <__assert> to including any public C++ header of the library. Note that C compatibility headers are excluded because we don't implement all the C headers ourselves -- some of them are taken straight from the C library, like assert.h. It also adds a generated test to check it. Furthermore, this new generated test is designed in a way that will make it possible to replace almost all the existing test-generation scripts with this system in upcoming patches. Differential Revision: https://reviews.llvm.org/D122506
2022-03-26 00:55:36 +08:00
#include <__assert> // all public C++ headers provide the assertion handler
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
#include <__config>
#include <__tuple>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/as_const.h>
[libc++] [ranges] Introduce _LIBCPP_AUTO_CAST(x) for auto(x). Clang is gaining `auto(x)` support in D113393; sadly there seems to be no feature-test macro for it. Zhihao is opening a core issue for that macro. Use `_LIBCPP_AUTO_CAST` where C++20 specifies we should use `auto(x)`; stop using `__decay_copy(x)` in those places. In fact, remove `__decay_copy` entirely. As of C++20, it's purely a paper specification tool signifying "Return just `x`, but it was perfect-forwarded, so we understand you're going to have to call its move-constructor sometimes." I believe there's no reason we'd ever need to do its operation explicitly in code. This heisenbugs away a test failure on MinGW; see D112214. Differential Revision: https://reviews.llvm.org/D115686
2021-12-14 08:21:38 +08:00
#include <__utility/auto_cast.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/cmp.h>
[libcxx][modularisation] moves <utility> content out of <type_traits> Moves: * `std::move`, `std::forward`, `std::declval`, and `std::swap` into `__utility/${FUNCTION_NAME}`. * `std::swap_ranges` and `std::iter_swap` into `__algorithm/${FUNCTION_NAME}` Differential Revision: https://reviews.llvm.org/D103734
2021-06-05 10:47:47 +08:00
#include <__utility/declval.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/exchange.h>
[libcxx][modularisation] moves <utility> content out of <type_traits> Moves: * `std::move`, `std::forward`, `std::declval`, and `std::swap` into `__utility/${FUNCTION_NAME}`. * `std::swap_ranges` and `std::iter_swap` into `__algorithm/${FUNCTION_NAME}` Differential Revision: https://reviews.llvm.org/D103734
2021-06-05 10:47:47 +08:00
#include <__utility/forward.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/in_place.h>
#include <__utility/integer_sequence.h>
[libcxx][modularisation] moves <utility> content out of <type_traits> Moves: * `std::move`, `std::forward`, `std::declval`, and `std::swap` into `__utility/${FUNCTION_NAME}`. * `std::swap_ranges` and `std::iter_swap` into `__algorithm/${FUNCTION_NAME}` Differential Revision: https://reviews.llvm.org/D103734
2021-06-05 10:47:47 +08:00
#include <__utility/move.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/pair.h>
#include <__utility/piecewise_construct.h>
[libc++] [P1614] Implement [cmp.alg]'s std::{strong,weak,partial}_order. This does not include `std::compare_*_fallback`; those are coming later. There's still an open question of how to implement std::strong_order for `long double`, which has 80 value bits and 48 padding bits on x86-64, and which is presumably *not* IEEE 754-compliant on PPC64 and so on. So that part is left unimplemented. Differential Revision: https://reviews.llvm.org/D110738
2021-07-29 10:04:18 +08:00
#include <__utility/priority_tag.h>
[libcxx][modularisation] splits `<utility>` into self-contained headers * moves `std::hash` and `std::unary_function` into `__functional` * Everything else goes into `__utility/${NAME}.h` Differential Revision: https://reviews.llvm.org/D104002
2021-06-10 07:10:17 +08:00
#include <__utility/rel_ops.h>
[libcxx][modularisation] moves <utility> content out of <type_traits> Moves: * `std::move`, `std::forward`, `std::declval`, and `std::swap` into `__utility/${FUNCTION_NAME}`. * `std::swap_ranges` and `std::iter_swap` into `__algorithm/${FUNCTION_NAME}` Differential Revision: https://reviews.llvm.org/D103734
2021-06-05 10:47:47 +08:00
#include <__utility/swap.h>
[libc++] Adds __utility/to_underlying.h. During the review of D97115 it was mentioned adding the `<utility>` header for `__to_underlying` was a bit unfortunate. Nowadays we tend to implement smaller headers, so a good reason to move `std::to_underlying` to its own header and adjust `<charconv>` to use the new header. Differential Revision: https://reviews.llvm.org/D101233
2021-04-24 23:28:35 +08:00
#include <__utility/to_underlying.h>
[libc++] Add a helper class to write code with the strong exception guarantee __transaction is a helper class that allows rolling back code in case an exception is thrown. The main goal is to reduce the clutter when code needs to be guarded with `#if _LIBCPP_NO_EXCEPTIONS`. Differential Revision: https://reviews.llvm.org/D115730
2021-12-14 23:18:19 +08:00
#include <__utility/transaction.h>
[libc++] Implement P0627R6 (Function to mark unreachable code) Reviewed By: ldionne, Quuxplusone, #libc Spies: arichardson, mstorsjo, libcxx-commits, mgorny Differential Revision: https://reviews.llvm.org/D119152
2022-02-15 01:26:02 +08:00
#include <__utility/unreachable.h>
[libc++] Header inclusion tests. As mandated by the Standard's various synopses, e.g. [iterator.synopsis]. Searching the TeX source for '#include' is a good way to find all of these mandates. The new tests are all autogenerated by utils/generate_header_inclusion_tests.py. I was SHOCKED by how many mandates there are, and how many of them libc++ wasn't conforming with. Differential Revision: https://reviews.llvm.org/D99309
2021-03-25 06:19:12 +08:00
#include <compare>
[libc++] Alphabetize and include-what-you-use. NFCI. Differential Revision: https://reviews.llvm.org/D102781
2021-05-19 23:57:04 +08:00
#include <initializer_list>
Implement the infrastructure for feature-test macros. Very few actual feature test macros, though. Reviewed as: https://reviews.llvm.org/D51955 llvm-svn: 342073
2018-09-13 03:41:40 +08:00
#include <version>
libcxx initial import llvm-svn: 103490
2010-05-12 03:42:16 +08:00
[libc++] Add missing `#pragma GCC system_header` in a few headers. NFCI.
2021-12-06 02:08:36 +08:00
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
[libc++] Normalize all our '#pragma GCC system_header', and regression-test. Now we'll notice if a header forgets to include this magic phrase. Differential Revision: https://reviews.llvm.org/D118800
2022-02-02 09:16:40 +08:00
# pragma GCC system_header
[libc++] Add missing `#pragma GCC system_header` in a few headers. NFCI.
2021-12-06 02:08:36 +08:00
#endif
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // _LIBCPP_UTILITY