// -*- C++ -*- //===----------------------------------------------------------------------===// // // 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 // //===----------------------------------------------------------------------===// #ifndef _LIBCPP_DEQUE #define _LIBCPP_DEQUE /* deque synopsis namespace std { template <class T, class Allocator = allocator<T> > class deque { public: // types: typedef T value_type; typedef Allocator allocator_type; typedef typename allocator_type::reference reference; typedef typename allocator_type::const_reference const_reference; typedef implementation-defined iterator; typedef implementation-defined const_iterator; typedef typename allocator_type::size_type size_type; typedef typename allocator_type::difference_type difference_type; typedef typename allocator_type::pointer pointer; typedef typename allocator_type::const_pointer const_pointer; typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // construct/copy/destroy: deque() noexcept(is_nothrow_default_constructible<allocator_type>::value); explicit deque(const allocator_type& a); explicit deque(size_type n); explicit deque(size_type n, const allocator_type& a); // C++14 deque(size_type n, const value_type& v); deque(size_type n, const value_type& v, const allocator_type& a); template <class InputIterator> deque(InputIterator f, InputIterator l); template <class InputIterator> deque(InputIterator f, InputIterator l, const allocator_type& a); template<container-compatible-range<T> R> deque(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23 deque(const deque& c); deque(deque&& c) noexcept(is_nothrow_move_constructible<allocator_type>::value); deque(initializer_list<value_type> il, const Allocator& a = allocator_type()); deque(const deque& c, const allocator_type& a); deque(deque&& c, const allocator_type& a); ~deque(); deque& operator=(const deque& c); deque& operator=(deque&& c) noexcept( allocator_type::propagate_on_container_move_assignment::value && is_nothrow_move_assignable<allocator_type>::value); deque& operator=(initializer_list<value_type> il); template <class InputIterator> void assign(InputIterator f, InputIterator l); template<container-compatible-range<T> R> void assign_range(R&& rg); // C++23 void assign(size_type n, const value_type& v); void assign(initializer_list<value_type> il); allocator_type get_allocator() const noexcept; // iterators: iterator begin() noexcept; const_iterator begin() const noexcept; iterator end() noexcept; const_iterator end() const noexcept; reverse_iterator rbegin() noexcept; const_reverse_iterator rbegin() const noexcept; reverse_iterator rend() noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; // capacity: size_type size() const noexcept; size_type max_size() const noexcept; void resize(size_type n); void resize(size_type n, const value_type& v); void shrink_to_fit(); bool empty() const noexcept; // element access: reference operator[](size_type i); const_reference operator[](size_type i) const; reference at(size_type i); const_reference at(size_type i) const; reference front(); const_reference front() const; reference back(); const_reference back() const; // modifiers: void push_front(const value_type& v); void push_front(value_type&& v); template<container-compatible-range<T> R> void prepend_range(R&& rg); // C++23 void push_back(const value_type& v); void push_back(value_type&& v); template<container-compatible-range<T> R> void append_range(R&& rg); // C++23 template <class... Args> reference emplace_front(Args&&... args); // reference in C++17 template <class... Args> reference emplace_back(Args&&... args); // reference in C++17 template <class... Args> iterator emplace(const_iterator p, Args&&... args); iterator insert(const_iterator p, const value_type& v); iterator insert(const_iterator p, value_type&& v); iterator insert(const_iterator p, size_type n, const value_type& v); template <class InputIterator> iterator insert(const_iterator p, InputIterator f, InputIterator l); template<container-compatible-range<T> R> iterator insert_range(const_iterator position, R&& rg); // C++23 iterator insert(const_iterator p, initializer_list<value_type> il); void pop_front(); void pop_back(); iterator erase(const_iterator p); iterator erase(const_iterator f, const_iterator l); void swap(deque& c) noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17 void clear() noexcept; }; template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> deque(InputIterator, InputIterator, Allocator = Allocator()) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17 template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>> deque(from_range_t, R&&, Allocator = Allocator()) -> deque<ranges::range_value_t<R>, Allocator>; // C++23 template <class T, class Allocator> bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y); template <class T, class Allocator> bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20 template <class T, class Allocator> bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20 template <class T, class Allocator> bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20 template <class T, class Allocator> bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20 template <class T, class Allocator> bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); // removed in C++20 template<class T, class Allocator> synth-three-way-result<T> operator<=>(const deque<T, Allocator>& x, const deque<T, Allocator>& y); // since C++20 // specialized algorithms: template <class T, class Allocator> void swap(deque<T,Allocator>& x, deque<T,Allocator>& y) noexcept(noexcept(x.swap(y))); template <class T, class Allocator, class U> typename deque<T, Allocator>::size_type erase(deque<T, Allocator>& c, const U& value); // C++20 template <class T, class Allocator, class Predicate> typename deque<T, Allocator>::size_type erase_if(deque<T, Allocator>& c, Predicate pred); // C++20 } // std */ #include <__algorithm/copy.h> #include <__algorithm/copy_backward.h> #include <__algorithm/copy_n.h> #include <__algorithm/equal.h> #include <__algorithm/fill_n.h> #include <__algorithm/lexicographical_compare.h> #include <__algorithm/lexicographical_compare_three_way.h> #include <__algorithm/min.h> #include <__algorithm/remove.h> #include <__algorithm/remove_if.h> #include <__algorithm/unwrap_iter.h> #include <__assert> #include <__config> #include <__debug_utils/sanitizers.h> #include <__format/enable_insertable.h> #include <__fwd/deque.h> #include <__iterator/distance.h> #include <__iterator/iterator_traits.h> #include <__iterator/next.h> #include <__iterator/prev.h> #include <__iterator/reverse_iterator.h> #include <__iterator/segmented_iterator.h> #include <__memory/addressof.h> #include <__memory/allocator_destructor.h> #include <__memory/pointer_traits.h> #include <__memory/temp_value.h> #include <__memory/unique_ptr.h> #include <__memory_resource/polymorphic_allocator.h> #include <__ranges/access.h> #include <__ranges/concepts.h> #include <__ranges/container_compatible_range.h> #include <__ranges/from_range.h> #include <__ranges/size.h> #include <__split_buffer> #include <__type_traits/is_allocator.h> #include <__type_traits/is_convertible.h> #include <__type_traits/is_same.h> #include <__type_traits/is_swappable.h> #include <__type_traits/type_identity.h> #include <__utility/forward.h> #include <__utility/move.h> #include <__utility/pair.h> #include <__utility/swap.h> #include <limits> #include <stdexcept> #include <version> // standard-mandated includes // [iterator.range] #include <__iterator/access.h> #include <__iterator/data.h> #include <__iterator/empty.h> #include <__iterator/reverse_access.h> #include <__iterator/size.h> // [deque.syn] #include <compare> #include <initializer_list> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> _LIBCPP_BEGIN_NAMESPACE_STD template <class _ValueType, class _DiffType> struct __deque_block_size { … }; template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BS = #ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE // Keep template parameter to avoid changing all template declarations thoughout // this file. 0 #else __deque_block_size<_ValueType, _DiffType>::value #endif > class _LIBCPP_TEMPLATE_VIS __deque_iterator { … }; __segmented_iterator_traits<__deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>>; template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize> const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>::__block_size = …; template <class _Tp, class _Allocator /*= allocator<_Tp>*/> class _LIBCPP_TEMPLATE_VIS deque { … }; template <class _Tp, class _Alloc> _LIBCPP_CONSTEXPR const typename allocator_traits<_Alloc>::difference_type deque<_Tp, _Alloc>::__block_size = …; #if _LIBCPP_STD_VER >= 17 template <class _InputIterator, class _Alloc = allocator<__iter_value_type<_InputIterator>>, class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>, class = enable_if_t<__is_allocator<_Alloc>::value> > deque(_InputIterator, _InputIterator) -> deque<__iter_value_type<_InputIterator>, _Alloc>; template <class _InputIterator, class _Alloc, class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>, class = enable_if_t<__is_allocator<_Alloc>::value> > deque(_InputIterator, _InputIterator, _Alloc) -> deque<__iter_value_type<_InputIterator>, _Alloc>; #endif #if _LIBCPP_STD_VER >= 23 template <ranges::input_range _Range, class _Alloc = allocator<ranges::range_value_t<_Range>>, class = enable_if_t<__is_allocator<_Alloc>::value> > deque(from_range_t, _Range&&, _Alloc = _Alloc()) -> deque<ranges::range_value_t<_Range>, _Alloc>; #endif template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(size_type __n) : … { … } #if _LIBCPP_STD_VER >= 14 template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a) : … { … } #endif template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v) : … { … } template <class _Tp, class _Allocator> template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> > deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l) : __start_(0), __size_(0, __default_init_tag()) { … } template <class _Tp, class _Allocator> template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> > deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a) : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) { … } template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(const deque& __c) : … { … } template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(const deque& __c, const __type_identity_t<allocator_type>& __a) : … { … } template <class _Tp, class _Allocator> deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(const deque& __c) { … } #ifndef _LIBCPP_CXX03_LANG template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il) : … { … } template <class _Tp, class _Allocator> deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a) : … { … } template <class _Tp, class _Allocator> inline deque<_Tp, _Allocator>::deque(deque&& __c) noexcept(is_nothrow_move_constructible<allocator_type>::value) : … { … } template <class _Tp, class _Allocator> inline deque<_Tp, _Allocator>::deque(deque&& __c, const __type_identity_t<allocator_type>& __a) : … { … } template <class _Tp, class _Allocator> inline deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(deque&& __c) noexcept( __alloc_traits::propagate_on_container_move_assignment::value && is_nothrow_move_assignable<allocator_type>::value) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type) noexcept(is_nothrow_move_assignable<allocator_type>::value) { … } #endif // _LIBCPP_CXX03_LANG template <class _Tp, class _Allocator> template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value && !__has_random_access_iterator_category<_InputIter>::value, int> > void deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l) { … } template <class _Tp, class _Allocator> template <class _Iterator, class _Sentinel> _LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) { … } template <class _Tp, class _Allocator> template <class _RAIter, __enable_if_t<__has_random_access_iterator_category<_RAIter>::value, int> > void deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l) { … } template <class _Tp, class _Allocator> template <class _RandomAccessIterator> _LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n) { … } template <class _Tp, class _Allocator> template <class _Iterator> _LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v) { … } template <class _Tp, class _Allocator> inline _Allocator deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::resize(size_type __n) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::operator[](size_type __i) _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::operator[](size_type __i) const _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::at(size_type __i) { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::at(size_type __i) const { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::front() _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::front() const _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::back() _NOEXCEPT { … } template <class _Tp, class _Allocator> inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::back() const _NOEXCEPT { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::push_back(const value_type& __v) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::push_front(const value_type& __v) { … } #ifndef _LIBCPP_CXX03_LANG template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::push_back(value_type&& __v) { … } template <class _Tp, class _Allocator> template <class... _Args> # if _LIBCPP_STD_VER >= 17 typename deque<_Tp, _Allocator>::reference # else void # endif deque<_Tp, _Allocator>::emplace_back(_Args&&... __args) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::push_front(value_type&& __v) { … } template <class _Tp, class _Allocator> template <class... _Args> # if _LIBCPP_STD_VER >= 17 typename deque<_Tp, _Allocator>::reference # else void # endif deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) { … } template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v) { … } template <class _Tp, class _Allocator> template <class... _Args> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args) { … } #endif // _LIBCPP_CXX03_LANG template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v) { … } template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v) { … } template <class _Tp, class _Allocator> template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> > typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l) { … } template <class _Tp, class _Allocator> template <class _Iterator, class _Sentinel> _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) { … } template <class _Tp, class _Allocator> template <class _ForwardIterator, __enable_if_t<__has_exactly_forward_iterator_category<_ForwardIterator>::value, int> > typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l) { … } template <class _Tp, class _Allocator> template <class _Iterator> _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) { … } template <class _Tp, class _Allocator> template <class _BiIter, __enable_if_t<__has_bidirectional_iterator_category<_BiIter>::value, int> > typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l) { … } template <class _Tp, class _Allocator> template <class _BiIter, class _Sentinel> _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel, size_type __n) { … } template <class _Tp, class _Allocator> template <class _BiIter> _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n) { … } template <class _Tp, class _Allocator> template <class _InpIter, __enable_if_t<__has_exactly_input_iterator_category<_InpIter>::value, int> > void deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l) { … } template <class _Tp, class _Allocator> template <class _InputIterator, class _Sentinel> _LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__append_with_sentinel(_InputIterator __f, _Sentinel __l) { … } template <class _Tp, class _Allocator> template <class _ForIter, __enable_if_t<__has_forward_iterator_category<_ForIter>::value, int> > void deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l) { … } template <class _Tp, class _Allocator> template <class _InputIterator> _LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__append(size_type __n) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v) { … } // Create front capacity for one block of elements. // Strong guarantee. Either do it or don't touch anything. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__add_front_capacity() { … } // Create front capacity for __n elements. // Strong guarantee. Either do it or don't touch anything. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__add_front_capacity(size_type __n) { … } // Create back capacity for one block of elements. // Strong guarantee. Either do it or don't touch anything. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__add_back_capacity() { … } // Create back capacity for __n elements. // Strong guarantee. Either do it or don't touch anything. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__add_back_capacity(size_type __n) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::pop_front() { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::pop_back() { … } // move assign [__f, __l) to [__r, __r + (__l-__f)). // If __vt points into [__f, __l), then subtract (__f - __r) from __vt. template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) { … } // move assign [__f, __l) to [__r - (__l-__f), __r) backwards. // If __vt points into [__f, __l), then add (__r - __l) to __vt. template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) { … } // move construct [__f, __l) to [__r, __r + (__l-__f)). // If __vt points into [__f, __l), then add (__r - __f) to __vt. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) { … } // move construct [__f, __l) to [__r - (__l-__f), __r) backwards. // If __vt points into [__f, __l), then subtract (__l - __r) from __vt. template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__move_construct_backward_and_check( iterator __f, iterator __l, iterator __r, const_pointer& __vt) { … } template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f) { … } template <class _Tp, class _Allocator> typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l) { … } template <class _Tp, class _Allocator> void deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f) { … } template <class _Tp, class _Allocator> inline void deque<_Tp, _Allocator>::swap(deque& __c) #if _LIBCPP_STD_VER >= 14 _NOEXCEPT #else _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>) #endif { … } template <class _Tp, class _Allocator> inline void deque<_Tp, _Allocator>::clear() _NOEXCEPT { … } template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { … } #if _LIBCPP_STD_VER <= 17 template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { return !(__x == __y); } template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator<(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { return __y < __x; } template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { return !(__x < __y); } template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { return !(__y < __x); } #else // _LIBCPP_STD_VER <= 17 template <class _Tp, class _Allocator> _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp> operator<=>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { … } #endif // _LIBCPP_STD_VER <= 17 template <class _Tp, class _Allocator> inline _LIBCPP_HIDE_FROM_ABI void swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) { … } #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Allocator, class _Up> inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type erase(deque<_Tp, _Allocator>& __c, const _Up& __v) { … } template <class _Tp, class _Allocator, class _Predicate> inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) { … } __enable_insertable; # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS __enable_insertable; # endif #endif // _LIBCPP_STD_VER >= 20 _LIBCPP_END_NAMESPACE_STD #if _LIBCPP_STD_VER >= 17 _LIBCPP_BEGIN_NAMESPACE_STD namespace pmr { deque; } // namespace pmr _LIBCPP_END_NAMESPACE_STD #endif _LIBCPP_POP_MACROS #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 # include <algorithm> # include <atomic> # include <concepts> # include <cstdlib> # include <functional> # include <iosfwd> # include <iterator> # include <type_traits> # include <typeinfo> #endif #endif // _LIBCPP_DEQUE
Codebase Browser
chromium