#include <initializer_list>
#endif
-#define __glibcxx_want_constexpr_algorithms
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifndef _GLIBCXX_ALIGN_H
#define _GLIBCXX_ALIGN_H 1
-#include <bits/c++config.h>
-
-#define __glibcxx_want_assume_aligned
-#include <bits/version.h>
-
#include <bit> // std::has_single_bit
#include <stdint.h> // uintptr_t
#include <debug/assertions.h> // _GLIBCXX_DEBUG_ASSERT
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
}
}
-#ifdef __cpp_lib_assume_aligned // C++ >= 20
+#ifdef __glibcxx_assume_aligned // C++ >= 20
/** @brief Inform the compiler that a pointer is aligned.
*
* @tparam _Align An alignment value (i.e. a power of two)
return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align));
}
}
-#endif // __cpp_lib_assume_aligned
+#endif // __glibcxx_assume_aligned
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
# endif
#endif
-#define __glibcxx_want_constexpr_dynamic_alloc
-#define __glibcxx_want_allocator_traits_is_always_equal
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#include <type_traits>
#endif
-#define __glibcxx_want_incomplete_container_elements
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
#endif
-#define __glibcxx_want_atomic_value_initialization
-#define __glibcxx_want_atomic_flag_test
#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
}
/// @cond undocumented
-#if __cpp_lib_atomic_value_initialization
+#if __glibcxx_atomic_value_initialization
# define _GLIBCXX20_INIT(I) = I
#else
# define _GLIBCXX20_INIT(I)
return __atomic_test_and_set (&_M_i, int(__m));
}
-#ifdef __cpp_lib_atomic_flag_test // C++ >= 20
+#ifdef __glibcxx_atomic_flag_test // C++ >= 20
_GLIBCXX_ALWAYS_INLINE bool
test(memory_order __m = memory_order_seq_cst) const noexcept
{
}
#endif
-#if __cpp_lib_atomic_wait // C++ >= 20 && (linux_futex || gthread)
+#if __glibcxx_atomic_wait // C++ >= 20 && (linux_futex || gthread)
_GLIBCXX_ALWAYS_INLINE void
wait(bool __old,
memory_order __m = memory_order_seq_cst) const noexcept
{ std::__atomic_notify_address(&_M_i, true); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
clear(memory_order __m = memory_order_seq_cst) noexcept
__cmpexch_failure_order(__m));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(__int_type __old,
memory_order __m = memory_order_seq_cst) const noexcept
{ std::__atomic_notify_address(&_M_i, true); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE __int_type
fetch_add(__int_type __i,
int(__m1), int(__m2));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(__pointer_type __old,
memory_order __m = memory_order_seq_cst) const noexcept
{ std::__atomic_notify_address(&_M_p, true); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE __pointer_type
fetch_add(ptrdiff_t __d,
*__ptr, __expected, __desired, false, __success, __failure);
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
template<typename _Tp>
_GLIBCXX_ALWAYS_INLINE void
wait(const _Tp* __ptr, _Val<_Tp> __old,
{ std::__atomic_notify_address(__ptr, true); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
template<typename _Tp>
_GLIBCXX_ALWAYS_INLINE _Tp
__cmpexch_failure_order(__order));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
{ __atomic_impl::wait(&_M_fp, __old, __m); }
{ __atomic_impl::notify_all(&_M_fp); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
value_type
fetch_add(value_type __i,
__cmpexch_failure_order(__order));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
{ __atomic_impl::wait(_M_ptr, __old, __m); }
{ __atomic_impl::notify_all(_M_ptr); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
private:
_Tp* _M_ptr;
__cmpexch_failure_order(__order));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
{ __atomic_impl::wait(_M_ptr, __old, __m); }
{ __atomic_impl::notify_all(_M_ptr); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
value_type
fetch_add(value_type __i,
__cmpexch_failure_order(__order));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
{ __atomic_impl::wait(_M_ptr, __old, __m); }
{ __atomic_impl::notify_all(_M_ptr); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
value_type
fetch_add(value_type __i,
__cmpexch_failure_order(__order));
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE void
wait(_Tp* __old, memory_order __m = memory_order_seq_cst) const noexcept
{ __atomic_impl::wait(_M_ptr, __old, __m); }
{ __atomic_impl::notify_all(_M_ptr); }
// TODO add const volatile overload
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
_GLIBCXX_ALWAYS_INLINE value_type
fetch_add(difference_type __d,
#include <bits/atomic_wait.h>
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
#include <bits/functional_hash.h>
#include <bits/this_thread_sleep.h>
#include <bits/chrono.h>
#pragma GCC system_header
-#define __glibcxx_want_atomic_wait
#include <bits/version.h>
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
#include <bits/functional_hash.h>
#include <bits/gthr.h>
#include <ext/numeric_traits.h>
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // __cpp_lib_atomic_wait
+#endif // __glibcxx_atomic_wait
#endif // _GLIBCXX_ATOMIC_WAIT_H
# include <charconv>
#endif
-#define __glibcxx_want_constexpr_string
-#define __glibcxx_want_string_resize_and_overwrite
-#define __glibcxx_want_string_udls
-#define __glibcxx_want_to_string
#include <bits/version.h>
#if ! _GLIBCXX_USE_CXX11_ABI
_S_allocate(_Char_alloc_type& __a, size_type __n)
{
pointer __p = _Alloc_traits::allocate(__a, __n);
-#if __cpp_lib_constexpr_string >= 201907L
+#if __glibcxx_constexpr_string >= 201907L
// std::char_traits begins the lifetime of characters,
// but custom traits might not, so do it here.
if constexpr (!is_same_v<_Traits, char_traits<_CharT>>)
void
_M_init_local_buf() _GLIBCXX_NOEXCEPT
{
-#if __cpp_lib_is_constant_evaluated
+#if __glibcxx_is_constant_evaluated
if (std::is_constant_evaluated())
for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
_M_local_buf[__i] = _CharT();
#pragma GCC diagnostic pop
#endif
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
/** Resize the string and call a function to fill it.
*
* @param __n The maximum size requested.
return __str;
}
-#if __cpp_lib_to_string >= 202306L
+#if __glibcxx_to_string >= 202306L // C++ >= 26
[[nodiscard]]
inline string
}
}
-#if __cpp_lib_constexpr_string >= 201907L
+#if __glibcxx_constexpr_string >= 201907L
constexpr
#endif
inline wstring
to_wstring(unsigned long long __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }
-#if __cpp_lib_to_string || _GLIBCXX_USE_C99_STDIO
+#if __glibcxx_to_string || _GLIBCXX_USE_C99_STDIO
_GLIBCXX_NODISCARD
inline wstring
to_wstring(float __val)
{ };
#endif
-#ifdef __cpp_lib_string_udls // C++ >= 14
+#ifdef __glibcxx_string_udls // C++ >= 14
inline namespace literals
{
inline namespace string_literals
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"
-#if __cpp_lib_constexpr_string >= 201907L
+#if __glibcxx_constexpr_string >= 201907L
# define _GLIBCXX_STRING_CONSTEXPR constexpr
#else
# define _GLIBCXX_STRING_CONSTEXPR
#pragma GCC diagnostic pop
} // inline namespace string_literals
} // inline namespace literals
-#endif // __cpp_lib_string_udls
+#endif // __glibcxx_string_udls
#if __cplusplus >= 201703L
namespace __detail::__variant
return __n;
}
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _Operation>
[[__gnu__::__always_inline__]]
template<typename _Operation>
_GLIBCXX20_CONSTEXPR void
basic_string<_CharT, _Traits, _Alloc>::
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
resize_and_overwrite(const size_type __n, _Operation __op)
#else
__resize_and_overwrite(const size_type __n, _Operation __op)
#endif // _GLIBCXX_USE_CXX11_ABI
-#if __cpp_lib_constexpr_string >= 201907L
+#if __glibcxx_constexpr_string >= 201907L
# define _GLIBCXX_STRING_CONSTEXPR constexpr
#else
# define _GLIBCXX_STRING_CONSTEXPR
# define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
#endif
-#define __glibcxx_want_constexpr_char_traits
-#include <bits/version.h>
-
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#pragma GCC system_header
-#define __glibcxx_want_chrono
-#define __glibcxx_want_chrono_udls
-#include <bits/version.h>
-
#if __cplusplus >= 201103L
#include <ratio>
# include <compare>
#endif
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
{ };
#endif // C++20
-#ifdef __cpp_lib_chrono // C++ >= 17 && HOSTED
+#ifdef __glibcxx_chrono // C++ >= 17 && HOSTED
/** Convert a `duration` to type `ToDur` and round down.
*
* If the duration cannot be represented exactly in the result type,
// Make chrono::ceil<D> also usable as chrono::__detail::ceil<D>.
namespace __detail { using chrono::ceil; }
-#else // ! __cpp_lib_chrono
+#else // ! __glibcxx_chrono
// We want to use ceil even when compiling for earlier standards versions.
// C++11 only allows a single statement in a constexpr function, so we
return __detail::__ceil_impl(chrono::duration_cast<_ToDur>(__d), __d);
}
}
-#endif // __cpp_lib_chrono
+#endif // __glibcxx_chrono
/// duration_values
template<typename _Rep>
#endif // C++20
} // namespace chrono
-#ifdef __cpp_lib_chrono_udls // C++ >= 14 && HOSTED
+#ifdef __glibcxx_chrono_udls // C++ >= 14 && HOSTED
inline namespace literals
{
/** ISO C++ 2014 namespace for suffixes for duration literals.
{
using namespace literals::chrono_literals;
} // namespace chrono
-#endif // __cpp_lib_chrono_udls
+#endif // __glibcxx_chrono_udls
#if __cplusplus >= 201703L
namespace filesystem
#include <ext/atomicity.h> // _Atomic_word, __is_single_threaded
-#define __glibcxx_want_constexpr_string
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#pragma GCC diagnostic pop
#endif
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
/** Resize the string and call a function to fill it.
*
* @param __n The maximum size requested.
template<typename _Operation>
void
resize_and_overwrite(size_type __n, _Operation __op);
-#endif // __cpp_lib_string_resize_and_overwrite
+#endif // __glibcxx_string_resize_and_overwrite
#if __cplusplus >= 201103L
/// Non-standard version of resize_and_overwrite for C++11 and above.
return __n;
}
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
template<typename _CharT, typename _Traits, typename _Alloc>
template<typename _Operation>
[[__gnu__::__always_inline__]]
template<typename _Operation>
void
basic_string<_CharT, _Traits, _Alloc>::
-#ifdef __cpp_lib_string_resize_and_overwrite // C++ >= 23
+#ifdef __glibcxx_string_resize_and_overwrite // C++ >= 23
resize_and_overwrite(const size_type __n, _Operation __op)
#else
__resize_and_overwrite(const size_type __n, _Operation __op)
#include <bits/c++config.h>
-#define __glibcxx_want_erase_if
-#include <bits/version.h>
-
+// Used by C++17 containers and Library Fundamentals v2 headers.
#if __cplusplus >= 201402L
namespace std
{
#include <ext/alloc_traits.h>
#include <ext/aligned_buffer.h>
-#define __glibcxx_want_list_remove_return_type
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @}
private:
-#ifdef __cpp_lib_list_remove_return_type // C++20 && HOSTED
+#ifdef __glibcxx_list_remove_return_type // C++20 && HOSTED
using __remove_return_type = size_type;
# define _GLIBCXX_FWDLIST_REMOVE_RETURN_TYPE_TAG \
__attribute__((__abi_tag__("__cxx20")))
# include <bits/node_handle.h>
#endif
-#define __glibcxx_want_generic_unordered_lookup
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
std::pair<const_iterator, const_iterator>
equal_range(const key_type& __k) const;
-#ifdef __cpp_lib_generic_unordered_lookup // C++ >= 20 && HOSTED
+#ifdef __glibcxx_generic_unordered_lookup // C++ >= 20 && HOSTED
template<typename _Kt,
typename = __has_is_transparent_t<_Hash, _Kt>,
typename = __has_is_transparent_t<_Equal, _Kt>>
typename = __has_is_transparent_t<_Equal, _Kt>>
pair<const_iterator, const_iterator>
_M_equal_range_tr(const _Kt& __k) const;
-#endif // __cpp_lib_generic_unordered_lookup
+#endif // __glibcxx_generic_unordered_lookup
private:
// Bucket index computation helpers.
# include <system_error>
#endif
-#define __glibcxx_want_ios_noreplace
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
static const openmode __noreplace = _S_noreplace;
-#ifdef __cpp_lib_ios_noreplace // C++ >= 23 && HOSTED
+#ifdef __glibcxx_ios_noreplace // C++ >= 23 && HOSTED
/// Open a file in exclusive mode.
static const openmode noreplace = _S_noreplace;
#endif
#include <ext/numeric_traits.h> // __int_traits
#include <debug/assertions.h>
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
# include <bits/utility.h> // index_sequence
# include <tuple> // tuple, forward_as_tuple
#endif
}
#endif // C++2a
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
template<typename _Tp1, typename... _Args>
__attribute__((__nonnull__))
typename __not_pair<_Tp1>::type
#endif
private:
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
using __uses_alloc1_ = __uses_alloc1<polymorphic_allocator>;
using __uses_alloc2_ = __uses_alloc2<polymorphic_allocator>;
# include <type_traits> // Brings in std::declval too.
#endif
-#define __glibcxx_want_addressof_constexpr
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#pragma GCC system_header
-#define __glibcxx_want_move_only_function
#include <bits/version.h>
-#ifdef __cpp_lib_move_only_function // C++ >= 23 && HOSTED
+#ifdef __glibcxx_move_only_function // C++ >= 23 && HOSTED
#include <bits/invoke.h>
#include <bits/utility.h>
#define _GLIBCXX_MOF_REF &&
#include "mofunc_impl.h"
-#endif // __cpp_lib_move_only_function
+#endif // __glibcxx_move_only_function
#endif // _GLIBCXX_MOVE_ONLY_FUNCTION_H
#pragma GCC system_header
-#define __glibcxx_want_node_extract
#include <bits/version.h>
-#ifdef __cpp_lib_node_extract // C++ >= 17 && HOSTED
+#ifdef __glibcxx_node_extract // C++ >= 17 && HOSTED
#include <new>
#include <bits/alloc_traits.h>
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // __cpp_lib_node_extract
+#endif // __glibcxx_node_extract
#endif
#include <bits/move.h>
-#define __glibcxx_want_constexpr_memory
-#define __glibcxx_want_to_address
-#include <bits/version.h>
-
#if __cplusplus > 201703L
#include <concepts>
namespace __gnu_debug { struct _Safe_iterator_base; }
return __ptr;
}
-#ifndef __cpp_lib_to_address // C++ < 20
+#ifndef __glibcxx_to_address // C++ < 20
template<typename _Ptr>
constexpr typename std::pointer_traits<_Ptr>::element_type*
__to_address(const _Ptr& __ptr)
constexpr auto
to_address(const _Ptr& __ptr) noexcept
{ return std::__to_address(__ptr); }
-#endif // __cpp_lib_to_address
+#endif // __glibcxx_to_address
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#pragma GCC system_header
-#define __glibcxx_want_nonmember_container_access
-#define __glibcxx_want_ssize
-#include <bits/version.h>
-
#if __cplusplus >= 201103L
#include <initializer_list>
#include <type_traits> // common_type_t, make_signed_t
#endif // C++14
-#ifdef __cpp_lib_nonmember_container_access // C++ >= 17
+#ifdef __glibcxx_nonmember_container_access // C++ >= 17
/**
* @brief Return the size of a container.
* @param __cont Container.
constexpr const _Tp*
data(initializer_list<_Tp> __il) noexcept
{ return __il.begin(); }
-#endif // __cpp_lib_nonmember_container_access
+#endif // __glibcxx_nonmember_container_access
-#ifdef __cpp_lib_ssize // C++ >= 20
+#ifdef __glibcxx_ssize // C++ >= 20
template<typename _Container>
[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
constexpr ptrdiff_t
ssize(const _Tp (&)[_Num]) noexcept
{ return _Num; }
-#endif // __cpp_lib_ssize
+#endif // __glibcxx_ssize
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#include <bits/ranges_util.h>
#include <bits/uniform_int_dist.h> // concept uniform_random_bit_generator
-#define __glibcxx_want_ranges_contains
-#define __glibcxx_want_ranges_find_last
-#define __glibcxx_want_ranges_fold
-#define __glibcxx_want_ranges_iota
-#define __glibcxx_want_shift
-#include <bits/version.h>
-
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
inline constexpr __prev_permutation_fn prev_permutation{};
-#if __cpp_lib_ranges_contains >= 202207L // C++ >= 23
+#if __glibcxx_ranges_contains >= 202207L // C++ >= 23
struct __contains_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
inline constexpr __contains_subrange_fn contains_subrange{};
-#endif // __cpp_lib_ranges_contains
+#endif // __glibcxx_ranges_contains
-#if __cpp_lib_ranges_iota >= 202202L // C++ >= 23
+#if __glibcxx_ranges_iota >= 202202L // C++ >= 23
template<typename _Out, typename _Tp>
struct out_value_result
inline constexpr __iota_fn iota{};
-#endif // __cpp_lib_ranges_iota
+#endif // __glibcxx_ranges_iota
-#if __cpp_lib_ranges_find_last >= 202207L // C++ >= 23
+#if __glibcxx_ranges_find_last >= 202207L // C++ >= 23
struct __find_last_fn
{
inline constexpr __find_last_if_not_fn find_last_if_not{};
-#endif // __cpp_lib_ranges_find_last
+#endif // __glibcxx_ranges_find_last
-#if __cpp_lib_ranges_fold >= 202207L // C++ >= 23
+#if __glibcxx_ranges_fold >= 202207L // C++ >= 23
template<typename _Iter, typename _Tp>
struct in_value_result
};
inline constexpr __fold_right_last_fn fold_right_last{};
-#endif // __cpp_lib_ranges_fold
+#endif // __glibcxx_ranges_fold
} // namespace ranges
template<typename _ForwardIterator>
#ifndef _RANGES_CMP_H
#define _RANGES_CMP_H 1
-#define __glibcxx_want_ranges
-#include <bits/version.h>
-
#if __cplusplus > 201703L
# include <bits/move.h>
# include <concepts>
using is_transparent = __is_transparent;
};
-#ifdef __cpp_lib_ranges // C++ >= 20
+#ifdef __glibcxx_ranges // C++ >= 20
namespace ranges
{
namespace __detail
};
} // namespace ranges
-#endif // __cpp_lib_ranges
+#endif // __glibcxx_ranges
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++20
# include <bits/ranges_base.h>
# include <bits/utility.h>
-#ifdef __cpp_lib_ranges
+#ifdef __glibcxx_ranges
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#include <bits/atomic_base.h>
#include <bits/chrono.h>
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
#include <bits/atomic_timed_wait.h>
#include <ext/numeric_traits.h>
#endif // __cpp_lib_atomic_wait
};
#endif // _GLIBCXX_HAVE_POSIX_SEMAPHORE
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
struct __atomic_semaphore
{
static constexpr ptrdiff_t _S_max = __gnu_cxx::__int_traits<int>::__max;
// Note: the _GLIBCXX_USE_POSIX_SEMAPHORE macro can be used to force the
// use of Posix semaphores (sem_t). Doing so however, alters the ABI.
-#if defined __cpp_lib_atomic_wait && !_GLIBCXX_USE_POSIX_SEMAPHORE
+#if defined __glibcxx_atomic_wait && !_GLIBCXX_USE_POSIX_SEMAPHORE
using __semaphore_impl = __atomic_semaphore;
#elif _GLIBCXX_HAVE_POSIX_SEMAPHORE
using __semaphore_impl = __platform_semaphore;
#include <iosfwd> // std::basic_ostream
#include <bits/shared_ptr_base.h>
-#define __glibcxx_want_shared_ptr_weak_type
-#define __glibcxx_want_enable_shared_from_this
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @cond undocumented
// Constraint for overloads taking non-array types.
-#if __cpp_concepts && __cpp_lib_type_trait_variable_templates
+#if __cpp_concepts && __glibcxx_type_trait_variable_templates
template<typename _Tp>
requires (!is_array_v<_Tp>)
using _NonArray = _Tp;
using _NonArray = __enable_if_t<!is_array<_Tp>::value, _Tp>;
#endif
-#if __cpp_lib_shared_ptr_arrays >= 201707L
+#if __glibcxx_shared_ptr_arrays >= 201707L
// Constraint for overloads taking array types with unknown bound, U[].
#if __cpp_concepts
template<typename _Tp>
= __enable_if_t<__is_array_known_bounds<_Tp>::value, _Tp>;
#endif
-#if __cpp_lib_smart_ptr_for_overwrite
+#if __glibcxx_smart_ptr_for_overwrite
// Constraint for overloads taking either non-array or bounded array, U[N].
#if __cpp_concepts
template<typename _Tp>
/// The type pointed to by the stored pointer, remove_extent_t<_Tp>
using element_type = typename __shared_ptr<_Tp>::element_type;
-#ifdef __cpp_lib_shared_ptr_weak_type // C++ >= 17 && HOSTED
+#ifdef __glibcxx_shared_ptr_weak_type // C++ >= 17 && HOSTED
/// The corresponding weak_ptr type for this shared_ptr
/// @since C++17
using weak_type = weak_ptr<_Tp>;
friend shared_ptr<_NonArray<_Yp>>
make_shared(_Args&&...);
-#if __cpp_lib_shared_ptr_arrays >= 201707L
+#if __glibcxx_shared_ptr_arrays >= 201707L
// This constructor is non-standard, it is used by allocate_shared<T[]>.
template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
friend shared_ptr<_BoundedArray<_Yp>>
make_shared(const remove_extent_t<_Yp>&);
-#if __cpp_lib_smart_ptr_for_overwrite
+#if __glibcxx_smart_ptr_for_overwrite
template<typename _Yp, typename _Alloc>
friend shared_ptr<_NotUnboundedArray<_Yp>>
allocate_shared_for_overwrite(const _Alloc&);
shared_from_this() const
{ return shared_ptr<const _Tp>(this->_M_weak_this); }
-#ifdef __cpp_lib_enable_shared_from_this // C++ >= 17 && HOSTED
+#ifdef __glibcxx_enable_shared_from_this // C++ >= 17 && HOSTED
/** @{
* Get a `weak_ptr` referring to the object that has `*this` as its base.
* @since C++17
std::forward<_Args>(__args)...);
}
-#if __cpp_lib_shared_ptr_arrays >= 201707L
+#if __glibcxx_shared_ptr_arrays >= 201707L
/// @cond undocumented
template<typename _Tp, typename _Alloc = allocator<void>>
auto
std::__addressof(__u));
}
-#if __cpp_lib_smart_ptr_for_overwrite
+#if __glibcxx_smart_ptr_for_overwrite
template<typename _Tp, typename _Alloc>
inline shared_ptr<_NotUnboundedArray<_Tp>>
allocate_shared_for_overwrite(const _Alloc& __a)
#define _SHARED_PTR_ATOMIC_H 1
#include <bits/atomic_base.h>
-
-#define __glibcxx_want_atomic_shared_ptr
-#include <bits/version.h>
+#include <bits/shared_ptr.h>
// Annotations for the custom locking in atomic<shared_ptr<T>>.
#if defined _GLIBCXX_TSAN && __has_include(<sanitizer/tsan_interface.h>)
/// @} group pointer_abstractions
-#ifdef __cpp_lib_atomic_shared_ptr // C++ >= 20 && HOSTED
+#ifdef __glibcxx_atomic_shared_ptr // C++ >= 20 && HOSTED
template<typename _Tp>
struct atomic;
auto __current = _M_val.load(memory_order_relaxed);
while (__current & _S_lock_bit)
{
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
__detail::__thread_relax();
#endif
__current = _M_val.load(memory_order_relaxed);
memory_order_relaxed))
{
_GLIBCXX_TSAN_MUTEX_TRY_LOCK_FAILED(&_M_val);
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
__detail::__thread_relax();
#endif
__current = __current & ~_S_lock_bit;
__c._M_pi = reinterpret_cast<pointer>(__x & ~_S_lock_bit);
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
// Precondition: caller holds lock!
void
_M_wait_unlock(memory_order __o) const noexcept
return __result;
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
void
wait(value_type __old, memory_order __o) const noexcept
{
return compare_exchange_strong(__expected, std::move(__desired), __o);
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
void
wait(value_type __old,
memory_order __o = memory_order_seq_cst) const noexcept
return compare_exchange_strong(__expected, std::move(__desired), __o);
}
-#if __cpp_lib_atomic_wait
+#if __glibcxx_atomic_wait
void
wait(value_type __old,
memory_order __o = memory_order_seq_cst) const noexcept
# include <bits/stl_uninitialized.h>
#endif
-#define __glibcxx_want_smart_ptr_for_overwrite
-#define __glibcxx_want_shared_ptr_arrays
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<_Lock_policy _Lp = __default_lock_policy>
class __shared_count;
-#if __cplusplus >= 202002L
+#ifdef __glibcxx_atomic_shared_ptr
template<typename>
class _Sp_atomic;
#endif
_Impl _M_impl;
};
-#ifdef __cpp_lib_smart_ptr_for_overwrite // C++ >= 20 && HOSTED
+#ifdef __glibcxx_smart_ptr_for_overwrite // C++ >= 20 && HOSTED
struct _Sp_overwrite_tag { };
// Partial specialization used for make_shared_for_overwrite<non-array>().
_M_get_deleter(const std::type_info&) noexcept override
{ return nullptr; }
};
-#endif // __cpp_lib_smart_ptr_for_overwrite
+#endif // __glibcxx_smart_ptr_for_overwrite
-#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
+#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
struct _Sp_overwrite_tag;
// For make_shared<T[]>, make_shared<T[N]>, allocate_shared<T[]> etc.
_M_get_deleter(const std::type_info&) noexcept override
{ return nullptr; }
};
-#endif // __cpp_lib_shared_ptr_arrays >= 201707L
+#endif // __glibcxx_shared_ptr_arrays >= 201707L
// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
template<typename _Tp>
struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };
-#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
+#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
template<typename _Alloc>
struct __not_alloc_shared_tag<_Sp_counted_array_base<_Alloc>> { };
#endif
__p = __pi->_M_ptr();
}
-#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
+#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
template<typename _Tp, typename _Alloc, typename _Init>
__shared_count(_Tp*& __p, const _Sp_counted_array_base<_Alloc>& __a,
_Init __init)
private:
friend class __weak_count<_Lp>;
-#if __cplusplus >= 202002L
+#ifdef __glibcxx_atomic_shared_ptr
template<typename> friend class _Sp_atomic;
#endif
private:
friend class __shared_count<_Lp>;
-#if __cplusplus >= 202002L
+#ifdef __glibcxx_atomic_shared_ptr
template<typename> friend class _Sp_atomic;
#endif
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);
-#if __cpp_lib_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
+#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
// This constructor is non-standard, it is used by allocate_shared<T[]>.
template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
__shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
template<typename _Del, typename _Tp1>
friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;
-#if __cplusplus >= 202002L
+#ifdef __glibcxx_atomic_shared_ptr
friend _Sp_atomic<shared_ptr<_Tp>>;
#endif
template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
friend class __enable_shared_from_this<_Tp, _Lp>;
friend class enable_shared_from_this<_Tp>;
-#if __cplusplus >= 202002L
+#ifdef __glibcxx_atomic_shared_ptr
friend _Sp_atomic<weak_ptr<_Tp>>;
#endif
# endif
#endif
-#define __glibcxx_want_clamp
-#define __glibcxx_want_sample
-#include <bits/version.h>
-
// See concept_check.h for the __glibcxx_*_requires macros.
namespace std _GLIBCXX_VISIBILITY(default)
}
#endif // C++14
-#ifdef __cpp_lib_clamp // C++ >= 17
+#ifdef __glibcxx_clamp // C++ >= 17
/**
* @brief Returns the value clamped between lo and hi.
* @ingroup sorting_algorithms
__glibcxx_assert(!__comp(__hi, __lo));
return std::min(std::max(__val, __lo, __comp), __hi, __comp);
}
-#endif // __cpp_lib_clamp
+#endif // __glibcxx_clamp
/**
* @brief Generate two uniformly distributed integers using a
}
#endif // C++14
-#ifdef __cpp_lib_sample // C++ >= 17
+#ifdef __glibcxx_sample // C++ >= 17
/// Take a random sample from a population.
template<typename _PopulationIterator, typename _SampleIterator,
typename _Distance, typename _UniformRandomBitGenerator>
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
std::forward<_UniformRandomBitGenerator>(__g));
}
-#endif // __cpp_lib_sample
+#endif // __glibcxx_sample
_GLIBCXX_END_NAMESPACE_ALGO
_GLIBCXX_END_NAMESPACE_VERSION
# include <compare>
#endif
-#define __glibcxx_want_robust_nonmodifying_seq_ops
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
(__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value
&& __is_pointer<_II1>::__value
&& __is_pointer<_II2>::__value
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
// For C++20 iterator_traits<volatile T*>::value_type is non-volatile
// so __is_byte<T> could be true, but we can't use memcmp with
// volatile data.
}
#endif // C++11
-#ifdef __cpp_lib_robust_nonmodifying_seq_ops // C++ >= 14
+#ifdef __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14
/**
* @brief Tests a range for element-wise equality.
* @ingroup non_mutating_algorithms
return _GLIBCXX_STD_A::__equal4(__first1, __last1, __first2, __last2,
__binary_pred);
}
-#endif // __cpp_lib_robust_nonmodifying_seq_ops
+#endif // __glibcxx_robust_nonmodifying_seq_ops
/**
* @brief Performs @b dictionary comparison on ranges.
__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}
-#if __cpp_lib_robust_nonmodifying_seq_ops // C++ >= 14
+#if __glibcxx_robust_nonmodifying_seq_ops // C++ >= 14
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
_GLIBCXX20_CONSTEXPR
#include <bits/move.h>
#endif
-#define __glibcxx_want_transparent_operators
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
* @{
*/
-#if __cpp_lib_transparent_operators // C++ >= 14
+#if __glibcxx_transparent_operators // C++ >= 14
struct __is_transparent; // undefined
template<typename _Tp = void>
};
#pragma GCC diagnostic pop
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
template<>
struct plus<void>
{
*
* @{
*/
-#if __cpp_lib_transparent_operators // C++ >= 14
+#if __glibcxx_transparent_operators // C++ >= 14
template<typename _Tp = void>
struct equal_to;
};
#pragma GCC diagnostic pop
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
/// One of the @link comparison_functors comparison functors@endlink.
template<>
struct equal_to<void>
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};
-#endif // __cpp_lib_transparent_operators
+#endif // __glibcxx_transparent_operators
/** @} */
// 20.3.4 logical operations
*
* @{
*/
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
template<typename _Tp = void>
struct logical_and;
};
#pragma GCC diagnostic pop
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
/// One of the @link logical_functors Boolean operations functors@endlink.
template<>
struct logical_and<void>
typedef __is_transparent is_transparent;
};
-#endif // __cpp_lib_transparent_operators
+#endif // __glibcxx_transparent_operators
/** @} */
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
template<typename _Tp = void>
struct bit_and;
};
#pragma GCC diagnostic pop
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
template <>
struct bit_and<void>
{
/** @} */
-#ifdef __cpp_lib_transparent_operators // C++ >= 14
+#ifdef __glibcxx_transparent_operators // C++ >= 14
template<typename _Func, typename _SfinaeType, typename = __void_t<>>
struct __has_is_transparent
{ };
# include <type_traits>
#endif
-#define __glibcxx_want_constexpr_iterator
-#define __glibcxx_want_array_constexpr
-#define __glibcxx_want_make_reverse_iterator
-#define __glibcxx_want_move_iterator_concept
-#include <bits/version.h>
-
#if __cplusplus >= 202002L
# include <compare>
# include <new>
* @{
*/
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
namespace __detail
{
// Weaken iterator_category _Cat to _Limit if it is derived from that,
template<typename _Iter>
friend class reverse_iterator;
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3435. three_way_comparable_with<reverse_iterator<int*>, [...]>
template<typename _Iter>
public:
typedef _Iterator iterator_type;
typedef typename __traits_type::pointer pointer;
-#if ! __cpp_lib_concepts
+#if ! __glibcxx_concepts
typedef typename __traits_type::difference_type difference_type;
typedef typename __traits_type::reference reference;
#else
* underlying %iterator can be converted to the type of @c current.
*/
template<typename _Iter>
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
requires __convertible<_Iter>
#endif
_GLIBCXX17_CONSTEXPR
#if __cplusplus >= 201103L
template<typename _Iter>
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
requires __convertible<_Iter>
&& assignable_from<_Iterator&, const _Iter&>
#endif
operator[](difference_type __n) const
{ return *(*this + __n); }
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
[[nodiscard]]
friend constexpr iter_rvalue_reference_t<_Iterator>
iter_move(const reverse_iterator& __i)
* iterators.
*
*/
-#if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
+#if __cplusplus <= 201703L || ! defined __glibcxx_concepts
template<typename _Iterator>
_GLIBCXX_NODISCARD
inline _GLIBCXX17_CONSTEXPR bool
__make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
-# ifdef __cpp_lib_make_reverse_iterator // C++ >= 14
+# ifdef __glibcxx_make_reverse_iterator // C++ >= 14
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 2285. make_reverse_iterator
/// Generator function for reverse_iterator.
make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }
-# if __cplusplus > 201703L && defined __cpp_lib_concepts
+# if __cplusplus > 201703L && defined __glibcxx_concepts
template<typename _Iterator1, typename _Iterator2>
requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
inline constexpr bool
disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
reverse_iterator<_Iterator2>> = true;
# endif // C++20
-# endif // __cpp_lib_make_reverse_iterator
+# endif // __glibcxx_make_reverse_iterator
template<typename _Iterator>
_GLIBCXX20_CONSTEXPR
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
-#if __cplusplus > 201703L && defined __cpp_lib_concepts
+#if __cplusplus > 201703L && defined __glibcxx_concepts
using _Iter = std::__detail::__range_iter_t<_Container>;
#else
typedef typename _Container::iterator _Iter;
/// A nested typedef for the type of whatever container you used.
typedef _Container container_type;
-#if __cplusplus > 201703L && defined __cpp_lib_concepts
+#if __cplusplus > 201703L && defined __glibcxx_concepts
using difference_type = ptrdiff_t;
#endif
* template parameter deduction, making the compiler match the correct
* types for you.
*/
-#if __cplusplus > 201703L && defined __cpp_lib_concepts
+#if __cplusplus > 201703L && defined __glibcxx_concepts
template<typename _Container>
[[nodiscard]]
constexpr insert_iterator<_Container>
typedef typename __traits_type::reference reference;
typedef typename __traits_type::pointer pointer;
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
using iterator_concept = std::__detail::__iter_concept<_Iterator>;
#endif
* @{
*/
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
template<semiregular _Sent>
class move_sentinel
{
namespace __detail
{
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
template<typename _Iterator>
struct __move_iter_cat
{ };
*/
template<typename _Iterator>
class move_iterator
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
: public __detail::__move_iter_cat<_Iterator>
#endif
{
_Iterator _M_current;
using __traits_type = iterator_traits<_Iterator>;
-#if ! (__cplusplus > 201703L && __cpp_lib_concepts)
+#if ! (__cplusplus > 201703L && __glibcxx_concepts)
using __base_ref = typename __traits_type::reference;
#endif
template<typename _Iter2>
friend class move_iterator;
-#if __cpp_lib_concepts // C++20 && concepts
+#if __glibcxx_concepts // C++20 && concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3435. three_way_comparable_with<reverse_iterator<int*>, [...]>
template<typename _Iter2>
&& convertible_to<const _Iter2&, _Iterator>;
#endif
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
static auto
_S_iter_concept()
{
public:
using iterator_type = _Iterator;
-#ifdef __cpp_lib_move_iterator_concept // C++ >= 20 && lib_concepts
+#ifdef __glibcxx_move_iterator_concept // C++ >= 20 && lib_concepts
using iterator_concept = decltype(_S_iter_concept());
// iterator_category defined in __move_iter_cat
: _M_current(std::move(__i)) { }
template<typename _Iter>
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
requires __convertible<_Iter>
#endif
_GLIBCXX17_CONSTEXPR
: _M_current(__i._M_current) { }
template<typename _Iter>
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
requires __convertible<_Iter>
&& assignable_from<_Iterator&, const _Iter&>
#endif
[[__nodiscard__]]
_GLIBCXX17_CONSTEXPR reference
operator*() const
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
{ return ranges::iter_move(_M_current); }
#else
{ return static_cast<reference>(*_M_current); }
return __tmp;
}
-#if __cpp_lib_concepts
+#if __glibcxx_concepts
constexpr void
operator++(int) requires (!forward_iterator<_Iterator>)
{ ++_M_current; }
[[__nodiscard__]]
_GLIBCXX17_CONSTEXPR reference
operator[](difference_type __n) const
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
{ return ranges::iter_move(_M_current + __n); }
#else
{ return std::move(_M_current[__n]); }
#endif
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
template<sentinel_for<_Iterator> _Sent>
[[nodiscard]]
friend constexpr bool
inline _GLIBCXX17_CONSTEXPR bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
#endif
{ return __x.base() == __y.base(); }
inline _GLIBCXX17_CONSTEXPR bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
#endif
{ return __x.base() < __y.base(); }
inline _GLIBCXX17_CONSTEXPR bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
#endif
{ return !(__y < __x); }
inline _GLIBCXX17_CONSTEXPR bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
#endif
{ return __y < __x; }
inline _GLIBCXX17_CONSTEXPR bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
#endif
{ return !(__x < __y); }
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); }
-#if __cplusplus > 201703L && __cpp_lib_concepts
+#if __cplusplus > 201703L && __glibcxx_concepts
// [iterators.common] Common iterators
namespace __detail
#include <ext/aligned_buffer.h>
#endif
-#define __glibcxx_want_list_remove_return_type
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
private:
-#ifdef __cpp_lib_list_remove_return_type // C++ >= 20 && HOSTED
+#ifdef __glibcxx_list_remove_return_type // C++ >= 20 && HOSTED
typedef size_type __remove_return_type;
# define _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG \
__attribute__((__abi_tag__("__cxx20")))
#include <tuple>
#endif
-#define __glibcxx_want_map_try_emplace
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
{ merge(__source); }
#endif // C++17
-#ifdef __cpp_lib_map_try_emplace // C++ >= 17 && HOSTED
+#ifdef __glibcxx_map_try_emplace // C++ >= 17 && HOSTED
/**
* @brief Attempts to build and insert a std::pair into the %map.
*
# include <compare>
#endif
-#define __glibcxx_want_constexpr_utility
-#define __glibcxx_want_tuples_by_type
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return __pair_get<_Int>::__const_move_get(std::move(__in)); }
-#ifdef __cpp_lib_tuples_by_type // C++ >= 14
+#ifdef __glibcxx_tuples_by_type // C++ >= 14
template <typename _Tp, typename _Up>
constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
constexpr const _Tp&&
get(const pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }
-#endif // __cpp_lib_tuples_by_type
+#endif // __glibcxx_tuples_by_type
#if __cplusplus > 202002L
# include <bits/uses_allocator.h>
#endif
-#define __glibcxx_want_adaptor_iterator_pair_constructor
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
: c(std::move(__q.c), __a) { }
#endif
-#ifdef __cpp_lib_adaptor_iterator_pair_constructor // C++ >= 23 && HOSTED
+#ifdef __glibcxx_adaptor_iterator_pair_constructor // C++ >= 23 && HOSTED
template<typename _InputIterator,
typename = _RequireInputIter<_InputIterator>>
queue(_InputIterator __first, _InputIterator __last)
queue(_Container, _Allocator)
-> queue<typename _Container::value_type, _Container>;
-#ifdef __cpp_lib_adaptor_iterator_pair_constructor
+#ifdef __glibcxx_adaptor_iterator_pair_constructor
template<typename _InputIterator,
typename _ValT
= typename iterator_traits<_InputIterator>::value_type,
# include <bits/uses_allocator.h>
#endif
-#define __glibcxx_want_adaptor_iterator_pair_constructor
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
stack(_Sequence&& __c)
: c(std::move(__c)) { }
-#ifdef __cpp_lib_adaptor_iterator_pair_constructor // C++ >= 23 && HOSTED
+#ifdef __glibcxx_adaptor_iterator_pair_constructor // C++ >= 23 && HOSTED
template<typename _InputIterator,
typename = _RequireInputIter<_InputIterator>>
stack(_InputIterator __first, _InputIterator __last)
stack(_Container, _Allocator)
-> stack<typename _Container::value_type, _Container>;
-#ifdef __cpp_lib_adaptor_iterator_pair_constructor
+#ifdef __glibcxx_adaptor_iterator_pair_constructor
template<typename _InputIterator,
typename _ValT
= typename iterator_traits<_InputIterator>::value_type,
# include <bits/node_handle.h>
#endif
-#define __glibcxx_want_generic_associative_lookup
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
#include <bits/stl_pair.h>
#endif
-#define __glibcxx_want_raw_memory_algorithms
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @endcond
#endif
-#ifdef __cpp_lib_raw_memory_algorithms // C++ >= 17
+#ifdef __glibcxx_raw_memory_algorithms // C++ >= 17
/**
* @brief Default-initializes objects in the range [first,last).
* @param __first A forward iterator.
__count, __result);
return {__res.first.base(), __res.second};
}
-#endif // __cpp_lib_raw_memory_algorithms
+#endif // __glibcxx_raw_memory_algorithms
#if __cplusplus >= 201103L
/// @cond undocumented
# include <compare>
#endif
-#define __glibcxx_want_constexpr_vector
-#include <bits/version.h>
-
#include <debug/assertions.h>
#if _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR
# endif
#endif
-#define __glibcxx_want_constexpr_memory
-#define __glibcxx_want_make_unique
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
{ };
-#ifdef __cpp_lib_make_unique // C++ >= 14 && HOSTED
+#ifdef __glibcxx_make_unique // C++ >= 14 && HOSTED
/// @cond undocumented
namespace __detail
{
#include <bits/functional_hash.h> // hash
#include <bits/stl_function.h> // equal_to
-#define __glibcxx_want_unordered_map_try_emplace
-#include <bits/version.h>
-
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return _M_h._M_reinsert_node(std::move(__nh)).position; }
#endif // C++17
-#ifdef __cpp_lib_unordered_map_try_emplace // C++ >= 17 && HOSTED
+#ifdef __glibcxx_unordered_map_try_emplace // C++ >= 17 && HOSTED
/**
* @brief Attempts to build and insert a std::pair into the
* %unordered_map.
return _M_h.try_emplace(__hint, std::move(__k),
std::forward<_Args>(__args)...).first;
}
-#endif // __cpp_lib_unordered_map_try_emplace
+#endif // __glibcxx_unordered_map_try_emplace
///@{
/**
#pragma GCC system_header
-#define __glibcxx_want_make_obj_using_allocator
#include <bits/version.h>
-#ifdef __cpp_lib_make_obj_using_allocator // C++ >= 20 && concepts
+#ifdef __glibcxx_make_obj_using_allocator // C++ >= 20 && concepts
#include <new> // for placement operator new
#include <tuple> // for tuple, make_tuple, make_from_tuple
#include <bits/stl_construct.h> // construct_at
/// @}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif // __cpp_lib_make_obj_using_allocator
+#endif // __glibcxx_make_obj_using_allocator
#endif // _USES_ALLOCATOR_ARGS
#pragma GCC system_header
-#define __glibcxx_want_tuple_element_t
-#define __glibcxx_want_integer_sequence
-#define __glibcxx_want_ranges_zip
-#include <bits/version.h>
-
#if __cplusplus >= 201103L
#include <type_traits>
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3378. tuple_size_v/tuple_element_t should be available when
// tuple_size/tuple_element are
-#ifdef __cpp_lib_tuple_element_t // C++ >= 14
+#ifdef __glibcxx_tuple_element_t // C++ >= 14
template<size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;
#endif
#endif
};
-#ifdef __cpp_lib_integer_sequence // C++ >= 14
+#ifdef __glibcxx_integer_sequence // C++ >= 14
/// Class template integer_sequence
template<typename _Tp, _Tp... _Idx>
/// Alias template index_sequence_for
template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
-#endif // __cpp_lib_integer_sequence
+#endif // __glibcxx_integer_sequence
#if __cplusplus >= 201703L
# include <bits/ranges_algo.h>
#endif
+#define __glibcxx_want_clamp
+#define __glibcxx_want_constexpr_algorithms
#define __glibcxx_want_parallel_algorithm
+#define __glibcxx_want_ranges_contains
+#define __glibcxx_want_ranges_find_last
+#define __glibcxx_want_ranges_fold
+#define __glibcxx_want_robust_nonmodifying_seq_ops
+#define __glibcxx_want_sample
+#define __glibcxx_want_shift
#include <bits/version.h>
#if __cpp_lib_parallel_algorithm // C++ >= 17 && HOSTED
#include <bits/utility.h> // std::index_sequence, std::tuple_size
#include <debug/assertions.h>
+#define __glibcxx_want_array_constexpr
+#define __glibcxx_want_nonmember_container_access
#define __glibcxx_want_to_array
#include <bits/version.h>
#else
#define __glibcxx_want_atomic_is_always_lock_free
+#define __glibcxx_want_atomic_flag_test
#define __glibcxx_want_atomic_float
#define __glibcxx_want_atomic_ref
#define __glibcxx_want_atomic_lock_free_type_aliases
+#define __glibcxx_want_atomic_value_initialization
+#define __glibcxx_want_atomic_wait
#include <bits/version.h>
#include <bits/atomic_base.h>
# include <bits/unique_ptr.h>
#endif
+#define __glibcxx_want_chrono
+#define __glibcxx_want_chrono_udls
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p)
{ return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); }
-#ifdef __cpp_lib_jthread
+#ifdef __glibcxx_jthread
template <class _Lock, class _Predicate>
bool wait(_Lock& __lock,
stop_token __stoken,
#include <bits/deque.tcc>
#define __glibcxx_want_erase_if
+#define __glibcxx_want_nonmember_container_access
#include <bits/version.h>
#ifdef _GLIBCXX_DEBUG
#include <bits/requires_hosted.h> // for std::string
#define __glibcxx_want_format
+#define __glibcxx_want_format_ranges
#include <bits/version.h>
#ifdef __cpp_lib_format // C++ >= 20 && HOSTED
};
#endif
-#if defined __cpp_lib_to_chars
+#if defined __glibcxx_to_chars
/// Format a floating-point value.
template<__format::__formattable_float _Tp, __format::__char _CharT>
struct formatter<_Tp, _CharT>
return std::forward<_Visitor>(__vis)(_M_val._M_ll);
case _Arg_ull:
return std::forward<_Visitor>(__vis)(_M_val._M_ull);
-#if __cpp_lib_to_chars // FIXME: need to be able to format these types!
+#if __glibcxx_to_chars // FIXME: need to be able to format these types!
case _Arg_flt:
return std::forward<_Visitor>(__vis)(_M_val._M_flt);
case _Arg_dbl:
#endif
#define __glibcxx_want_erase_if
+#define __glibcxx_want_incomplete_container_elements
+#define __glibcxx_want_list_remove_return_type
+#define __glibcxx_want_nonmember_container_access
#include <bits/version.h>
#if __cplusplus >= 201703L
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Alloc, typename _Predicate>
- inline typename forward_list<_Tp, _Alloc>::size_type
+ inline typename forward_list<_Tp, _Alloc>::size_type
erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred)
{ return __cont.remove_if(__pred); }
#include <bits/c++config.h>
#include <bits/stl_function.h> // std::equal_to, std::unary_function etc.
-#define __glibcxx_want_invoke
-#define __glibcxx_want_constexpr_functional
-#define __glibcxx_want_invoke_r
-#define __glibcxx_want_bind_front
-#define __glibcxx_want_not_fn
-#define __glibcxx_want_boyer_moore_searcher
-#include <bits/version.h>
-
#if __cplusplus >= 201103L
#include <tuple>
# include <bits/move_only_function.h>
#endif
+#define __glibcxx_want_boyer_moore_searcher
+#define __glibcxx_want_bind_front
+#define __glibcxx_want_constexpr_functional
+#define __glibcxx_want_invoke
+#define __glibcxx_want_invoke_r
+#define __glibcxx_want_move_only_function
+#define __glibcxx_want_not_fn
+#define __glibcxx_want_ranges
+#define __glibcxx_want_transparent_operators
+#include <bits/version.h>
+
#endif // C++11
namespace std _GLIBCXX_VISIBILITY(default)
#include <streambuf>
#include <bits/basic_ios.h>
+#define __glibcxx_want_ios_noreplace
+#include <bits/version.h>
+
#endif /* _GLIBCXX_IOS */
#endif
#include <bits/range_access.h>
+#define __glibcxx_want_array_constexpr
+#define __glibcxx_want_constexpr_iterator
+#define __glibcxx_want_make_reverse_iterator
+#define __glibcxx_want_move_iterator_concept
+#define __glibcxx_want_nonmember_container_access
#define __glibcxx_want_null_iterators
+#define __glibcxx_want_ranges
+#define __glibcxx_want_ssize
#include <bits/version.h>
#if __cplusplus >= 202002L
#endif
#define __glibcxx_want_erase_if
+#define __glibcxx_want_incomplete_container_elements
+#define __glibcxx_want_list_remove_return_type
+#define __glibcxx_want_nonmember_container_access
#include <bits/version.h>
#if __cplusplus >= 201703L
# include <debug/map>
#endif
+#define __glibcxx_want_erase_if
+#define __glibcxx_want_generic_associative_lookup
+#define __glibcxx_want_map_try_emplace
+#define __glibcxx_want_node_extract
+#define __glibcxx_want_nonmember_container_access
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
# include <bits/uses_allocator_args.h>
#endif
+#define __glibcxx_want_allocator_traits_is_always_equal
+#define __glibcxx_want_assume_aligned
+#define __glibcxx_want_atomic_shared_ptr
#define __glibcxx_want_atomic_value_initialization
+#define __glibcxx_want_constexpr_dynamic_alloc
+#define __glibcxx_want_constexpr_memory
+#define __glibcxx_want_enable_shared_from_this
+#define __glibcxx_want_make_unique
#define __glibcxx_want_parallel_algorithm
+#define __glibcxx_want_ranges
+#define __glibcxx_want_raw_memory_algorithms
+#define __glibcxx_want_shared_ptr_arrays
+#define __glibcxx_want_shared_ptr_weak_type
+#define __glibcxx_want_smart_ptr_for_overwrite
+#define __glibcxx_want_to_address
+#define __glibcxx_want_transparent_operators
#include <bits/version.h>
#if __cplusplus >= 201103L && __cplusplus <= 202002L && _GLIBCXX_HOSTED
#define __glibcxx_want_interpolate
#define __glibcxx_want_lcm
#define __glibcxx_want_parallel_algorithm
+#define __glibcxx_want_ranges_iota
#include <bits/version.h>
/**
#include <bits/stl_function.h>
#include <bits/stl_queue.h>
+#define __glibcxx_want_adaptor_iterator_pair_constructor
+#include <bits/version.h>
+
#endif /* _GLIBCXX_QUEUE */
#include <bits/ranges_util.h>
#include <bits/refwrap.h>
+#define __glibcxx_want_ranges
#define __glibcxx_want_ranges_as_const
#define __glibcxx_want_ranges_as_rvalue
#define __glibcxx_want_ranges_cartesian_product
#include <bits/regex.h>
#include <bits/regex_executor.h>
+#define __glibcxx_want_nonmember_container_access
+#include <bits/version.h>
+
#if __cplusplus >= 201703L && _GLIBCXX_USE_CXX11_ABI
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
using __outermost_alloc_traits
= allocator_traits<typename __outermost_type<_Alloc>::type>;
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
template<typename _Tp, typename... _Args>
void
_M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args)
size_type max_size() const
{ return __traits::max_size(outer_allocator()); }
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
template<typename _Tp, typename... _Args>
typename __not_pair<_Tp>::type
construct(_Tp* __p, _Args&&... __args)
const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept;
private:
-#if ! __cpp_lib_make_obj_using_allocator
+#if ! __glibcxx_make_obj_using_allocator
template<typename _Ind, typename... _Args>
tuple<_Args&&...>
_M_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t)
# include <debug/set>
#endif
+#define __glibcxx_want_erase_if
+#define __glibcxx_want_generic_associative_lookup
+#define __glibcxx_want_node_extract
+#define __glibcxx_want_nonmember_container_access
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
#include <deque>
#include <bits/stl_stack.h>
+#define __glibcxx_want_adaptor_iterator_pair_constructor
+#include <bits/version.h>
+
#endif /* _GLIBCXX_STACK */
this_thread::yield();
}
-#ifndef __cpp_lib_semaphore
+#ifndef __glibcxx_semaphore
struct binary_semaphore
{
explicit binary_semaphore(int __d) : _M_counter(__d > 0) { }
#include <bits/basic_string.h>
#include <bits/basic_string.tcc>
+#define __glibcxx_want_constexpr_char_traits
+#define __glibcxx_want_constexpr_string
#define __glibcxx_want_erase_if
+#define __glibcxx_want_nonmember_container_access
+#define __glibcxx_want_string_resize_and_overwrite
+#define __glibcxx_want_string_udls
+#define __glibcxx_want_to_string
#include <bits/version.h>
#if __cplusplus >= 201703L && _GLIBCXX_USE_CXX11_ABI
#pragma GCC system_header
+#define __glibcxx_want_constexpr_char_traits
#define __glibcxx_want_string_view
#define __glibcxx_want_constexpr_string_view
#define __glibcxx_want_starts_ends_with
#endif
#define __glibcxx_want_constexpr_tuple
+#define __glibcxx_want_tuple_element_t
#define __glibcxx_want_tuples_by_type
#define __glibcxx_want_apply
#define __glibcxx_want_make_from_tuple
+#define __glibcxx_want_ranges_zip
#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
# include <debug/unordered_map>
#endif
+#define __glibcxx_want_erase_if
+#define __glibcxx_want_generic_unordered_lookup
+#define __glibcxx_want_node_extract
+#define __glibcxx_want_nonmember_container_access
+#define __glibcxx_want_unordered_map_try_emplace
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
# include <debug/unordered_set>
#endif
+#define __glibcxx_want_erase_if
+#define __glibcxx_want_generic_unordered_lookup
+#define __glibcxx_want_node_extract
+#define __glibcxx_want_nonmember_container_access
+#include <bits/version.h>
+
#if __cplusplus >= 201703L
#include <bits/memory_resource.h>
namespace std _GLIBCXX_VISIBILITY(default)
#include <bits/stl_relops.h>
#include <bits/stl_pair.h>
-#define __glibcxx_want_as_const
-#define __glibcxx_want_constexpr_algorithms
-#define __glibcxx_want_exchange_function
-#define __glibcxx_want_forward_like
-#define __glibcxx_want_integer_comparison_functions
-#define __glibcxx_want_to_underlying
-#define __glibcxx_want_unreachable
-#include <bits/version.h>
-
#if __cplusplus >= 201103L
#include <initializer_list>
#include <ext/numeric_traits.h> // __is_standard_integer, __int_traits
#endif
+#define __glibcxx_want_addressof_constexpr
+#define __glibcxx_want_as_const
+#define __glibcxx_want_constexpr_algorithms
+#define __glibcxx_want_constexpr_utility
+#define __glibcxx_want_exchange_function
+#define __glibcxx_want_forward_like
+#define __glibcxx_want_integer_comparison_functions
+#define __glibcxx_want_integer_sequence
+#define __glibcxx_want_ranges_zip
+#define __glibcxx_want_to_underlying
+#define __glibcxx_want_tuple_element_t
+#define __glibcxx_want_tuples_by_type
+#define __glibcxx_want_unreachable
+#include <bits/version.h>
+
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
# include <debug/vector>
#endif
+#define __glibcxx_want_constexpr_vector
#define __glibcxx_want_erase_if
+#define __glibcxx_want_incomplete_container_elements
+#define __glibcxx_want_nonmember_container_access
#include <bits/version.h>
#if __cplusplus >= 201703L
projects / thirdparty / gcc.git / commitdiff
