1e564246ec
The patch touches these files: locale array deque new string utility vector __bit_reference __split_buffer locale_win32.h There is no intended functionality change and it is expected that reversing the position of the inline keyword with regard to the other keywords does not change the meaning of anything, least not for apple/Linux etc. It is intended to make libcxx more consistent with itself and to prevent the 1000 or so "inline.cpp(3) : warning C4141: 'inline' : used more than once" warnings that MS's cl.exe compiler emits without this patch, i.e. if inline is not the first keyword before a function name etc. Prefer "inline [other inline related keyword]" over "[other related keyword] inline". After this patch, libcxx should be consistent to this pattern. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@191987 91177308-0d34-0410-b5e6-96231b3b80d8
3247 lines
104 KiB
C++
3247 lines
104 KiB
C++
// -*- C++ -*-
|
|
//===------------------------------ vector --------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_VECTOR
|
|
#define _LIBCPP_VECTOR
|
|
|
|
/*
|
|
vector synopsis
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <class T, class Allocator = allocator<T> >
|
|
class vector
|
|
{
|
|
public:
|
|
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;
|
|
|
|
vector()
|
|
noexcept(is_nothrow_default_constructible<allocator_type>::value);
|
|
explicit vector(const allocator_type&);
|
|
explicit vector(size_type n);
|
|
explicit vector(size_type n, const allocator_type&); // C++14
|
|
vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
|
|
template <class InputIterator>
|
|
vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
|
|
vector(const vector& x);
|
|
vector(vector&& x)
|
|
noexcept(is_nothrow_move_constructible<allocator_type>::value);
|
|
vector(initializer_list<value_type> il);
|
|
vector(initializer_list<value_type> il, const allocator_type& a);
|
|
~vector();
|
|
vector& operator=(const vector& x);
|
|
vector& operator=(vector&& x)
|
|
noexcept(
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value);
|
|
vector& operator=(initializer_list<value_type> il);
|
|
template <class InputIterator>
|
|
void assign(InputIterator first, InputIterator last);
|
|
void assign(size_type n, const value_type& u);
|
|
void assign(initializer_list<value_type> il);
|
|
|
|
allocator_type get_allocator() const noexcept;
|
|
|
|
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;
|
|
|
|
size_type size() const noexcept;
|
|
size_type max_size() const noexcept;
|
|
size_type capacity() const noexcept;
|
|
bool empty() const noexcept;
|
|
void reserve(size_type n);
|
|
void shrink_to_fit() noexcept;
|
|
|
|
reference operator[](size_type n);
|
|
const_reference operator[](size_type n) const;
|
|
reference at(size_type n);
|
|
const_reference at(size_type n) const;
|
|
|
|
reference front();
|
|
const_reference front() const;
|
|
reference back();
|
|
const_reference back() const;
|
|
|
|
value_type* data() noexcept;
|
|
const value_type* data() const noexcept;
|
|
|
|
void push_back(const value_type& x);
|
|
void push_back(value_type&& x);
|
|
template <class... Args>
|
|
void emplace_back(Args&&... args);
|
|
void pop_back();
|
|
|
|
template <class... Args> iterator emplace(const_iterator position, Args&&... args);
|
|
iterator insert(const_iterator position, const value_type& x);
|
|
iterator insert(const_iterator position, value_type&& x);
|
|
iterator insert(const_iterator position, size_type n, const value_type& x);
|
|
template <class InputIterator>
|
|
iterator insert(const_iterator position, InputIterator first, InputIterator last);
|
|
iterator insert(const_iterator position, initializer_list<value_type> il);
|
|
|
|
iterator erase(const_iterator position);
|
|
iterator erase(const_iterator first, const_iterator last);
|
|
|
|
void clear() noexcept;
|
|
|
|
void resize(size_type sz);
|
|
void resize(size_type sz, const value_type& c);
|
|
|
|
void swap(vector&)
|
|
noexcept(!allocator_type::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value);
|
|
|
|
bool __invariants() const;
|
|
};
|
|
|
|
template <class Allocator = allocator<T> >
|
|
class vector<bool, Allocator>
|
|
{
|
|
public:
|
|
typedef bool value_type;
|
|
typedef Allocator allocator_type;
|
|
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 iterator pointer;
|
|
typedef const_iterator const_pointer;
|
|
typedef std::reverse_iterator<iterator> reverse_iterator;
|
|
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
class reference
|
|
{
|
|
public:
|
|
reference(const reference&) noexcept;
|
|
operator bool() const noexcept;
|
|
reference& operator=(const bool x) noexcept;
|
|
reference& operator=(const reference& x) noexcept;
|
|
iterator operator&() const noexcept;
|
|
void flip() noexcept;
|
|
};
|
|
|
|
class const_reference
|
|
{
|
|
public:
|
|
const_reference(const reference&) noexcept;
|
|
operator bool() const noexcept;
|
|
const_iterator operator&() const noexcept;
|
|
};
|
|
|
|
vector()
|
|
noexcept(is_nothrow_default_constructible<allocator_type>::value);
|
|
explicit vector(const allocator_type&);
|
|
explicit vector(size_type n, const allocator_type& a = allocator_type()); // C++14
|
|
vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
|
|
template <class InputIterator>
|
|
vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
|
|
vector(const vector& x);
|
|
vector(vector&& x)
|
|
noexcept(is_nothrow_move_constructible<allocator_type>::value);
|
|
vector(initializer_list<value_type> il);
|
|
vector(initializer_list<value_type> il, const allocator_type& a);
|
|
~vector();
|
|
vector& operator=(const vector& x);
|
|
vector& operator=(vector&& x)
|
|
noexcept(
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value);
|
|
vector& operator=(initializer_list<value_type> il);
|
|
template <class InputIterator>
|
|
void assign(InputIterator first, InputIterator last);
|
|
void assign(size_type n, const value_type& u);
|
|
void assign(initializer_list<value_type> il);
|
|
|
|
allocator_type get_allocator() const noexcept;
|
|
|
|
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;
|
|
|
|
size_type size() const noexcept;
|
|
size_type max_size() const noexcept;
|
|
size_type capacity() const noexcept;
|
|
bool empty() const noexcept;
|
|
void reserve(size_type n);
|
|
void shrink_to_fit() noexcept;
|
|
|
|
reference operator[](size_type n);
|
|
const_reference operator[](size_type n) const;
|
|
reference at(size_type n);
|
|
const_reference at(size_type n) const;
|
|
|
|
reference front();
|
|
const_reference front() const;
|
|
reference back();
|
|
const_reference back() const;
|
|
|
|
void push_back(const value_type& x);
|
|
template <class... Args> void emplace_back(Args&&... args); // C++14
|
|
void pop_back();
|
|
|
|
template <class... Args> iterator emplace(const_iterator position, Args&&... args); // C++14
|
|
iterator insert(const_iterator position, const value_type& x);
|
|
iterator insert(const_iterator position, size_type n, const value_type& x);
|
|
template <class InputIterator>
|
|
iterator insert(const_iterator position, InputIterator first, InputIterator last);
|
|
iterator insert(const_iterator position, initializer_list<value_type> il);
|
|
|
|
iterator erase(const_iterator position);
|
|
iterator erase(const_iterator first, const_iterator last);
|
|
|
|
void clear() noexcept;
|
|
|
|
void resize(size_type sz);
|
|
void resize(size_type sz, value_type x);
|
|
|
|
void swap(vector&)
|
|
noexcept(!allocator_type::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value);
|
|
void flip() noexcept;
|
|
|
|
bool __invariants() const;
|
|
};
|
|
|
|
template <class Allocator> struct hash<std::vector<bool, Allocator>>;
|
|
|
|
template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
|
|
|
|
template <class T, class Allocator>
|
|
void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
|
|
noexcept(noexcept(x.swap(y)));
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
#include <__config>
|
|
#include <__bit_reference>
|
|
#include <type_traits>
|
|
#include <climits>
|
|
#include <limits>
|
|
#include <initializer_list>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
#include <__split_buffer>
|
|
#include <__functional_base>
|
|
|
|
#include <__undef_min_max>
|
|
|
|
#ifdef _LIBCPP_DEBUG
|
|
# include <__debug>
|
|
#else
|
|
# define _LIBCPP_ASSERT(x, m) ((void)0)
|
|
#endif
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template <bool>
|
|
class __vector_base_common
|
|
{
|
|
protected:
|
|
_LIBCPP_ALWAYS_INLINE __vector_base_common() {}
|
|
void __throw_length_error() const;
|
|
void __throw_out_of_range() const;
|
|
};
|
|
|
|
template <bool __b>
|
|
void
|
|
__vector_base_common<__b>::__throw_length_error() const
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
throw length_error("vector");
|
|
#else
|
|
assert(!"vector length_error");
|
|
#endif
|
|
}
|
|
|
|
template <bool __b>
|
|
void
|
|
__vector_base_common<__b>::__throw_out_of_range() const
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
throw out_of_range("vector");
|
|
#else
|
|
assert(!"vector out_of_range");
|
|
#endif
|
|
}
|
|
|
|
#ifdef _LIBCPP_MSVC
|
|
#pragma warning( push )
|
|
#pragma warning( disable: 4231 )
|
|
#endif // _LIBCPP_MSVC
|
|
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS __vector_base_common<true>)
|
|
#ifdef _LIBCPP_MSVC
|
|
#pragma warning( pop )
|
|
#endif // _LIBCPP_MSVC
|
|
|
|
template <class _Tp, class _Allocator>
|
|
class __vector_base
|
|
: protected __vector_base_common<true>
|
|
{
|
|
protected:
|
|
typedef _Tp value_type;
|
|
typedef _Allocator allocator_type;
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
|
typedef value_type& reference;
|
|
typedef const value_type& const_reference;
|
|
typedef typename __alloc_traits::size_type size_type;
|
|
typedef typename __alloc_traits::difference_type difference_type;
|
|
typedef typename __alloc_traits::pointer pointer;
|
|
typedef typename __alloc_traits::const_pointer const_pointer;
|
|
typedef pointer iterator;
|
|
typedef const_pointer const_iterator;
|
|
|
|
pointer __begin_;
|
|
pointer __end_;
|
|
__compressed_pair<pointer, allocator_type> __end_cap_;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
allocator_type& __alloc() _NOEXCEPT
|
|
{return __end_cap_.second();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const allocator_type& __alloc() const _NOEXCEPT
|
|
{return __end_cap_.second();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
pointer& __end_cap() _NOEXCEPT
|
|
{return __end_cap_.first();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const pointer& __end_cap() const _NOEXCEPT
|
|
{return __end_cap_.first();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__vector_base()
|
|
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
|
|
_LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
|
|
~__vector_base();
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void clear() _NOEXCEPT {__destruct_at_end(__begin_);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type capacity() const _NOEXCEPT
|
|
{return static_cast<size_type>(__end_cap() - __begin_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __destruct_at_end(pointer __new_last) _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const __vector_base& __c)
|
|
{__copy_assign_alloc(__c, integral_constant<bool,
|
|
__alloc_traits::propagate_on_container_copy_assignment::value>());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(__vector_base& __c)
|
|
_NOEXCEPT_(
|
|
!__alloc_traits::propagate_on_container_move_assignment::value ||
|
|
is_nothrow_move_assignable<allocator_type>::value)
|
|
{__move_assign_alloc(__c, integral_constant<bool,
|
|
__alloc_traits::propagate_on_container_move_assignment::value>());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(allocator_type& __x, allocator_type& __y)
|
|
_NOEXCEPT_(
|
|
!__alloc_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value)
|
|
{__swap_alloc(__x, __y, integral_constant<bool,
|
|
__alloc_traits::propagate_on_container_swap::value>());}
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const __vector_base& __c, true_type)
|
|
{
|
|
if (__alloc() != __c.__alloc())
|
|
{
|
|
clear();
|
|
__alloc_traits::deallocate(__alloc(), __begin_, capacity());
|
|
__begin_ = __end_ = __end_cap() = nullptr;
|
|
}
|
|
__alloc() = __c.__alloc();
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const __vector_base&, false_type)
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(__vector_base& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
__alloc() = _VSTD::move(__c.__alloc());
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(__vector_base&, false_type)
|
|
_NOEXCEPT
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
using _VSTD::swap;
|
|
swap(__x, __y);
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(allocator_type&, allocator_type&, false_type)
|
|
_NOEXCEPT
|
|
{}
|
|
};
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
__vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
|
|
{
|
|
while (__new_last != __end_)
|
|
__alloc_traits::destroy(__alloc(), _VSTD::__to_raw_pointer(--__end_));
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
__vector_base<_Tp, _Allocator>::__vector_base()
|
|
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
|
|
: __begin_(nullptr),
|
|
__end_(nullptr),
|
|
__end_cap_(nullptr)
|
|
{
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
__vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__end_(nullptr),
|
|
__end_cap_(nullptr, __a)
|
|
{
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
__vector_base<_Tp, _Allocator>::~__vector_base()
|
|
{
|
|
if (__begin_ != nullptr)
|
|
{
|
|
clear();
|
|
__alloc_traits::deallocate(__alloc(), __begin_, capacity());
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator = allocator<_Tp> >
|
|
class _LIBCPP_TYPE_VIS_ONLY vector
|
|
: private __vector_base<_Tp, _Allocator>
|
|
{
|
|
private:
|
|
typedef __vector_base<_Tp, _Allocator> __base;
|
|
public:
|
|
typedef vector __self;
|
|
typedef _Tp value_type;
|
|
typedef _Allocator allocator_type;
|
|
typedef typename __base::__alloc_traits __alloc_traits;
|
|
typedef typename __base::reference reference;
|
|
typedef typename __base::const_reference const_reference;
|
|
typedef typename __base::size_type size_type;
|
|
typedef typename __base::difference_type difference_type;
|
|
typedef typename __base::pointer pointer;
|
|
typedef typename __base::const_pointer const_pointer;
|
|
typedef __wrap_iter<pointer> iterator;
|
|
typedef __wrap_iter<const_pointer> const_iterator;
|
|
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
|
|
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
static_assert((is_same<typename allocator_type::value_type, value_type>::value),
|
|
"Allocator::value_type must be same type as value_type");
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector()
|
|
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
}
|
|
explicit vector(size_type __n);
|
|
#if _LIBCPP_STD_VER > 11
|
|
explicit vector(size_type __n, const allocator_type& __a);
|
|
#endif
|
|
vector(size_type __n, const_reference __x);
|
|
vector(size_type __n, const_reference __x, const allocator_type& __a);
|
|
template <class _InputIterator>
|
|
vector(_InputIterator __first,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
_InputIterator>::type __last);
|
|
template <class _InputIterator>
|
|
vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
|
|
template <class _ForwardIterator>
|
|
vector(_ForwardIterator __first,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
_ForwardIterator>::type __last);
|
|
template <class _ForwardIterator>
|
|
vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector(initializer_list<value_type> __il);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector(initializer_list<value_type> __il, const allocator_type& __a);
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
~vector()
|
|
{
|
|
__get_db()->__erase_c(this);
|
|
}
|
|
#endif
|
|
|
|
vector(const vector& __x);
|
|
vector(const vector& __x, const allocator_type& __a);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector& operator=(const vector& __x);
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector(vector&& __x)
|
|
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector(vector&& __x, const allocator_type& __a);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector& operator=(vector&& __x)
|
|
_NOEXCEPT_(
|
|
__alloc_traits::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value);
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector& operator=(initializer_list<value_type> __il)
|
|
{assign(__il.begin(), __il.end()); return *this;}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
void
|
|
>::type
|
|
assign(_InputIterator __first, _InputIterator __last);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
void
|
|
>::type
|
|
assign(_ForwardIterator __first, _ForwardIterator __last);
|
|
|
|
void assign(size_type __n, const_reference __u);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void assign(initializer_list<value_type> __il)
|
|
{assign(__il.begin(), __il.end());}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
allocator_type get_allocator() const _NOEXCEPT
|
|
{return this->__alloc();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
reverse_iterator rbegin() _NOEXCEPT
|
|
{return reverse_iterator(end());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator rbegin() const _NOEXCEPT
|
|
{return const_reverse_iterator(end());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
reverse_iterator rend() _NOEXCEPT
|
|
{return reverse_iterator(begin());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator rend() const _NOEXCEPT
|
|
{return const_reverse_iterator(begin());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator cbegin() const _NOEXCEPT
|
|
{return begin();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator cend() const _NOEXCEPT
|
|
{return end();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator crbegin() const _NOEXCEPT
|
|
{return rbegin();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator crend() const _NOEXCEPT
|
|
{return rend();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type size() const _NOEXCEPT
|
|
{return static_cast<size_type>(this->__end_ - this->__begin_);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type capacity() const _NOEXCEPT
|
|
{return __base::capacity();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool empty() const _NOEXCEPT
|
|
{return this->__begin_ == this->__end_;}
|
|
size_type max_size() const _NOEXCEPT;
|
|
void reserve(size_type __n);
|
|
void shrink_to_fit() _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n);
|
|
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const;
|
|
reference at(size_type __n);
|
|
const_reference at(size_type __n) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY reference front()
|
|
{
|
|
_LIBCPP_ASSERT(!empty(), "front() called for empty vector");
|
|
return *this->__begin_;
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY const_reference front() const
|
|
{
|
|
_LIBCPP_ASSERT(!empty(), "front() called for empty vector");
|
|
return *this->__begin_;
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY reference back()
|
|
{
|
|
_LIBCPP_ASSERT(!empty(), "back() called for empty vector");
|
|
return *(this->__end_ - 1);
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY const_reference back() const
|
|
{
|
|
_LIBCPP_ASSERT(!empty(), "back() called for empty vector");
|
|
return *(this->__end_ - 1);
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
value_type* data() _NOEXCEPT
|
|
{return _VSTD::__to_raw_pointer(this->__begin_);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const value_type* data() const _NOEXCEPT
|
|
{return _VSTD::__to_raw_pointer(this->__begin_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
_LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
template <class... _Args>
|
|
void emplace_back(_Args&&... __args);
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
void pop_back();
|
|
|
|
iterator insert(const_iterator __position, const_reference __x);
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
iterator insert(const_iterator __position, value_type&& __x);
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
template <class... _Args>
|
|
iterator emplace(const_iterator __position, _Args&&... __args);
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
iterator insert(const_iterator __position, size_type __n, const_reference __x);
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
iterator
|
|
>::type
|
|
insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
iterator
|
|
>::type
|
|
insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator insert(const_iterator __position, initializer_list<value_type> __il)
|
|
{return insert(__position, __il.begin(), __il.end());}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
_LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
|
|
iterator erase(const_iterator __first, const_iterator __last);
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void clear() _NOEXCEPT
|
|
{
|
|
__base::clear();
|
|
__invalidate_all_iterators();
|
|
}
|
|
|
|
void resize(size_type __sz);
|
|
void resize(size_type __sz, const_reference __x);
|
|
|
|
void swap(vector&)
|
|
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value);
|
|
|
|
bool __invariants() const;
|
|
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
|
|
bool __dereferenceable(const const_iterator* __i) const;
|
|
bool __decrementable(const const_iterator* __i) const;
|
|
bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
|
|
bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
|
|
|
|
#endif // _LIBCPP_DEBUG_LEVEL >= 2
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
|
|
void allocate(size_type __n);
|
|
void deallocate() _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
|
|
void __construct_at_end(size_type __n);
|
|
void __construct_at_end(size_type __n, const_reference __x);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
__construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
|
|
void __move_construct_at_end(pointer __first, pointer __last);
|
|
void __append(size_type __n);
|
|
void __append(size_type __n, const_reference __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator __make_iter(pointer __p) _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator __make_iter(const_pointer __p) const _NOEXCEPT;
|
|
void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
|
|
pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
|
|
void __move_range(pointer __from_s, pointer __from_e, pointer __to);
|
|
void __move_assign(vector& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
|
|
void __move_assign(vector& __c, false_type);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __destruct_at_end(pointer __new_last) _NOEXCEPT
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__c_node* __c = __get_db()->__find_c_and_lock(this);
|
|
for (__i_node** __p = __c->end_; __p != __c->beg_; )
|
|
{
|
|
--__p;
|
|
const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
|
|
if (__i->base() > __new_last)
|
|
{
|
|
(*__p)->__c_ = nullptr;
|
|
if (--__c->end_ != __p)
|
|
memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
|
|
}
|
|
}
|
|
__get_db()->unlock();
|
|
#endif
|
|
__base::__destruct_at_end(__new_last);
|
|
}
|
|
template <class _Up>
|
|
void
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
__push_back_slow_path(_Up&& __x);
|
|
#else
|
|
__push_back_slow_path(_Up& __x);
|
|
#endif
|
|
#if !defined(_LIBCPP_HAS_NO_VARIADICS) && !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
|
|
template <class... _Args>
|
|
void
|
|
__emplace_back_slow_path(_Args&&... __args);
|
|
#endif
|
|
};
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
|
|
{
|
|
__alloc_traits::__construct_backward(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
|
|
_VSTD::swap(this->__begin_, __v.__begin_);
|
|
_VSTD::swap(this->__end_, __v.__end_);
|
|
_VSTD::swap(this->__end_cap(), __v.__end_cap());
|
|
__v.__first_ = __v.__begin_;
|
|
__invalidate_all_iterators();
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::pointer
|
|
vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p)
|
|
{
|
|
pointer __r = __v.__begin_;
|
|
__alloc_traits::__construct_backward(this->__alloc(), this->__begin_, __p, __v.__begin_);
|
|
__alloc_traits::__construct_forward(this->__alloc(), __p, this->__end_, __v.__end_);
|
|
_VSTD::swap(this->__begin_, __v.__begin_);
|
|
_VSTD::swap(this->__end_, __v.__end_);
|
|
_VSTD::swap(this->__end_cap(), __v.__end_cap());
|
|
__v.__first_ = __v.__begin_;
|
|
__invalidate_all_iterators();
|
|
return __r;
|
|
}
|
|
|
|
// Allocate space for __n objects
|
|
// throws length_error if __n > max_size()
|
|
// throws (probably bad_alloc) if memory run out
|
|
// Precondition: __begin_ == __end_ == __end_cap() == 0
|
|
// Precondition: __n > 0
|
|
// Postcondition: capacity() == __n
|
|
// Postcondition: size() == 0
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::allocate(size_type __n)
|
|
{
|
|
if (__n > max_size())
|
|
this->__throw_length_error();
|
|
this->__begin_ = this->__end_ = __alloc_traits::allocate(this->__alloc(), __n);
|
|
this->__end_cap() = this->__begin_ + __n;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::deallocate() _NOEXCEPT
|
|
{
|
|
if (this->__begin_ != nullptr)
|
|
{
|
|
clear();
|
|
__alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
|
|
this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::size_type
|
|
vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
|
|
{
|
|
return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()), numeric_limits<size_type>::max() / 2); // end() >= begin(), always
|
|
}
|
|
|
|
// Precondition: __new_size > capacity()
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::size_type
|
|
vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
|
|
{
|
|
const size_type __ms = max_size();
|
|
if (__new_size > __ms)
|
|
this->__throw_length_error();
|
|
const size_type __cap = capacity();
|
|
if (__cap >= __ms / 2)
|
|
return __ms;
|
|
return _VSTD::max<size_type>(2*__cap, __new_size);
|
|
}
|
|
|
|
// Default constructs __n objects starting at __end_
|
|
// throws if construction throws
|
|
// Precondition: __n > 0
|
|
// Precondition: size() + __n <= capacity()
|
|
// Postcondition: size() == size() + __n
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
do
|
|
{
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
|
|
++this->__end_;
|
|
--__n;
|
|
} while (__n > 0);
|
|
}
|
|
|
|
// Copy constructs __n objects starting at __end_ from __x
|
|
// throws if construction throws
|
|
// Precondition: __n > 0
|
|
// Precondition: size() + __n <= capacity()
|
|
// Postcondition: size() == old size() + __n
|
|
// Postcondition: [i] == __x for all i in [size() - __n, __n)
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
do
|
|
{
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
|
|
++this->__end_;
|
|
--__n;
|
|
} while (__n > 0);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
for (; __first != __last; ++__first)
|
|
{
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
|
|
++this->__end_;
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__move_construct_at_end(pointer __first, pointer __last)
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
for (; __first != __last; ++__first)
|
|
{
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::move(*__first));
|
|
++this->__end_;
|
|
}
|
|
}
|
|
|
|
// Default constructs __n objects starting at __end_
|
|
// throws if construction throws
|
|
// Postcondition: size() == size() + __n
|
|
// Exception safety: strong.
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__append(size_type __n)
|
|
{
|
|
if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
|
|
this->__construct_at_end(__n);
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
|
|
__v.__construct_at_end(__n);
|
|
__swap_out_circular_buffer(__v);
|
|
}
|
|
}
|
|
|
|
// Default constructs __n objects starting at __end_
|
|
// throws if construction throws
|
|
// Postcondition: size() == size() + __n
|
|
// Exception safety: strong.
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x)
|
|
{
|
|
if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
|
|
this->__construct_at_end(__n, __x);
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
|
|
__v.__construct_at_end(__n, __x);
|
|
__swap_out_circular_buffer(__v);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(size_type __n)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n);
|
|
}
|
|
}
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, __x);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x, const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, __x);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _InputIterator>
|
|
vector<_Tp, _Allocator>::vector(_InputIterator __first,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
_InputIterator>::type __last)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _InputIterator>
|
|
vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_InputIterator>::reference>::value>::type*)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _ForwardIterator>
|
|
vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
_ForwardIterator>::type __last)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _ForwardIterator>
|
|
vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
value_type,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(const vector& __x)
|
|
: __base(__alloc_traits::select_on_container_copy_construction(__x.__alloc()))
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
size_type __n = __x.size();
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__x.__begin_, __x.__end_);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
size_type __n = __x.size();
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__x.__begin_, __x.__end_);
|
|
}
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>::vector(vector&& __x)
|
|
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
|
|
: __base(_VSTD::move(__x.__alloc()))
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
__get_db()->swap(this, &__x);
|
|
#endif
|
|
this->__begin_ = __x.__begin_;
|
|
this->__end_ = __x.__end_;
|
|
this->__end_cap() = __x.__end_cap();
|
|
__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>::vector(vector&& __x, const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__a == __x.__alloc())
|
|
{
|
|
this->__begin_ = __x.__begin_;
|
|
this->__end_ = __x.__end_;
|
|
this->__end_cap() = __x.__end_cap();
|
|
__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->swap(this, &__x);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
typedef move_iterator<iterator> _Ip;
|
|
assign(_Ip(__x.begin()), _Ip(__x.end()));
|
|
}
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__il.size() > 0)
|
|
{
|
|
allocate(__il.size());
|
|
__construct_at_end(__il.begin(), __il.end());
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
|
|
: __base(__a)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__insert_c(this);
|
|
#endif
|
|
if (__il.size() > 0)
|
|
{
|
|
allocate(__il.size());
|
|
__construct_at_end(__il.begin(), __il.end());
|
|
}
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>&
|
|
vector<_Tp, _Allocator>::operator=(vector&& __x)
|
|
_NOEXCEPT_(
|
|
__alloc_traits::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
__move_assign(__x, integral_constant<bool,
|
|
__alloc_traits::propagate_on_container_move_assignment::value>());
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
|
|
{
|
|
if (__base::__alloc() != __c.__alloc())
|
|
{
|
|
typedef move_iterator<iterator> _Ip;
|
|
assign(_Ip(__c.begin()), _Ip(__c.end()));
|
|
}
|
|
else
|
|
__move_assign(__c, true_type());
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
deallocate();
|
|
this->__begin_ = __c.__begin_;
|
|
this->__end_ = __c.__end_;
|
|
this->__end_cap() = __c.__end_cap();
|
|
__base::__move_assign_alloc(__c);
|
|
__c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->swap(this, &__c);
|
|
#endif
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<_Tp, _Allocator>&
|
|
vector<_Tp, _Allocator>::operator=(const vector& __x)
|
|
{
|
|
if (this != &__x)
|
|
{
|
|
__base::__copy_assign_alloc(__x);
|
|
assign(__x.__begin_, __x.__end_);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
_Tp,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
void
|
|
>::type
|
|
vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
clear();
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
_Tp,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
void
|
|
>::type
|
|
vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
typename iterator_traits<_ForwardIterator>::difference_type __new_size = _VSTD::distance(__first, __last);
|
|
if (static_cast<size_type>(__new_size) <= capacity())
|
|
{
|
|
_ForwardIterator __mid = __last;
|
|
bool __growing = false;
|
|
if (static_cast<size_type>(__new_size) > size())
|
|
{
|
|
__growing = true;
|
|
__mid = __first;
|
|
_VSTD::advance(__mid, size());
|
|
}
|
|
pointer __m = _VSTD::copy(__first, __mid, this->__begin_);
|
|
if (__growing)
|
|
__construct_at_end(__mid, __last);
|
|
else
|
|
this->__destruct_at_end(__m);
|
|
}
|
|
else
|
|
{
|
|
deallocate();
|
|
allocate(__recommend(static_cast<size_type>(__new_size)));
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
|
|
{
|
|
if (__n <= capacity())
|
|
{
|
|
size_type __s = size();
|
|
_VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u);
|
|
if (__n > __s)
|
|
__construct_at_end(__n - __s, __u);
|
|
else
|
|
this->__destruct_at_end(this->__begin_ + __n);
|
|
}
|
|
else
|
|
{
|
|
deallocate();
|
|
allocate(__recommend(static_cast<size_type>(__n)));
|
|
__construct_at_end(__n, __u);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
return iterator(this, __p);
|
|
#else
|
|
return iterator(__p);
|
|
#endif
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::const_iterator
|
|
vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
return const_iterator(this, __p);
|
|
#else
|
|
return const_iterator(__p);
|
|
#endif
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::begin() _NOEXCEPT
|
|
{
|
|
return __make_iter(this->__begin_);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::const_iterator
|
|
vector<_Tp, _Allocator>::begin() const _NOEXCEPT
|
|
{
|
|
return __make_iter(this->__begin_);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::end() _NOEXCEPT
|
|
{
|
|
return __make_iter(this->__end_);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::const_iterator
|
|
vector<_Tp, _Allocator>::end() const _NOEXCEPT
|
|
{
|
|
return __make_iter(this->__end_);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::reference
|
|
vector<_Tp, _Allocator>::operator[](size_type __n)
|
|
{
|
|
_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
|
|
return this->__begin_[__n];
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::const_reference
|
|
vector<_Tp, _Allocator>::operator[](size_type __n) const
|
|
{
|
|
_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
|
|
return this->__begin_[__n];
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::reference
|
|
vector<_Tp, _Allocator>::at(size_type __n)
|
|
{
|
|
if (__n >= size())
|
|
this->__throw_out_of_range();
|
|
return this->__begin_[__n];
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::const_reference
|
|
vector<_Tp, _Allocator>::at(size_type __n) const
|
|
{
|
|
if (__n >= size())
|
|
this->__throw_out_of_range();
|
|
return this->__begin_[__n];
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::reserve(size_type __n)
|
|
{
|
|
if (__n > capacity())
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
|
|
__swap_out_circular_buffer(__v);
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
|
|
{
|
|
if (capacity() > size())
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
|
|
__swap_out_circular_buffer(__v);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _Up>
|
|
void
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
|
|
#else
|
|
vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
|
|
#endif
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
|
|
// __v.push_back(_VSTD::forward<_Up>(__x));
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Up>(__x));
|
|
__v.__end_++;
|
|
__swap_out_circular_buffer(__v);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::push_back(const_reference __x)
|
|
{
|
|
if (this->__end_ != this->__end_cap())
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_), __x);
|
|
++this->__end_;
|
|
}
|
|
else
|
|
__push_back_slow_path(__x);
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::push_back(value_type&& __x)
|
|
{
|
|
if (this->__end_ < this->__end_cap())
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::move(__x));
|
|
++this->__end_;
|
|
}
|
|
else
|
|
__push_back_slow_path(_VSTD::move(__x));
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class... _Args>
|
|
void
|
|
vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
|
|
// __v.emplace_back(_VSTD::forward<_Args>(__args)...);
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Args>(__args)...);
|
|
__v.__end_++;
|
|
__swap_out_circular_buffer(__v);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class... _Args>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
|
|
{
|
|
if (this->__end_ < this->__end_cap())
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::forward<_Args>(__args)...);
|
|
++this->__end_;
|
|
}
|
|
else
|
|
__emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::pop_back()
|
|
{
|
|
_LIBCPP_ASSERT(!empty(), "vector::pop_back called for empty vector");
|
|
this->__destruct_at_end(this->__end_ - 1);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::erase(const_iterator __position)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::erase(iterator) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
_LIBCPP_ASSERT(__position != end(),
|
|
"vector::erase(iterator) called with a non-dereferenceable iterator");
|
|
difference_type __ps = __position - cbegin();
|
|
pointer __p = this->__begin_ + __ps;
|
|
iterator __r = __make_iter(__p);
|
|
this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
|
|
return __r;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
|
|
"vector::erase(iterator, iterator) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
_LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range");
|
|
pointer __p = this->__begin_ + (__first - begin());
|
|
iterator __r = __make_iter(__p);
|
|
if (__first != __last)
|
|
this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p));
|
|
return __r;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
|
|
{
|
|
pointer __old_last = this->__end_;
|
|
difference_type __n = __old_last - __to;
|
|
for (pointer __i = __from_s + __n; __i < __from_e; ++__i, ++this->__end_)
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::move(*__i));
|
|
_VSTD::move_backward(__from_s, __from_s + __n, __old_last);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::insert(iterator, x) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
pointer __p = this->__begin_ + (__position - begin());
|
|
if (this->__end_ < this->__end_cap())
|
|
{
|
|
if (__p == this->__end_)
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_), __x);
|
|
++this->__end_;
|
|
}
|
|
else
|
|
{
|
|
__move_range(__p, this->__end_, __p + 1);
|
|
const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
|
|
if (__p <= __xr && __xr < this->__end_)
|
|
++__xr;
|
|
*__p = *__xr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
|
|
__v.push_back(__x);
|
|
__p = __swap_out_circular_buffer(__v, __p);
|
|
}
|
|
return __make_iter(__p);
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::insert(iterator, x) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
pointer __p = this->__begin_ + (__position - begin());
|
|
if (this->__end_ < this->__end_cap())
|
|
{
|
|
if (__p == this->__end_)
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::move(__x));
|
|
++this->__end_;
|
|
}
|
|
else
|
|
{
|
|
__move_range(__p, this->__end_, __p + 1);
|
|
*__p = _VSTD::move(__x);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
|
|
__v.push_back(_VSTD::move(__x));
|
|
__p = __swap_out_circular_buffer(__v, __p);
|
|
}
|
|
return __make_iter(__p);
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class... _Args>
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::emplace(iterator, x) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
pointer __p = this->__begin_ + (__position - begin());
|
|
if (this->__end_ < this->__end_cap())
|
|
{
|
|
if (__p == this->__end_)
|
|
{
|
|
__alloc_traits::construct(this->__alloc(),
|
|
_VSTD::__to_raw_pointer(this->__end_),
|
|
_VSTD::forward<_Args>(__args)...);
|
|
++this->__end_;
|
|
}
|
|
else
|
|
{
|
|
value_type __tmp(_VSTD::forward<_Args>(__args)...);
|
|
__move_range(__p, this->__end_, __p + 1);
|
|
*__p = _VSTD::move(__tmp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
|
|
__v.emplace_back(_VSTD::forward<_Args>(__args)...);
|
|
__p = __swap_out_circular_buffer(__v, __p);
|
|
}
|
|
return __make_iter(__p);
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_VARIADICS
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Tp, class _Allocator>
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::insert(iterator, n, x) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
pointer __p = this->__begin_ + (__position - begin());
|
|
if (__n > 0)
|
|
{
|
|
if (__n <= static_cast<size_type>(this->__end_cap() - this->__end_))
|
|
{
|
|
size_type __old_n = __n;
|
|
pointer __old_last = this->__end_;
|
|
if (__n > static_cast<size_type>(this->__end_ - __p))
|
|
{
|
|
size_type __cx = __n - (this->__end_ - __p);
|
|
__construct_at_end(__cx, __x);
|
|
__n -= __cx;
|
|
}
|
|
if (__n > 0)
|
|
{
|
|
__move_range(__p, __old_last, __p + __old_n);
|
|
const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
|
|
if (__p <= __xr && __xr < this->__end_)
|
|
__xr += __old_n;
|
|
_VSTD::fill_n(__p, __n, *__xr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
|
|
__v.__construct_at_end(__n, __x);
|
|
__p = __swap_out_circular_buffer(__v, __p);
|
|
}
|
|
}
|
|
return __make_iter(__p);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value &&
|
|
is_constructible<
|
|
_Tp,
|
|
typename iterator_traits<_InputIterator>::reference>::value,
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
>::type
|
|
vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::insert(iterator, range) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
difference_type __off = __position - begin();
|
|
pointer __p = this->__begin_ + __off;
|
|
allocator_type& __a = this->__alloc();
|
|
pointer __old_last = this->__end_;
|
|
for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
|
|
{
|
|
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
|
|
*__first);
|
|
++this->__end_;
|
|
}
|
|
__split_buffer<value_type, allocator_type&> __v(__a);
|
|
if (__first != __last)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
__v.__construct_at_end(__first, __last);
|
|
difference_type __old_size = __old_last - this->__begin_;
|
|
difference_type __old_p = __p - this->__begin_;
|
|
reserve(__recommend(size() + __v.size()));
|
|
__p = this->__begin_ + __old_p;
|
|
__old_last = this->__begin_ + __old_size;
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
erase(__make_iter(__old_last), end());
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
__p = _VSTD::rotate(__p, __old_last, this->__end_);
|
|
insert(__make_iter(__p), make_move_iterator(__v.begin()),
|
|
make_move_iterator(__v.end()));
|
|
return begin() + __off;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value &&
|
|
is_constructible<
|
|
_Tp,
|
|
typename iterator_traits<_ForwardIterator>::reference>::value,
|
|
typename vector<_Tp, _Allocator>::iterator
|
|
>::type
|
|
vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
|
|
"vector::insert(iterator, range) called with an iterator not"
|
|
" referring to this vector");
|
|
#endif
|
|
pointer __p = this->__begin_ + (__position - begin());
|
|
difference_type __n = _VSTD::distance(__first, __last);
|
|
if (__n > 0)
|
|
{
|
|
if (__n <= this->__end_cap() - this->__end_)
|
|
{
|
|
size_type __old_n = __n;
|
|
pointer __old_last = this->__end_;
|
|
_ForwardIterator __m = __last;
|
|
difference_type __dx = this->__end_ - __p;
|
|
if (__n > __dx)
|
|
{
|
|
__m = __first;
|
|
_VSTD::advance(__m, this->__end_ - __p);
|
|
__construct_at_end(__m, __last);
|
|
__n = __dx;
|
|
}
|
|
if (__n > 0)
|
|
{
|
|
__move_range(__p, __old_last, __p + __old_n);
|
|
_VSTD::copy(__first, __m, __p);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allocator_type& __a = this->__alloc();
|
|
__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
|
|
__v.__construct_at_end(__first, __last);
|
|
__p = __swap_out_circular_buffer(__v, __p);
|
|
}
|
|
}
|
|
return __make_iter(__p);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::resize(size_type __sz)
|
|
{
|
|
size_type __cs = size();
|
|
if (__cs < __sz)
|
|
this->__append(__sz - __cs);
|
|
else if (__cs > __sz)
|
|
this->__destruct_at_end(this->__begin_ + __sz);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
|
|
{
|
|
size_type __cs = size();
|
|
if (__cs < __sz)
|
|
this->__append(__sz - __cs, __x);
|
|
else if (__cs > __sz)
|
|
this->__destruct_at_end(this->__begin_ + __sz);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
void
|
|
vector<_Tp, _Allocator>::swap(vector& __x)
|
|
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value)
|
|
{
|
|
_LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value ||
|
|
this->__alloc() == __x.__alloc(),
|
|
"vector::swap: Either propagate_on_container_swap must be true"
|
|
" or the allocators must compare equal");
|
|
_VSTD::swap(this->__begin_, __x.__begin_);
|
|
_VSTD::swap(this->__end_, __x.__end_);
|
|
_VSTD::swap(this->__end_cap(), __x.__end_cap());
|
|
__base::__swap_alloc(this->__alloc(), __x.__alloc());
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->swap(this, &__x);
|
|
#endif // _LIBCPP_DEBUG_LEVEL >= 2
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
bool
|
|
vector<_Tp, _Allocator>::__invariants() const
|
|
{
|
|
if (this->__begin_ == nullptr)
|
|
{
|
|
if (this->__end_ != nullptr || this->__end_cap() != nullptr)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (this->__begin_ > this->__end_)
|
|
return false;
|
|
if (this->__begin_ == this->__end_cap())
|
|
return false;
|
|
if (this->__end_ > this->__end_cap())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
|
|
template <class _Tp, class _Allocator>
|
|
bool
|
|
vector<_Tp, _Allocator>::__dereferenceable(const const_iterator* __i) const
|
|
{
|
|
return this->__begin_ <= __i->base() && __i->base() < this->__end_;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
bool
|
|
vector<_Tp, _Allocator>::__decrementable(const const_iterator* __i) const
|
|
{
|
|
return this->__begin_ < __i->base() && __i->base() <= this->__end_;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
bool
|
|
vector<_Tp, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
|
|
{
|
|
const_pointer __p = __i->base() + __n;
|
|
return this->__begin_ <= __p && __p <= this->__end_;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
bool
|
|
vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
|
|
{
|
|
const_pointer __p = __i->base() + __n;
|
|
return this->__begin_ <= __p && __p < this->__end_;
|
|
}
|
|
|
|
#endif // _LIBCPP_DEBUG_LEVEL >= 2
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<_Tp, _Allocator>::__invalidate_all_iterators()
|
|
{
|
|
#if _LIBCPP_DEBUG_LEVEL >= 2
|
|
__get_db()->__invalidate_all(this);
|
|
#endif // _LIBCPP_DEBUG_LEVEL >= 2
|
|
}
|
|
|
|
// vector<bool>
|
|
|
|
template <class _Allocator> class vector<bool, _Allocator>;
|
|
|
|
template <class _Allocator> struct hash<vector<bool, _Allocator> >;
|
|
|
|
template <class _Allocator>
|
|
struct __has_storage_type<vector<bool, _Allocator> >
|
|
{
|
|
static const bool value = true;
|
|
};
|
|
|
|
template <class _Allocator>
|
|
class _LIBCPP_TYPE_VIS_ONLY vector<bool, _Allocator>
|
|
: private __vector_base_common<true>
|
|
{
|
|
public:
|
|
typedef vector __self;
|
|
typedef bool value_type;
|
|
typedef _Allocator allocator_type;
|
|
typedef allocator_traits<allocator_type> __alloc_traits;
|
|
typedef typename __alloc_traits::size_type size_type;
|
|
typedef typename __alloc_traits::difference_type difference_type;
|
|
typedef size_type __storage_type;
|
|
typedef __bit_iterator<vector, false> pointer;
|
|
typedef __bit_iterator<vector, true> const_pointer;
|
|
typedef pointer iterator;
|
|
typedef const_pointer const_iterator;
|
|
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
|
|
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
|
|
private:
|
|
typedef typename __alloc_traits::template
|
|
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
|
rebind_alloc<__storage_type>
|
|
#else
|
|
rebind_alloc<__storage_type>::other
|
|
#endif
|
|
__storage_allocator;
|
|
typedef allocator_traits<__storage_allocator> __storage_traits;
|
|
typedef typename __storage_traits::pointer __storage_pointer;
|
|
typedef typename __storage_traits::const_pointer __const_storage_pointer;
|
|
|
|
__storage_pointer __begin_;
|
|
size_type __size_;
|
|
__compressed_pair<size_type, __storage_allocator> __cap_alloc_;
|
|
public:
|
|
typedef __bit_reference<vector> reference;
|
|
typedef __bit_const_reference<vector> const_reference;
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type& __cap() _NOEXCEPT
|
|
{return __cap_alloc_.first();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const size_type& __cap() const _NOEXCEPT
|
|
{return __cap_alloc_.first();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
__storage_allocator& __alloc() _NOEXCEPT
|
|
{return __cap_alloc_.second();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const __storage_allocator& __alloc() const _NOEXCEPT
|
|
{return __cap_alloc_.second();}
|
|
|
|
static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
|
|
{return __n * __bits_per_word;}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT
|
|
{return (__n - 1) / __bits_per_word + 1;}
|
|
|
|
public:
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector()
|
|
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
|
|
_LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a);
|
|
~vector();
|
|
explicit vector(size_type __n);
|
|
#if _LIBCPP_STD_VER > 11
|
|
explicit vector(size_type __n, const allocator_type& __a);
|
|
#endif
|
|
vector(size_type __n, const value_type& __v);
|
|
vector(size_type __n, const value_type& __v, const allocator_type& __a);
|
|
template <class _InputIterator>
|
|
vector(_InputIterator __first, _InputIterator __last,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value>::type* = 0);
|
|
template <class _InputIterator>
|
|
vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value>::type* = 0);
|
|
template <class _ForwardIterator>
|
|
vector(_ForwardIterator __first, _ForwardIterator __last,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
|
|
template <class _ForwardIterator>
|
|
vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
|
|
|
|
vector(const vector& __v);
|
|
vector(const vector& __v, const allocator_type& __a);
|
|
vector& operator=(const vector& __v);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
vector(initializer_list<value_type> __il);
|
|
vector(initializer_list<value_type> __il, const allocator_type& __a);
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector(vector&& __v)
|
|
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
|
|
vector(vector&& __v, const allocator_type& __a);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector& operator=(vector&& __v)
|
|
_NOEXCEPT_(
|
|
__alloc_traits::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value);
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
vector& operator=(initializer_list<value_type> __il)
|
|
{assign(__il.begin(), __il.end()); return *this;}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator<_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value,
|
|
void
|
|
>::type
|
|
assign(_InputIterator __first, _InputIterator __last);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
assign(_ForwardIterator __first, _ForwardIterator __last);
|
|
|
|
void assign(size_type __n, const value_type& __x);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void assign(initializer_list<value_type> __il)
|
|
{assign(__il.begin(), __il.end());}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
_LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT
|
|
{return allocator_type(this->__alloc());}
|
|
|
|
size_type max_size() const _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type capacity() const _NOEXCEPT
|
|
{return __internal_cap_to_external(__cap());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_type size() const _NOEXCEPT
|
|
{return __size_;}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
bool empty() const _NOEXCEPT
|
|
{return __size_ == 0;}
|
|
void reserve(size_type __n);
|
|
void shrink_to_fit() _NOEXCEPT;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator begin() _NOEXCEPT
|
|
{return __make_iter(0);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator begin() const _NOEXCEPT
|
|
{return __make_iter(0);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator end() _NOEXCEPT
|
|
{return __make_iter(__size_);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator end() const _NOEXCEPT
|
|
{return __make_iter(__size_);}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
reverse_iterator rbegin() _NOEXCEPT
|
|
{return reverse_iterator(end());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator rbegin() const _NOEXCEPT
|
|
{return const_reverse_iterator(end());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
reverse_iterator rend() _NOEXCEPT
|
|
{return reverse_iterator(begin());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator rend() const _NOEXCEPT
|
|
{return const_reverse_iterator(begin());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator cbegin() const _NOEXCEPT
|
|
{return __make_iter(0);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator cend() const _NOEXCEPT
|
|
{return __make_iter(__size_);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator crbegin() const _NOEXCEPT
|
|
{return rbegin();}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reverse_iterator crend() const _NOEXCEPT
|
|
{return rend();}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __make_ref(__n);}
|
|
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __make_ref(__n);}
|
|
reference at(size_type __n);
|
|
const_reference at(size_type __n) const;
|
|
|
|
_LIBCPP_INLINE_VISIBILITY reference front() {return __make_ref(0);}
|
|
_LIBCPP_INLINE_VISIBILITY const_reference front() const {return __make_ref(0);}
|
|
_LIBCPP_INLINE_VISIBILITY reference back() {return __make_ref(__size_ - 1);}
|
|
_LIBCPP_INLINE_VISIBILITY const_reference back() const {return __make_ref(__size_ - 1);}
|
|
|
|
void push_back(const value_type& __x);
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args)
|
|
{ push_back ( value_type ( _VSTD::forward<_Args>(__args)... )); }
|
|
#endif
|
|
|
|
_LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;}
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class... _Args>
|
|
_LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
|
|
{ return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
|
|
#endif
|
|
|
|
iterator insert(const_iterator __position, const value_type& __x);
|
|
iterator insert(const_iterator __position, size_type __n, const value_type& __x);
|
|
iterator insert(const_iterator __position, size_type __n, const_reference __x);
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value,
|
|
iterator
|
|
>::type
|
|
insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
iterator
|
|
>::type
|
|
insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator insert(const_iterator __position, initializer_list<value_type> __il)
|
|
{return insert(__position, __il.begin(), __il.end());}
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
_LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
|
|
iterator erase(const_iterator __first, const_iterator __last);
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void clear() _NOEXCEPT {__size_ = 0;}
|
|
|
|
void swap(vector&)
|
|
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value);
|
|
|
|
void resize(size_type __sz, value_type __x = false);
|
|
void flip() _NOEXCEPT;
|
|
|
|
bool __invariants() const;
|
|
|
|
private:
|
|
_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
|
|
void allocate(size_type __n);
|
|
void deallocate() _NOEXCEPT;
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static size_type __align_it(size_type __new_size) _NOEXCEPT
|
|
{return __new_size + (__bits_per_word-1) & ~(__bits_per_word-1);};
|
|
_LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
|
|
_LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
__construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
|
|
void __append(size_type __n, const_reference __x);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
reference __make_ref(size_type __pos) _NOEXCEPT
|
|
{return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_reference __make_ref(size_type __pos) const _NOEXCEPT
|
|
{return const_reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator __make_iter(size_type __pos) _NOEXCEPT
|
|
{return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
const_iterator __make_iter(size_type __pos) const _NOEXCEPT
|
|
{return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
|
|
{return begin() + (__p - cbegin());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const vector& __v)
|
|
{__copy_assign_alloc(__v, integral_constant<bool,
|
|
__storage_traits::propagate_on_container_copy_assignment::value>());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const vector& __c, true_type)
|
|
{
|
|
if (__alloc() != __c.__alloc())
|
|
deallocate();
|
|
__alloc() = __c.__alloc();
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __copy_assign_alloc(const vector&, false_type)
|
|
{}
|
|
|
|
void __move_assign(vector& __c, false_type);
|
|
void __move_assign(vector& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(vector& __c)
|
|
_NOEXCEPT_(
|
|
!__storage_traits::propagate_on_container_move_assignment::value ||
|
|
is_nothrow_move_assignable<allocator_type>::value)
|
|
{__move_assign_alloc(__c, integral_constant<bool,
|
|
__storage_traits::propagate_on_container_move_assignment::value>());}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(vector& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
__alloc() = _VSTD::move(__c.__alloc());
|
|
}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
void __move_assign_alloc(vector&, false_type)
|
|
_NOEXCEPT
|
|
{}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y)
|
|
_NOEXCEPT_(
|
|
!__storage_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value)
|
|
{__swap_alloc(__x, __y, integral_constant<bool,
|
|
__storage_traits::propagate_on_container_swap::value>());}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, true_type)
|
|
_NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
|
|
{
|
|
using _VSTD::swap;
|
|
swap(__x, __y);
|
|
}
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
static void __swap_alloc(__storage_allocator&, __storage_allocator&, false_type)
|
|
_NOEXCEPT
|
|
{}
|
|
|
|
size_t __hash_code() const _NOEXCEPT;
|
|
|
|
friend class __bit_reference<vector>;
|
|
friend class __bit_const_reference<vector>;
|
|
friend class __bit_iterator<vector, false>;
|
|
friend class __bit_iterator<vector, true>;
|
|
friend struct __bit_array<vector>;
|
|
friend struct _LIBCPP_TYPE_VIS_ONLY hash<vector>;
|
|
};
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<bool, _Allocator>::__invalidate_all_iterators()
|
|
{
|
|
}
|
|
|
|
// Allocate space for __n objects
|
|
// throws length_error if __n > max_size()
|
|
// throws (probably bad_alloc) if memory run out
|
|
// Precondition: __begin_ == __end_ == __cap() == 0
|
|
// Precondition: __n > 0
|
|
// Postcondition: capacity() == __n
|
|
// Postcondition: size() == 0
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::allocate(size_type __n)
|
|
{
|
|
if (__n > max_size())
|
|
this->__throw_length_error();
|
|
__n = __external_cap_to_internal(__n);
|
|
this->__begin_ = __storage_traits::allocate(this->__alloc(), __n);
|
|
this->__size_ = 0;
|
|
this->__cap() = __n;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::deallocate() _NOEXCEPT
|
|
{
|
|
if (this->__begin_ != nullptr)
|
|
{
|
|
__storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
|
|
__invalidate_all_iterators();
|
|
this->__begin_ = nullptr;
|
|
this->__size_ = this->__cap() = 0;
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::size_type
|
|
vector<bool, _Allocator>::max_size() const _NOEXCEPT
|
|
{
|
|
size_type __amax = __storage_traits::max_size(__alloc());
|
|
size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always
|
|
if (__nmax / __bits_per_word <= __amax)
|
|
return __nmax;
|
|
return __internal_cap_to_external(__amax);
|
|
}
|
|
|
|
// Precondition: __new_size > capacity()
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<bool, _Allocator>::size_type
|
|
vector<bool, _Allocator>::__recommend(size_type __new_size) const
|
|
{
|
|
const size_type __ms = max_size();
|
|
if (__new_size > __ms)
|
|
this->__throw_length_error();
|
|
const size_type __cap = capacity();
|
|
if (__cap >= __ms / 2)
|
|
return __ms;
|
|
return _VSTD::max(2*__cap, __align_it(__new_size));
|
|
}
|
|
|
|
// Default constructs __n objects starting at __end_
|
|
// Precondition: __n > 0
|
|
// Precondition: size() + __n <= capacity()
|
|
// Postcondition: size() == size() + __n
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
|
|
{
|
|
size_type __old_size = this->__size_;
|
|
this->__size_ += __n;
|
|
_VSTD::fill_n(__make_iter(__old_size), __n, __x);
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
size_type __old_size = this->__size_;
|
|
this->__size_ += _VSTD::distance(__first, __last);
|
|
_VSTD::copy(__first, __last, __make_iter(__old_size));
|
|
}
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<bool, _Allocator>::vector()
|
|
_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
}
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<bool, _Allocator>::vector(const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(size_type __n)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, false);
|
|
}
|
|
}
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, false);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, __x);
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__n, __x);
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _InputIterator>
|
|
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value>::type*)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
if (__begin_ != nullptr)
|
|
__storage_traits::deallocate(__alloc(), __begin_, __cap());
|
|
__invalidate_all_iterators();
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _InputIterator>
|
|
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value>::type*)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
if (__begin_ != nullptr)
|
|
__storage_traits::deallocate(__alloc(), __begin_, __cap());
|
|
__invalidate_all_iterators();
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _ForwardIterator>
|
|
vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _ForwardIterator>
|
|
vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
|
|
typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0)
|
|
{
|
|
size_type __n = static_cast<size_type>(__il.size());
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__il.begin(), __il.end());
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, static_cast<__storage_allocator>(__a))
|
|
{
|
|
size_type __n = static_cast<size_type>(__il.size());
|
|
if (__n > 0)
|
|
{
|
|
allocate(__n);
|
|
__construct_at_end(__il.begin(), __il.end());
|
|
}
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::~vector()
|
|
{
|
|
if (__begin_ != nullptr)
|
|
__storage_traits::deallocate(__alloc(), __begin_, __cap());
|
|
__invalidate_all_iterators();
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(const vector& __v)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
|
|
{
|
|
if (__v.size() > 0)
|
|
{
|
|
allocate(__v.size());
|
|
__construct_at_end(__v.begin(), __v.end());
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, __a)
|
|
{
|
|
if (__v.size() > 0)
|
|
{
|
|
allocate(__v.size());
|
|
__construct_at_end(__v.begin(), __v.end());
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>&
|
|
vector<bool, _Allocator>::operator=(const vector& __v)
|
|
{
|
|
if (this != &__v)
|
|
{
|
|
__copy_assign_alloc(__v);
|
|
if (__v.__size_)
|
|
{
|
|
if (__v.__size_ > capacity())
|
|
{
|
|
deallocate();
|
|
allocate(__v.__size_);
|
|
}
|
|
_VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
|
|
}
|
|
__size_ = __v.__size_;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<bool, _Allocator>::vector(vector&& __v)
|
|
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
|
|
: __begin_(__v.__begin_),
|
|
__size_(__v.__size_),
|
|
__cap_alloc_(__v.__cap_alloc_)
|
|
{
|
|
__v.__begin_ = nullptr;
|
|
__v.__size_ = 0;
|
|
__v.__cap() = 0;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
vector<bool, _Allocator>::vector(vector&& __v, const allocator_type& __a)
|
|
: __begin_(nullptr),
|
|
__size_(0),
|
|
__cap_alloc_(0, __a)
|
|
{
|
|
if (__a == allocator_type(__v.__alloc()))
|
|
{
|
|
this->__begin_ = __v.__begin_;
|
|
this->__size_ = __v.__size_;
|
|
this->__cap() = __v.__cap();
|
|
__v.__begin_ = nullptr;
|
|
__v.__cap() = __v.__size_ = 0;
|
|
}
|
|
else if (__v.size() > 0)
|
|
{
|
|
allocate(__v.size());
|
|
__construct_at_end(__v.begin(), __v.end());
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
vector<bool, _Allocator>&
|
|
vector<bool, _Allocator>::operator=(vector&& __v)
|
|
_NOEXCEPT_(
|
|
__alloc_traits::propagate_on_container_move_assignment::value &&
|
|
is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
__move_assign(__v, integral_constant<bool,
|
|
__storage_traits::propagate_on_container_move_assignment::value>());
|
|
return *this;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::__move_assign(vector& __c, false_type)
|
|
{
|
|
if (__alloc() != __c.__alloc())
|
|
assign(__c.begin(), __c.end());
|
|
else
|
|
__move_assign(__c, true_type());
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
|
|
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
|
{
|
|
deallocate();
|
|
this->__begin_ = __c.__begin_;
|
|
this->__size_ = __c.__size_;
|
|
this->__cap() = __c.__cap();
|
|
__move_assign_alloc(__c);
|
|
__c.__begin_ = nullptr;
|
|
__c.__cap() = __c.__size_ = 0;
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
|
|
{
|
|
__size_ = 0;
|
|
if (__n > 0)
|
|
{
|
|
size_type __c = capacity();
|
|
if (__n <= __c)
|
|
__size_ = __n;
|
|
else
|
|
{
|
|
vector __v(__alloc());
|
|
__v.reserve(__recommend(__n));
|
|
__v.__size_ = __n;
|
|
swap(__v);
|
|
}
|
|
_VSTD::fill_n(begin(), __n, __x);
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator<_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value,
|
|
void
|
|
>::type
|
|
vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
|
|
{
|
|
clear();
|
|
for (; __first != __last; ++__first)
|
|
push_back(*__first);
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
void
|
|
>::type
|
|
vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
clear();
|
|
difference_type __n = _VSTD::distance(__first, __last);
|
|
if (__n)
|
|
{
|
|
if (__n > capacity())
|
|
{
|
|
deallocate();
|
|
allocate(__n);
|
|
}
|
|
__construct_at_end(__first, __last);
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::reserve(size_type __n)
|
|
{
|
|
if (__n > capacity())
|
|
{
|
|
vector __v(this->__alloc());
|
|
__v.allocate(__n);
|
|
__v.__construct_at_end(this->begin(), this->end());
|
|
swap(__v);
|
|
__invalidate_all_iterators();
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
|
|
{
|
|
if (__external_cap_to_internal(size()) > __cap())
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
vector(*this, allocator_type(__alloc())).swap(*this);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::reference
|
|
vector<bool, _Allocator>::at(size_type __n)
|
|
{
|
|
if (__n >= size())
|
|
this->__throw_out_of_range();
|
|
return (*this)[__n];
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::const_reference
|
|
vector<bool, _Allocator>::at(size_type __n) const
|
|
{
|
|
if (__n >= size())
|
|
this->__throw_out_of_range();
|
|
return (*this)[__n];
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::push_back(const value_type& __x)
|
|
{
|
|
if (this->__size_ == this->capacity())
|
|
reserve(__recommend(this->__size_ + 1));
|
|
++this->__size_;
|
|
back() = __x;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::iterator
|
|
vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
|
|
{
|
|
iterator __r;
|
|
if (size() < capacity())
|
|
{
|
|
const_iterator __old_end = end();
|
|
++__size_;
|
|
_VSTD::copy_backward(__position, __old_end, end());
|
|
__r = __const_iterator_cast(__position);
|
|
}
|
|
else
|
|
{
|
|
vector __v(__alloc());
|
|
__v.reserve(__recommend(__size_ + 1));
|
|
__v.__size_ = __size_ + 1;
|
|
__r = _VSTD::copy(cbegin(), __position, __v.begin());
|
|
_VSTD::copy_backward(__position, cend(), __v.end());
|
|
swap(__v);
|
|
}
|
|
*__r = __x;
|
|
return __r;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::iterator
|
|
vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
|
|
{
|
|
iterator __r;
|
|
size_type __c = capacity();
|
|
if (__n <= __c && size() <= __c - __n)
|
|
{
|
|
const_iterator __old_end = end();
|
|
__size_ += __n;
|
|
_VSTD::copy_backward(__position, __old_end, end());
|
|
__r = __const_iterator_cast(__position);
|
|
}
|
|
else
|
|
{
|
|
vector __v(__alloc());
|
|
__v.reserve(__recommend(__size_ + __n));
|
|
__v.__size_ = __size_ + __n;
|
|
__r = _VSTD::copy(cbegin(), __position, __v.begin());
|
|
_VSTD::copy_backward(__position, cend(), __v.end());
|
|
swap(__v);
|
|
}
|
|
_VSTD::fill_n(__r, __n, __x);
|
|
return __r;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _InputIterator>
|
|
typename enable_if
|
|
<
|
|
__is_input_iterator <_InputIterator>::value &&
|
|
!__is_forward_iterator<_InputIterator>::value,
|
|
typename vector<bool, _Allocator>::iterator
|
|
>::type
|
|
vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
|
|
{
|
|
difference_type __off = __position - begin();
|
|
iterator __p = __const_iterator_cast(__position);
|
|
iterator __old_end = end();
|
|
for (; size() != capacity() && __first != __last; ++__first)
|
|
{
|
|
++this->__size_;
|
|
back() = *__first;
|
|
}
|
|
vector __v(__alloc());
|
|
if (__first != __last)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
__v.assign(__first, __last);
|
|
difference_type __old_size = static_cast<difference_type>(__old_end - begin());
|
|
difference_type __old_p = __p - begin();
|
|
reserve(__recommend(size() + __v.size()));
|
|
__p = begin() + __old_p;
|
|
__old_end = begin() + __old_size;
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
erase(__old_end, end());
|
|
throw;
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
__p = _VSTD::rotate(__p, __old_end, end());
|
|
insert(__p, __v.begin(), __v.end());
|
|
return begin() + __off;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
template <class _ForwardIterator>
|
|
typename enable_if
|
|
<
|
|
__is_forward_iterator<_ForwardIterator>::value,
|
|
typename vector<bool, _Allocator>::iterator
|
|
>::type
|
|
vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
|
|
{
|
|
difference_type __n = _VSTD::distance(__first, __last);
|
|
iterator __r;
|
|
size_type __c = capacity();
|
|
if (__n <= __c && size() <= __c - __n)
|
|
{
|
|
const_iterator __old_end = end();
|
|
__size_ += __n;
|
|
_VSTD::copy_backward(__position, __old_end, end());
|
|
__r = __const_iterator_cast(__position);
|
|
}
|
|
else
|
|
{
|
|
vector __v(__alloc());
|
|
__v.reserve(__recommend(__size_ + __n));
|
|
__v.__size_ = __size_ + __n;
|
|
__r = _VSTD::copy(cbegin(), __position, __v.begin());
|
|
_VSTD::copy_backward(__position, cend(), __v.end());
|
|
swap(__v);
|
|
}
|
|
_VSTD::copy(__first, __last, __r);
|
|
return __r;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename vector<bool, _Allocator>::iterator
|
|
vector<bool, _Allocator>::erase(const_iterator __position)
|
|
{
|
|
iterator __r = __const_iterator_cast(__position);
|
|
_VSTD::copy(__position + 1, this->cend(), __r);
|
|
--__size_;
|
|
return __r;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
typename vector<bool, _Allocator>::iterator
|
|
vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
|
|
{
|
|
iterator __r = __const_iterator_cast(__first);
|
|
difference_type __d = __last - __first;
|
|
_VSTD::copy(__last, this->cend(), __r);
|
|
__size_ -= __d;
|
|
return __r;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::swap(vector& __x)
|
|
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
|
|
__is_nothrow_swappable<allocator_type>::value)
|
|
{
|
|
_VSTD::swap(this->__begin_, __x.__begin_);
|
|
_VSTD::swap(this->__size_, __x.__size_);
|
|
_VSTD::swap(this->__cap(), __x.__cap());
|
|
__swap_alloc(this->__alloc(), __x.__alloc());
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
|
|
{
|
|
size_type __cs = size();
|
|
if (__cs < __sz)
|
|
{
|
|
iterator __r;
|
|
size_type __c = capacity();
|
|
size_type __n = __sz - __cs;
|
|
if (__n <= __c && __cs <= __c - __n)
|
|
{
|
|
__r = end();
|
|
__size_ += __n;
|
|
}
|
|
else
|
|
{
|
|
vector __v(__alloc());
|
|
__v.reserve(__recommend(__size_ + __n));
|
|
__v.__size_ = __size_ + __n;
|
|
__r = _VSTD::copy(cbegin(), cend(), __v.begin());
|
|
swap(__v);
|
|
}
|
|
_VSTD::fill_n(__r, __n, __x);
|
|
}
|
|
else
|
|
__size_ = __sz;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
void
|
|
vector<bool, _Allocator>::flip() _NOEXCEPT
|
|
{
|
|
// do middle whole words
|
|
size_type __n = __size_;
|
|
__storage_pointer __p = __begin_;
|
|
for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
|
|
*__p = ~*__p;
|
|
// do last partial word
|
|
if (__n > 0)
|
|
{
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
__storage_type __b = *__p & __m;
|
|
*__p &= ~__m;
|
|
*__p |= ~__b & __m;
|
|
}
|
|
}
|
|
|
|
template <class _Allocator>
|
|
bool
|
|
vector<bool, _Allocator>::__invariants() const
|
|
{
|
|
if (this->__begin_ == nullptr)
|
|
{
|
|
if (this->__size_ != 0 || this->__cap() != 0)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (this->__cap() == 0)
|
|
return false;
|
|
if (this->__size_ > this->capacity())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
size_t
|
|
vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
|
|
{
|
|
size_t __h = 0;
|
|
// do middle whole words
|
|
size_type __n = __size_;
|
|
__storage_pointer __p = __begin_;
|
|
for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
|
|
__h ^= *__p;
|
|
// do last partial word
|
|
if (__n > 0)
|
|
{
|
|
const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
__h ^= *__p & __m;
|
|
}
|
|
return __h;
|
|
}
|
|
|
|
template <class _Allocator>
|
|
struct _LIBCPP_TYPE_VIS_ONLY hash<vector<bool, _Allocator> >
|
|
: public unary_function<vector<bool, _Allocator>, size_t>
|
|
{
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
|
|
{return __vec.__hash_code();}
|
|
};
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
|
|
return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
return !(__x == __y);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
return __y < __x;
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
return !(__x < __y);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
bool
|
|
operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
|
|
{
|
|
return !(__y < __x);
|
|
}
|
|
|
|
template <class _Tp, class _Allocator>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
|
|
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
|
|
{
|
|
__x.swap(__y);
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_VECTOR
|