Index: include/__bit_reference =================================================================== --- include/__bit_reference +++ include/__bit_reference @@ -164,11 +164,11 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); __storage_type __b = *__first.__seg_ & __m; if (__b) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(__b))); + return _It(__first.__seg_, static_cast(std::__ctz(__b))); if (__n == __dn) return __first + __n; __n -= __dn; @@ -177,14 +177,14 @@ // do middle whole words for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) if (*__first.__seg_) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(*__first.__seg_))); + return _It(__first.__seg_, static_cast(std::__ctz(*__first.__seg_))); // do last partial word if (__n > 0) { __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __b = *__first.__seg_ & __m; if (__b) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(__b))); + return _It(__first.__seg_, static_cast(std::__ctz(__b))); } return _It(__first.__seg_, static_cast(__n)); } @@ -200,11 +200,11 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); __storage_type __b = ~*__first.__seg_ & __m; if (__b) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(__b))); + return _It(__first.__seg_, static_cast(std::__ctz(__b))); if (__n == __dn) return __first + __n; __n -= __dn; @@ -215,7 +215,7 @@ { __storage_type __b = ~*__first.__seg_; if (__b) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(__b))); + return _It(__first.__seg_, static_cast(std::__ctz(__b))); } // do last partial word if (__n > 0) @@ -223,7 +223,7 @@ __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __b = ~*__first.__seg_ & __m; if (__b) - return _It(__first.__seg_, static_cast(_VSTD::__ctz(__b))); + return _It(__first.__seg_, static_cast(std::__ctz(__b))); } return _It(__first.__seg_, static_cast(__n)); } @@ -253,20 +253,20 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); - __r = _VSTD::__popcount(*__first.__seg_ & __m); + __r = std::__popcount(*__first.__seg_ & __m); __n -= __dn; ++__first.__seg_; } // do middle whole words for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) - __r += _VSTD::__popcount(*__first.__seg_); + __r += std::__popcount(*__first.__seg_); // do last partial word if (__n > 0) { __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); - __r += _VSTD::__popcount(*__first.__seg_ & __m); + __r += std::__popcount(*__first.__seg_ & __m); } return __r; } @@ -284,20 +284,20 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); - __r = _VSTD::__popcount(~*__first.__seg_ & __m); + __r = std::__popcount(~*__first.__seg_ & __m); __n -= __dn; ++__first.__seg_; } // do middle whole words for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) - __r += _VSTD::__popcount(~*__first.__seg_); + __r += std::__popcount(~*__first.__seg_); // do last partial word if (__n > 0) { __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); - __r += _VSTD::__popcount(~*__first.__seg_ & __m); + __r += std::__popcount(~*__first.__seg_ & __m); } return __r; } @@ -325,7 +325,7 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); *__first.__seg_ &= ~__m; __n -= __dn; @@ -333,7 +333,7 @@ } // do middle whole words __storage_type __nw = __n / __bits_per_word; - _VSTD::memset(_VSTD::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type)); + std::memset(std::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type)); __n -= __nw * __bits_per_word; // do last partial word if (__n > 0) @@ -355,7 +355,7 @@ if (__first.__ctz_ != 0) { __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); - __storage_type __dn = _VSTD::min(__clz_f, __n); + __storage_type __dn = std::min(__clz_f, __n); __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); *__first.__seg_ |= __m; __n -= __dn; @@ -363,7 +363,7 @@ } // do middle whole words __storage_type __nw = __n / __bits_per_word; - _VSTD::memset(_VSTD::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type)); + std::memset(std::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type)); __n -= __nw * __bits_per_word; // do last partial word if (__n > 0) @@ -395,7 +395,7 @@ void fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_) { - _VSTD::fill_n(__first, static_cast(__last - __first), __value_); + std::fill_n(__first, static_cast(__last - __first), __value_); } // copy @@ -416,7 +416,7 @@ if (__first.__ctz_ != 0) { unsigned __clz = __bits_per_word - __first.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz), __n); + difference_type __dn = std::min(static_cast(__clz), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); __storage_type __b = *__first.__seg_ & __m; @@ -430,8 +430,8 @@ // __first.__ctz_ == 0; // do middle words __storage_type __nw = __n / __bits_per_word; - _VSTD::memmove(_VSTD::__to_raw_pointer(__result.__seg_), - _VSTD::__to_raw_pointer(__first.__seg_), + std::memmove(std::__to_raw_pointer(__result.__seg_), + std::__to_raw_pointer(__first.__seg_), __nw * sizeof(__storage_type)); __n -= __nw * __bits_per_word; __result.__seg_ += __nw; @@ -465,12 +465,12 @@ if (__first.__ctz_ != 0) { unsigned __clz_f = __bits_per_word - __first.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz_f), __n); + difference_type __dn = std::min(static_cast(__clz_f), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); __storage_type __b = *__first.__seg_ & __m; unsigned __clz_r = __bits_per_word - __result.__ctz_; - __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); + __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r); __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); *__result.__seg_ &= ~__m; if (__result.__ctz_ > __first.__ctz_) @@ -508,7 +508,7 @@ { __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __b = *__first.__seg_ & __m; - __storage_type __dn = _VSTD::min(__n, static_cast(__clz_r)); + __storage_type __dn = std::min(__n, static_cast(__clz_r)); __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); *__result.__seg_ &= ~__m; *__result.__seg_ |= __b << __result.__ctz_; @@ -554,7 +554,7 @@ // do first word if (__last.__ctz_ != 0) { - difference_type __dn = _VSTD::min(static_cast(__last.__ctz_), __n); + difference_type __dn = std::min(static_cast(__last.__ctz_), __n); __n -= __dn; unsigned __clz = __bits_per_word - __last.__ctz_; __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz); @@ -571,8 +571,8 @@ __storage_type __nw = __n / __bits_per_word; __result.__seg_ -= __nw; __last.__seg_ -= __nw; - _VSTD::memmove(_VSTD::__to_raw_pointer(__result.__seg_), - _VSTD::__to_raw_pointer(__last.__seg_), + std::memmove(std::__to_raw_pointer(__result.__seg_), + std::__to_raw_pointer(__last.__seg_), __nw * sizeof(__storage_type)); __n -= __nw * __bits_per_word; // do last word @@ -603,13 +603,13 @@ // do first word if (__last.__ctz_ != 0) { - difference_type __dn = _VSTD::min(static_cast(__last.__ctz_), __n); + difference_type __dn = std::min(static_cast(__last.__ctz_), __n); __n -= __dn; unsigned __clz_l = __bits_per_word - __last.__ctz_; __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l); __storage_type __b = *__last.__seg_ & __m; unsigned __clz_r = __bits_per_word - __result.__ctz_; - __storage_type __ddn = _VSTD::min(__dn, static_cast(__result.__ctz_)); + __storage_type __ddn = std::min(__dn, static_cast(__result.__ctz_)); if (__ddn > 0) { __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r); @@ -653,7 +653,7 @@ __m = ~__storage_type(0) << (__bits_per_word - __n); __storage_type __b = *--__last.__seg_ & __m; __clz_r = __bits_per_word - __result.__ctz_; - __storage_type __dn = _VSTD::min(__n, static_cast(__result.__ctz_)); + __storage_type __dn = std::min(__n, static_cast(__result.__ctz_)); __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r); *__result.__seg_ &= ~__m; *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_); @@ -691,7 +691,7 @@ __bit_iterator<_Cp, false> move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) { - return _VSTD::copy(__first, __last, __result); + return std::copy(__first, __last, __result); } // move_backward @@ -701,7 +701,7 @@ __bit_iterator<_Cp, false> move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) { - return _VSTD::copy_backward(__first, __last, __result); + return std::copy_backward(__first, __last, __result); } // swap_ranges @@ -722,7 +722,7 @@ if (__first.__ctz_ != 0) { unsigned __clz = __bits_per_word - __first.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz), __n); + difference_type __dn = std::min(static_cast(__clz), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); __storage_type __b1 = *__first.__seg_ & __m; @@ -772,13 +772,13 @@ if (__first.__ctz_ != 0) { unsigned __clz_f = __bits_per_word - __first.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz_f), __n); + difference_type __dn = std::min(static_cast(__clz_f), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); __storage_type __b1 = *__first.__seg_ & __m; *__first.__seg_ &= ~__m; unsigned __clz_r = __bits_per_word - __result.__ctz_; - __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); + __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r); __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); __storage_type __b2 = *__result.__seg_ & __m; *__result.__seg_ &= ~__m; @@ -833,7 +833,7 @@ __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __b1 = *__first.__seg_ & __m; *__first.__seg_ &= ~__m; - __storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r); + __storage_type __dn = std::min<__storage_type>(__n, __clz_r); __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); __storage_type __b2 = *__result.__seg_ & __m; *__result.__seg_ &= ~__m; @@ -912,13 +912,13 @@ if (__d1 <= __bit_array<_Cp>::capacity()) { __bit_array<_Cp> __b(__d1); - _VSTD::copy(__first, __middle, __b.begin()); - _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first)); + std::copy(__first, __middle, __b.begin()); + std::copy(__b.begin(), __b.end(), std::copy(__middle, __last, __first)); break; } else { - __bit_iterator<_Cp, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle); + __bit_iterator<_Cp, false> __mp = std::swap_ranges(__first, __middle, __middle); __first = __middle; __middle = __mp; __d2 -= __d1; @@ -929,14 +929,14 @@ if (__d2 <= __bit_array<_Cp>::capacity()) { __bit_array<_Cp> __b(__d2); - _VSTD::copy(__middle, __last, __b.begin()); - _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last)); + std::copy(__middle, __last, __b.begin()); + std::copy_backward(__b.begin(), __b.end(), std::copy_backward(__first, __middle, __last)); break; } else { __bit_iterator<_Cp, false> __mp = __first + __d2; - _VSTD::swap_ranges(__first, __mp, __middle); + std::swap_ranges(__first, __mp, __middle); __first = __mp; __d1 -= __d2; } @@ -963,12 +963,12 @@ if (__first1.__ctz_ != 0) { unsigned __clz_f = __bits_per_word - __first1.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz_f), __n); + difference_type __dn = std::min(static_cast(__clz_f), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); __storage_type __b = *__first1.__seg_ & __m; unsigned __clz_r = __bits_per_word - __first2.__ctz_; - __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); + __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r); __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); if (__first2.__ctz_ > __first1.__ctz_) { @@ -1011,7 +1011,7 @@ { __m = ~__storage_type(0) >> (__bits_per_word - __n); __storage_type __b = *__first1.__seg_ & __m; - __storage_type __dn = _VSTD::min(__n, static_cast(__clz_r)); + __storage_type __dn = std::min(__n, static_cast(__clz_r)); __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_)) return false; @@ -1045,7 +1045,7 @@ if (__first1.__ctz_ != 0) { unsigned __clz = __bits_per_word - __first1.__ctz_; - difference_type __dn = _VSTD::min(static_cast(__clz), __n); + difference_type __dn = std::min(static_cast(__clz), __n); __n -= __dn; __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m)) Index: include/__config =================================================================== --- include/__config +++ include/__config @@ -797,7 +797,6 @@ // Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect. #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE { #define _LIBCPP_END_NAMESPACE_STD } } -#define _VSTD std::_LIBCPP_ABI_NAMESPACE _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD #if _LIBCPP_STD_VER >= 17 @@ -811,7 +810,7 @@ #define _LIBCPP_END_NAMESPACE_FILESYSTEM \ _LIBCPP_END_NAMESPACE_STD } } -#define _VSTD_FS _VSTD::__fs::filesystem +#define _VSTD_FS std::__fs::filesystem #ifndef _LIBCPP_PREFERRED_OVERLOAD # if __has_attribute(__enable_if__) @@ -1095,7 +1094,7 @@ #endif #ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES -# define _LIBCPP_EXPLICIT_MOVE(x) _VSTD::move(x) +# define _LIBCPP_EXPLICIT_MOVE(x) std::move(x) #else # define _LIBCPP_EXPLICIT_MOVE(x) (x) #endif Index: include/__debug =================================================================== --- include/__debug +++ include/__debug @@ -30,7 +30,7 @@ #if _LIBCPP_DEBUG_LEVEL >= 1 && !defined(_LIBCPP_ASSERT) # define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : \ - _VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, #x, m))) + std::__libcpp_debug_function(std::__libcpp_debug_info(__FILE__, __LINE__, #x, m))) #endif #if _LIBCPP_DEBUG_LEVEL >= 2 Index: include/__functional_03 =================================================================== --- include/__functional_03 +++ include/__functional_03 @@ -105,8 +105,8 @@ { __compressed_pair<_Fp, _Alloc> __f_; public: - explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} - explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + explicit __func(_Fp __f) : __f_(std::move(__f)) {} + explicit __func(_Fp __f, _Alloc __a) : __f_(std::move(__f), std::move(__a)) {} virtual __base<_Rp()>* __clone() const; virtual void __clone(__base<_Rp()>*) const; virtual void destroy(); @@ -190,9 +190,9 @@ { __compressed_pair<_Fp, _Alloc> __f_; public: - _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} + _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(std::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) - : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + : __f_(std::move(__f), std::move(__a)) {} virtual __base<_Rp(_A0)>* __clone() const; virtual void __clone(__base<_Rp(_A0)>*) const; virtual void destroy(); @@ -276,9 +276,9 @@ { __compressed_pair<_Fp, _Alloc> __f_; public: - _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} + _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(std::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) - : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + : __f_(std::move(__f), std::move(__a)) {} virtual __base<_Rp(_A0, _A1)>* __clone() const; virtual void __clone(__base<_Rp(_A0, _A1)>*) const; virtual void destroy(); @@ -362,9 +362,9 @@ { __compressed_pair<_Fp, _Alloc> __f_; public: - _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} + _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(std::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) - : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + : __f_(std::move(__f), std::move(__a)) {} virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const; virtual void __clone(__base<_Rp(_A0, _A1, _A2)>*) const; virtual void destroy(); @@ -629,7 +629,7 @@ >::type function<_Rp()>::operator=(_Fp __f) { - function(_VSTD::move(__f)).swap(*this); + function(std::move(__f)).swap(*this); return *this; } @@ -646,7 +646,7 @@ void function<_Rp()>::swap(function& __f) { - if (_VSTD::addressof(__f) == this) + if (std::addressof(__f) == this) return; if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { @@ -678,7 +678,7 @@ __f_ = (__base*)&__buf_; } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } template @@ -909,7 +909,7 @@ >::type function<_Rp(_A0)>::operator=(_Fp __f) { - function(_VSTD::move(__f)).swap(*this); + function(std::move(__f)).swap(*this); return *this; } @@ -926,7 +926,7 @@ void function<_Rp(_A0)>::swap(function& __f) { - if (_VSTD::addressof(__f) == this) + if (std::addressof(__f) == this) return; if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { @@ -958,7 +958,7 @@ __f_ = (__base*)&__buf_; } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } template @@ -1189,7 +1189,7 @@ >::type function<_Rp(_A0, _A1)>::operator=(_Fp __f) { - function(_VSTD::move(__f)).swap(*this); + function(std::move(__f)).swap(*this); return *this; } @@ -1206,7 +1206,7 @@ void function<_Rp(_A0, _A1)>::swap(function& __f) { - if (_VSTD::addressof(__f) == this) + if (std::addressof(__f) == this) return; if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { @@ -1238,7 +1238,7 @@ __f_ = (__base*)&__buf_; } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } template @@ -1469,7 +1469,7 @@ >::type function<_Rp(_A0, _A1, _A2)>::operator=(_Fp __f) { - function(_VSTD::move(__f)).swap(*this); + function(std::move(__f)).swap(*this); return *this; } @@ -1486,7 +1486,7 @@ void function<_Rp(_A0, _A1, _A2)>::swap(function& __f) { - if (_VSTD::addressof(__f) == this) + if (std::addressof(__f) == this) return; if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { @@ -1518,7 +1518,7 @@ __f_ = (__base*)&__buf_; } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } template Index: include/__functional_base =================================================================== --- include/__functional_base +++ include/__functional_base @@ -62,9 +62,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) < std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) < std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) < std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -299,7 +299,7 @@ template struct __invoke_return { - typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type; + typedef decltype(__invoke(std::declval<_Tp>(), std::declval<_Args>()...)) type; }; #else // defined(_LIBCPP_CXX03_LANG) @@ -315,7 +315,7 @@ #ifndef _LIBCPP_CXX03_LANG template static _Ret __call(_Args&&... __args) { - return __invoke(_VSTD::forward<_Args>(__args)...); + return __invoke(std::forward<_Args>(__args)...); } #else template @@ -346,7 +346,7 @@ #ifndef _LIBCPP_CXX03_LANG template static void __call(_Args&&... __args) { - __invoke(_VSTD::forward<_Args>(__args)...); + __invoke(std::forward<_Args>(__args)...); } #else template @@ -384,7 +384,7 @@ public: // construct/copy/destroy _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT - : __f_(_VSTD::addressof(__f)) {} + : __f_(std::addressof(__f)) {} #ifndef _LIBCPP_CXX03_LANG private: reference_wrapper(type&&); public: // = delete; // do not bind to temps #endif @@ -399,7 +399,7 @@ _LIBCPP_INLINE_VISIBILITY typename __invoke_of::type operator() (_ArgTypes&&... __args) const { - return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...); + return __invoke(get(), std::forward<_ArgTypes>(__args)...); } #else @@ -627,7 +627,7 @@ inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &, _Args &&... __args ) { - new (__storage) _Tp (_VSTD::forward<_Args>(__args)...); + new (__storage) _Tp (std::forward<_Args>(__args)...); } // FIXME: This should have a version which takes a non-const alloc. @@ -635,7 +635,7 @@ inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) { - new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...); + new (__storage) _Tp (allocator_arg, __a, std::forward<_Args>(__args)...); } // FIXME: This should have a version which takes a non-const alloc. @@ -643,7 +643,7 @@ inline _LIBCPP_INLINE_VISIBILITY void __user_alloc_construct_impl (integral_constant, _Tp *__storage, const _Allocator &__a, _Args &&... __args ) { - new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a); + new (__storage) _Tp (std::forward<_Args>(__args)..., __a); } #endif // _LIBCPP_CXX03_LANG Index: include/__functional_base_03 =================================================================== --- include/__functional_base_03 +++ include/__functional_base_03 @@ -41,7 +41,7 @@ template struct __enable_invoke_imp<_Ret, _T1, false, false> { typedef typename add_lvalue_reference< - typename __apply_cv()), _Ret>::type + typename __apply_cv()), _Ret>::type >::type _Bullet4; typedef _Bullet4 type; }; @@ -143,7 +143,7 @@ template inline _LIBCPP_INLINE_VISIBILITY -decltype(_VSTD::declval<_Fp&>()()) +decltype(std::declval<_Fp&>()()) __invoke(_Fp& __f) { return __f(); @@ -151,7 +151,7 @@ template inline _LIBCPP_INLINE_VISIBILITY -decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>())) +decltype(std::declval<_Fp&>()(std::declval<_A0&>())) __invoke(_Fp& __f, _A0& __a0) { return __f(__a0); @@ -159,7 +159,7 @@ template inline _LIBCPP_INLINE_VISIBILITY -decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>(), _VSTD::declval<_A1&>())) +decltype(std::declval<_Fp&>()(std::declval<_A0&>(), std::declval<_A1&>())) __invoke(_Fp& __f, _A0& __a0, _A1& __a1) { return __f(__a0, __a1); @@ -167,7 +167,7 @@ template inline _LIBCPP_INLINE_VISIBILITY -decltype(_VSTD::declval<_Fp&>()(_VSTD::declval<_A0&>(), _VSTD::declval<_A1&>(), _VSTD::declval<_A2&>())) +decltype(std::declval<_Fp&>()(std::declval<_A0&>(), std::declval<_A1&>(), std::declval<_A2&>())) __invoke(_Fp& __f, _A0& __a0, _A1& __a1, _A2& __a2) { return __f(__a0, __a1, __a2); @@ -182,13 +182,13 @@ template struct __invoke_return<_Fp, false> { - typedef decltype(__invoke(_VSTD::declval<_Fp&>())) type; + typedef decltype(__invoke(std::declval<_Fp&>())) type; }; template struct __invoke_return0 { - typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>())) type; + typedef decltype(__invoke(std::declval<_Tp&>(), std::declval<_A0&>())) type; }; template @@ -200,8 +200,8 @@ template struct __invoke_return1 { - typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>(), - _VSTD::declval<_A1&>())) type; + typedef decltype(__invoke(std::declval<_Tp&>(), std::declval<_A0&>(), + std::declval<_A1&>())) type; }; template @@ -212,9 +212,9 @@ template struct __invoke_return2 { - typedef decltype(__invoke(_VSTD::declval<_Tp&>(), _VSTD::declval<_A0&>(), - _VSTD::declval<_A1&>(), - _VSTD::declval<_A2&>())) type; + typedef decltype(__invoke(std::declval<_Tp&>(), std::declval<_A0&>(), + std::declval<_A1&>(), + std::declval<_A2&>())) type; }; template Index: include/__hash_table =================================================================== --- include/__hash_table +++ include/__hash_table @@ -154,12 +154,12 @@ } _LIBCPP_INLINE_VISIBILITY static __container_value_type* __get_ptr(__node_value_type& __n) { - return _VSTD::addressof(__n); + return std::addressof(__n); } #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY static __container_value_type&& __move(__node_value_type& __v) { - return _VSTD::move(__v); + return std::move(__v); } #endif }; @@ -196,7 +196,7 @@ _LIBCPP_INLINE_VISIBILITY static __container_value_type* __get_ptr(__node_value_type& __n) { - return _VSTD::addressof(__n.__get_value()); + return std::addressof(__n.__get_value()); } #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -788,7 +788,7 @@ _LIBCPP_INLINE_VISIBILITY __bucket_list_deallocator(__bucket_list_deallocator&& __x) _NOEXCEPT_(is_nothrow_move_constructible::value) - : __data_(_VSTD::move(__x.__data_)) + : __data_(std::move(__x.__data_)) { __x.size() = 0; } @@ -1077,7 +1077,7 @@ template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique(_Pp&& __x) { - return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x), + return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>()); } @@ -1087,33 +1087,33 @@ __can_extract_map_key<_First, key_type, __container_value_type>::value, pair >::type __emplace_unique(_First&& __f, _Second&& __s) { - return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f), - _VSTD::forward<_Second>(__s)); + return __emplace_unique_key_args(__f, std::forward<_First>(__f), + std::forward<_Second>(__s)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique(_Args&&... __args) { - return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...); + return __emplace_unique_impl(std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) { - return __emplace_unique_impl(_VSTD::forward<_Pp>(__x)); + return __emplace_unique_impl(std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) { - return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x)); + return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) { - return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x)); + return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x)); } template @@ -1127,7 +1127,7 @@ _LIBCPP_INLINE_VISIBILITY pair __insert_unique(__container_value_type&& __x) { - return __emplace_unique_key_args(_NodeTypes::__get_key(__x), _VSTD::move(__x)); + return __emplace_unique_key_args(_NodeTypes::__get_key(__x), std::move(__x)); } template ::type> _LIBCPP_INLINE_VISIBILITY pair __insert_unique(_Pp&& __x) { - return __emplace_unique(_VSTD::forward<_Pp>(__x)); + return __emplace_unique(std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(_Pp&& __x) { - return __emplace_multi(_VSTD::forward<_Pp>(__x)); + return __emplace_multi(std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(const_iterator __p, _Pp&& __x) { - return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x)); + return __emplace_hint_multi(__p, std::forward<_Pp>(__x)); } #else // !defined(_LIBCPP_CXX03_LANG) @@ -1285,7 +1285,7 @@ { _LIBCPP_ASSERT(__mlf > 0, "unordered container::max_load_factor(lf) called with lf <= 0"); - max_load_factor() = _VSTD::max(__mlf, load_factor()); + max_load_factor() = std::max(__mlf, load_factor()); } _LIBCPP_INLINE_VISIBILITY @@ -1394,8 +1394,8 @@ is_nothrow_move_assignable<__node_allocator>::value) { __bucket_list_.get_deleter().__alloc() = - _VSTD::move(__u.__bucket_list_.get_deleter().__alloc()); - __node_alloc() = _VSTD::move(__u.__node_alloc()); + std::move(__u.__bucket_list_.get_deleter().__alloc()); + __node_alloc() = std::move(__u.__node_alloc()); } _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {} @@ -1486,10 +1486,10 @@ is_nothrow_move_constructible<__node_allocator>::value && is_nothrow_move_constructible::value && is_nothrow_move_constructible::value) - : __bucket_list_(_VSTD::move(__u.__bucket_list_)), - __p1_(_VSTD::move(__u.__p1_)), - __p2_(_VSTD::move(__u.__p2_)), - __p3_(_VSTD::move(__u.__p3_)) + : __bucket_list_(std::move(__u.__bucket_list_)), + __p1_(std::move(__u.__p1_)), + __p2_(std::move(__u.__p2_)), + __p3_(std::move(__u.__p3_)) { if (size() > 0) { @@ -1505,8 +1505,8 @@ const allocator_type& __a) : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)), __p1_(__second_tag(), __node_allocator(__a)), - __p2_(0, _VSTD::move(__u.hash_function())), - __p3_(_VSTD::move(__u.__p3_)) + __p2_(0, std::move(__u.hash_function())), + __p3_(std::move(__u.__p3_)) { if (__a == allocator_type(__u.__node_alloc())) { @@ -1634,9 +1634,9 @@ __u.__bucket_list_.get_deleter().size() = 0; __move_assign_alloc(__u); size() = __u.size(); - hash_function() = _VSTD::move(__u.hash_function()); + hash_function() = std::move(__u.hash_function()); max_load_factor() = __u.max_load_factor(); - key_eq() = _VSTD::move(__u.key_eq()); + key_eq() = std::move(__u.key_eq()); __p1_.first().__next_ = __u.__p1_.first().__next_; if (size() > 0) { @@ -1659,8 +1659,8 @@ __move_assign(__u, true_type()); else { - hash_function() = _VSTD::move(__u.hash_function()); - key_eq() = _VSTD::move(__u.key_eq()); + hash_function() = std::move(__u.hash_function()); + key_eq() = std::move(__u.key_eq()); max_load_factor() = __u.max_load_factor(); if (bucket_count() != 0) { @@ -1673,7 +1673,7 @@ while (__cache != nullptr && __u.size() != 0) { __cache->__upcast()->__value_ = - _VSTD::move(__u.remove(__i++)->__value_); + std::move(__u.remove(__i++)->__value_); __next_pointer __next = __cache->__next_; __node_insert_multi(__cache->__upcast()); __cache = __next; @@ -1890,7 +1890,7 @@ } if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max(2 * __bc + !__is_hash_power2(__bc), + rehash(std::max(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); } return nullptr; @@ -1966,7 +1966,7 @@ size_type __bc = bucket_count(); if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max(2 * __bc + !__is_hash_power2(__bc), + rehash(std::max(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); } @@ -2066,7 +2066,7 @@ size_type __bc = bucket_count(); if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max(2 * __bc + !__is_hash_power2(__bc), + rehash(std::max(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); } @@ -2123,13 +2123,13 @@ } { #ifndef _LIBCPP_CXX03_LANG - __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node_hash(__hash, std::forward<_Args>(__args)...); #else __node_holder __h = __construct_node_hash(__hash, __args); #endif if (size()+1 > __bc * max_load_factor() || __bc == 0) { - rehash(_VSTD::max(2 * __bc + !__is_hash_power2(__bc), + rehash(std::max(2 * __bc + !__is_hash_power2(__bc), size_type(ceil(float(size() + 1) / max_load_factor())))); __bc = bucket_count(); __chash = __constrain_hash(__hash, __bc); @@ -2172,7 +2172,7 @@ pair::iterator, bool> __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); pair __r = __node_insert_unique(__h.get()); if (__r.second) __h.release(); @@ -2184,7 +2184,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); iterator __r = __node_insert_multi(__h.get()); __h.release(); return __r; @@ -2201,7 +2201,7 @@ "unordered container::emplace_hint(const_iterator, args...) called with an iterator not" " referring to this unordered container"); #endif - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); iterator __r = __node_insert_multi(__p, __h.get()); __h.release(); return __r; @@ -2250,7 +2250,7 @@ pair __result = __node_insert_unique(__nh.__ptr_); if (__result.second) __nh.__release(); - return _InsertReturnType{__result.first, __result.second, _VSTD::move(__nh)}; + return _InsertReturnType{__result.first, __result.second, std::move(__nh)}; } template @@ -2382,7 +2382,7 @@ __rehash(__n); else if (__n < __bc) { - __n = _VSTD::max + __n = std::max ( __n, __is_hash_power2(__bc) ? __next_hash_pow2(size_t(ceil(float(size()) / max_load_factor()))) : @@ -2522,7 +2522,7 @@ "Construct cannot be called with a hash value type"); __node_allocator& __na = __node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); - __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...); + __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), std::forward<_Args>(__args)...); __h.get_deleter().__value_constructed = true; __h->__hash_ = hash_function()(__h->__value_); __h->__next_ = nullptr; @@ -2540,8 +2540,8 @@ __node_allocator& __na = __node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), - _VSTD::forward<_First>(__f), - _VSTD::forward<_Rest>(__rest)...); + std::forward<_First>(__f), + std::forward<_Rest>(__rest)...); __h.get_deleter().__value_constructed = true; __h->__hash_ = __hash; __h->__next_ = nullptr; @@ -2827,11 +2827,11 @@ __bucket_list_.reset(__u.__bucket_list_.release()); __u.__bucket_list_.reset(__npp); } - _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size()); + std::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size()); __swap_allocator(__bucket_list_.get_deleter().__alloc(), __u.__bucket_list_.get_deleter().__alloc()); __swap_allocator(__node_alloc(), __u.__node_alloc()); - _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_); + std::swap(__p1_.first().__next_, __u.__p1_.first().__next_); __p2_.swap(__u.__p2_); __p3_.swap(__u.__p3_); if (size() > 0) Index: include/__locale =================================================================== --- include/__locale +++ include/__locale @@ -212,10 +212,10 @@ locale locale::combine(const locale& __other) const { - if (!_VSTD::has_facet<_Facet>(__other)) + if (!std::has_facet<_Facet>(__other)) __throw_runtime_error("locale::combine: locale missing facet"); - return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other))); + return locale(*this, &const_cast<_Facet&>(std::use_facet<_Facet>(__other))); } template @@ -367,7 +367,7 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x, const basic_string<_CharT, _Traits, _Allocator>& __y) const { - return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare( + return std::use_facet >(*this).compare( __x.data(), __x.data() + __x.size(), __y.data(), __y.data() + __y.size()) < 0; } Index: include/__mutex_base =================================================================== --- include/__mutex_base +++ include/__mutex_base @@ -128,24 +128,24 @@ unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY explicit unique_lock(mutex_type& __m) - : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock();} + : __m_(std::addressof(__m)), __owns_(true) {__m_->lock();} _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT - : __m_(_VSTD::addressof(__m)), __owns_(false) {} + : __m_(std::addressof(__m)), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, try_to_lock_t) - : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock()) {} + : __m_(std::addressof(__m)), __owns_(__m.try_lock()) {} _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, adopt_lock_t) - : __m_(_VSTD::addressof(__m)), __owns_(true) {} + : __m_(std::addressof(__m)), __owns_(true) {} template _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t) - : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {} + : __m_(std::addressof(__m)), __owns_(__m.try_lock_until(__t)) {} template _LIBCPP_INLINE_VISIBILITY unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d) - : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {} + : __m_(std::addressof(__m)), __owns_(__m.try_lock_for(__d)) {} _LIBCPP_INLINE_VISIBILITY ~unique_lock() { @@ -190,8 +190,8 @@ _LIBCPP_INLINE_VISIBILITY void swap(unique_lock& __u) _NOEXCEPT { - _VSTD::swap(__m_, __u.__m_); - _VSTD::swap(__owns_, __u.__owns_); + std::swap(__m_, __u.__m_); + std::swap(__owns_, __u.__owns_); } _LIBCPP_INLINE_VISIBILITY mutex_type* release() _NOEXCEPT @@ -428,7 +428,7 @@ _Predicate __pred) { return wait_until(__lk, chrono::steady_clock::now() + __d, - _VSTD::move(__pred)); + std::move(__pred)); } #endif // !_LIBCPP_HAS_NO_THREADS Index: include/__node_handle =================================================================== --- include/__node_handle +++ include/__node_handle @@ -60,7 +60,7 @@ void __release() { __ptr_ = nullptr; - __alloc_ = _VSTD::nullopt; + __alloc_ = std::nullopt; } _LIBCPP_INLINE_VISIBILITY @@ -91,17 +91,17 @@ _LIBCPP_INLINE_VISIBILITY __basic_node_handle(__basic_node_handle&& __other) noexcept : __ptr_(__other.__ptr_), - __alloc_(_VSTD::move(__other.__alloc_)) + __alloc_(std::move(__other.__alloc_)) { __other.__ptr_ = nullptr; - __other.__alloc_ = _VSTD::nullopt; + __other.__alloc_ = std::nullopt; } _LIBCPP_INLINE_VISIBILITY __basic_node_handle& operator=(__basic_node_handle&& __other) { _LIBCPP_ASSERT( - __alloc_ == _VSTD::nullopt || + __alloc_ == std::nullopt || __alloc_traits::propagate_on_container_move_assignment::value || __alloc_ == __other.__alloc_, "node_type with incompatible allocator passed to " @@ -111,11 +111,11 @@ __ptr_ = __other.__ptr_; if (__alloc_traits::propagate_on_container_move_assignment::value || - __alloc_ == _VSTD::nullopt) - __alloc_ = _VSTD::move(__other.__alloc_); + __alloc_ == std::nullopt) + __alloc_ = std::move(__other.__alloc_); __other.__ptr_ = nullptr; - __other.__alloc_ = _VSTD::nullopt; + __other.__alloc_ = std::nullopt; return *this; } @@ -134,10 +134,10 @@ __alloc_traits::propagate_on_container_swap::value || __alloc_traits::is_always_equal::value) { - using _VSTD::swap; + using std::swap; swap(__ptr_, __other.__ptr_); if (__alloc_traits::propagate_on_container_swap::value || - __alloc_ == _VSTD::nullopt || __other.__alloc_ == _VSTD::nullopt) + __alloc_ == std::nullopt || __other.__alloc_ == std::nullopt) swap(__alloc_, __other.__alloc_); } Index: include/__nullptr =================================================================== --- include/__nullptr +++ include/__nullptr @@ -46,7 +46,7 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);} -#define nullptr _VSTD::__get_nullptr_t() +#define nullptr std::__get_nullptr_t() _LIBCPP_END_NAMESPACE_STD Index: include/__split_buffer =================================================================== --- include/__split_buffer +++ include/__split_buffer @@ -155,7 +155,7 @@ void __move_assign_alloc(__split_buffer& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable::value) { - __alloc() = _VSTD::move(__c.__alloc()); + __alloc() = std::move(__c.__alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -200,7 +200,7 @@ __alloc_rr& __a = this->__alloc(); do { - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_)); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_)); ++this->__end_; --__n; } while (__n > 0); @@ -219,7 +219,7 @@ __alloc_rr& __a = this->__alloc(); do { - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_), __x); ++this->__end_; --__n; } while (__n > 0); @@ -241,14 +241,14 @@ if (__end_ == __end_cap()) { size_type __old_cap = __end_cap() - __first_; - size_type __new_cap = _VSTD::max(2 * __old_cap, 8); + size_type __new_cap = std::max(2 * __old_cap, 8); __split_buffer __buf(__new_cap, 0, __a); for (pointer __p = __begin_; __p != __end_; ++__p, ++__buf.__end_) __alloc_traits::construct(__buf.__alloc(), - _VSTD::__to_raw_pointer(__buf.__end_), _VSTD::move(*__p)); + std::__to_raw_pointer(__buf.__end_), std::move(*__p)); swap(__buf); } - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_), *__first); ++this->__end_; } } @@ -265,7 +265,7 @@ __alloc_rr& __a = this->__alloc(); for (; __first != __last; ++__first) { - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_), *__first); ++this->__end_; } } @@ -348,10 +348,10 @@ template __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c) _NOEXCEPT_(is_nothrow_move_constructible::value) - : __first_(_VSTD::move(__c.__first_)), - __begin_(_VSTD::move(__c.__begin_)), - __end_(_VSTD::move(__c.__end_)), - __end_cap_(_VSTD::move(__c.__end_cap_)) + : __first_(std::move(__c.__first_)), + __begin_(std::move(__c.__begin_)), + __end_(std::move(__c.__end_)), + __end_cap_(std::move(__c.__end_cap_)) { __c.__first_ = nullptr; __c.__begin_ = nullptr; @@ -413,10 +413,10 @@ _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value|| __is_nothrow_swappable<__alloc_rr>::value) { - _VSTD::swap(__first_, __x.__first_); - _VSTD::swap(__begin_, __x.__begin_); - _VSTD::swap(__end_, __x.__end_); - _VSTD::swap(__end_cap(), __x.__end_cap()); + std::swap(__first_, __x.__first_); + std::swap(__begin_, __x.__begin_); + std::swap(__end_, __x.__end_); + std::swap(__end_cap(), __x.__end_cap()); __swap_allocator(__alloc(), __x.__alloc()); } @@ -429,10 +429,10 @@ __split_buffer __t(__n, 0, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } @@ -450,10 +450,10 @@ __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); __t.__end_ = __t.__begin_ + (__end_ - __begin_); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -473,7 +473,7 @@ { difference_type __d = __end_cap() - __end_; __d = (__d + 1) / 2; - __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d); + __begin_ = std::move_backward(__begin_, __end_, __end_ + __d); __end_ += __d; } else @@ -482,13 +482,13 @@ __split_buffer __t(__c, (__c + 3) / 4, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } - __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), __x); + __alloc_traits::construct(__alloc(), std::__to_raw_pointer(__begin_-1), __x); --__begin_; } @@ -504,7 +504,7 @@ { difference_type __d = __end_cap() - __end_; __d = (__d + 1) / 2; - __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d); + __begin_ = std::move_backward(__begin_, __end_, __end_ + __d); __end_ += __d; } else @@ -513,14 +513,14 @@ __split_buffer __t(__c, (__c + 3) / 4, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } - __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), - _VSTD::move(__x)); + __alloc_traits::construct(__alloc(), std::__to_raw_pointer(__begin_-1), + std::move(__x)); --__begin_; } @@ -537,7 +537,7 @@ { difference_type __d = __begin_ - __first_; __d = (__d + 1) / 2; - __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d); + __end_ = std::move(__begin_, __end_, __begin_ - __d); __begin_ -= __d; } else @@ -546,13 +546,13 @@ __split_buffer __t(__c, __c / 4, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } - __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), __x); + __alloc_traits::construct(__alloc(), std::__to_raw_pointer(__end_), __x); ++__end_; } @@ -568,7 +568,7 @@ { difference_type __d = __begin_ - __first_; __d = (__d + 1) / 2; - __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d); + __end_ = std::move(__begin_, __end_, __begin_ - __d); __begin_ -= __d; } else @@ -577,14 +577,14 @@ __split_buffer __t(__c, __c / 4, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } - __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), - _VSTD::move(__x)); + __alloc_traits::construct(__alloc(), std::__to_raw_pointer(__end_), + std::move(__x)); ++__end_; } @@ -599,7 +599,7 @@ { difference_type __d = __begin_ - __first_; __d = (__d + 1) / 2; - __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d); + __end_ = std::move(__begin_, __end_, __begin_ - __d); __begin_ -= __d; } else @@ -608,14 +608,14 @@ __split_buffer __t(__c, __c / 4, __alloc()); __t.__construct_at_end(move_iterator(__begin_), move_iterator(__end_)); - _VSTD::swap(__first_, __t.__first_); - _VSTD::swap(__begin_, __t.__begin_); - _VSTD::swap(__end_, __t.__end_); - _VSTD::swap(__end_cap(), __t.__end_cap()); + std::swap(__first_, __t.__first_); + std::swap(__begin_, __t.__begin_); + std::swap(__end_, __t.__end_); + std::swap(__end_cap(), __t.__end_cap()); } } - __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), - _VSTD::forward<_Args>(__args)...); + __alloc_traits::construct(__alloc(), std::__to_raw_pointer(__end_), + std::forward<_Args>(__args)...); ++__end_; } Index: include/__sso_allocator =================================================================== --- include/__sso_allocator +++ include/__sso_allocator @@ -55,14 +55,14 @@ __allocated_ = true; return (pointer)&buf_; } - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); + return static_cast(std::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) { if (__p == (pointer)&buf_) __allocated_ = false; else - _VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp)); + std::__libcpp_deallocate(__p, __n * sizeof(_Tp), __alignof(_Tp)); } _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);} Index: include/__std_stream =================================================================== --- include/__std_stream +++ include/__std_stream @@ -117,7 +117,7 @@ return __result; } char __extbuf[__limit]; - int __nread = _VSTD::max(1, __encoding_); + int __nread = std::max(1, __encoding_); for (int __i = 0; __i < __nread; ++__i) { int __c = getc(__file_); @@ -140,7 +140,7 @@ &__1buf, &__1buf + 1, __inxt); switch (__r) { - case _VSTD::codecvt_base::ok: + case std::codecvt_base::ok: break; case codecvt_base::partial: *__st_ = __sv_st; @@ -156,11 +156,11 @@ break; case codecvt_base::error: return traits_type::eof(); - case _VSTD::codecvt_base::noconv: + case std::codecvt_base::noconv: __1buf = static_cast(__extbuf[0]); break; } - } while (__r == _VSTD::codecvt_base::partial); + } while (__r == std::codecvt_base::partial); } if (!__consume) { @@ -198,9 +198,9 @@ switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt, __extbuf, __extbuf + sizeof(__extbuf), __enxt)) { - case _VSTD::codecvt_base::ok: + case std::codecvt_base::ok: break; - case _VSTD::codecvt_base::noconv: + case std::codecvt_base::noconv: __extbuf[0] = static_cast(__last_consumed_); __enxt = __extbuf + 1; break; Index: include/__string =================================================================== --- include/__string +++ include/__string @@ -732,12 +732,12 @@ __str_rfind(const _CharT *__p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT { - __pos = _VSTD::min(__pos, __sz); + __pos = std::min(__pos, __sz); if (__n < __sz - __pos) __pos += __n; else __pos = __sz; - const _CharT* __r = _VSTD::__find_end( + const _CharT* __r = std::__find_end( __p, __p + __pos, __s, __s + __n, _Traits::eq, random_access_iterator_tag(), random_access_iterator_tag()); if (__n > 0 && __r == __p + __pos) @@ -753,7 +753,7 @@ { if (__pos >= __sz || __n == 0) return __npos; - const _CharT* __r = _VSTD::__find_first_of_ce + const _CharT* __r = std::__find_first_of_ce (__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq ); if (__r == __p + __sz) return __npos; Index: include/__tree =================================================================== --- include/__tree +++ include/__tree @@ -558,12 +558,12 @@ } _LIBCPP_INLINE_VISIBILITY static __container_value_type* __get_ptr(__node_value_type& __n) { - return _VSTD::addressof(__n); + return std::addressof(__n); } #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY static __container_value_type&& __move(__node_value_type& __v) { - return _VSTD::move(__v); + return std::move(__v); } #endif }; @@ -607,7 +607,7 @@ _LIBCPP_INLINE_VISIBILITY static __container_value_type* __get_ptr(__node_value_type& __n) { - return _VSTD::addressof(__n.__get_value()); + return std::addressof(__n.__get_value()); } #ifndef _LIBCPP_CXX03_LANG @@ -1076,7 +1076,7 @@ {return static_cast<__node_pointer>(__end_node()->__left_);} __node_base_pointer* __root_ptr() const _NOEXCEPT { - return _VSTD::addressof(__end_node()->__left_); + return std::addressof(__end_node()->__left_); } typedef __tree_iterator iterator; @@ -1160,7 +1160,7 @@ template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique(_Pp&& __x) { - return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x), + return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>()); } @@ -1170,41 +1170,41 @@ __can_extract_map_key<_First, key_type, __container_value_type>::value, pair >::type __emplace_unique(_First&& __f, _Second&& __s) { - return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f), - _VSTD::forward<_Second>(__s)); + return __emplace_unique_key_args(__f, std::forward<_First>(__f), + std::forward<_Second>(__s)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique(_Args&&... __args) { - return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...); + return __emplace_unique_impl(std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) { - return __emplace_unique_impl(_VSTD::forward<_Pp>(__x)); + return __emplace_unique_impl(std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) { - return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x)); + return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY pair __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) { - return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x)); + return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) { - return __emplace_hint_unique_extract_key(__p, _VSTD::forward<_Pp>(__x), + return __emplace_hint_unique_extract_key(__p, std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>()); } @@ -1215,35 +1215,35 @@ iterator >::type __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) { return __emplace_hint_unique_key_args(__p, __f, - _VSTD::forward<_First>(__f), - _VSTD::forward<_Second>(__s)); + std::forward<_First>(__f), + std::forward<_Second>(__s)); } template _LIBCPP_INLINE_VISIBILITY iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) { - return __emplace_hint_unique_impl(__p, _VSTD::forward<_Args>(__args)...); + return __emplace_hint_unique_impl(__p, std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY iterator __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) { - return __emplace_hint_unique_impl(__p, _VSTD::forward<_Pp>(__x)); + return __emplace_hint_unique_impl(__p, std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY iterator __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) { - return __emplace_hint_unique_key_args(__p, __x, _VSTD::forward<_Pp>(__x)); + return __emplace_hint_unique_key_args(__p, __x, std::forward<_Pp>(__x)); } template _LIBCPP_INLINE_VISIBILITY iterator __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) { - return __emplace_hint_unique_key_args(__p, __x.first, _VSTD::forward<_Pp>(__x)); + return __emplace_hint_unique_key_args(__p, __x.first, std::forward<_Pp>(__x)); } #else @@ -1273,12 +1273,12 @@ #else _LIBCPP_INLINE_VISIBILITY pair __insert_unique(__container_value_type&& __v) { - return __emplace_unique_key_args(_NodeTypes::__get_key(__v), _VSTD::move(__v)); + return __emplace_unique_key_args(_NodeTypes::__get_key(__v), std::move(__v)); } _LIBCPP_INLINE_VISIBILITY iterator __insert_unique(const_iterator __p, __container_value_type&& __v) { - return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v)); + return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), std::move(__v)); } template ::type> _LIBCPP_INLINE_VISIBILITY pair __insert_unique(_Vp&& __v) { - return __emplace_unique(_VSTD::forward<_Vp>(__v)); + return __emplace_unique(std::forward<_Vp>(__v)); } template ::type> _LIBCPP_INLINE_VISIBILITY iterator __insert_unique(const_iterator __p, _Vp&& __v) { - return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v)); + return __emplace_hint_unique(__p, std::forward<_Vp>(__v)); } _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(__container_value_type&& __v) { - return __emplace_multi(_VSTD::move(__v)); + return __emplace_multi(std::move(__v)); } _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(const_iterator __p, __container_value_type&& __v) { - return __emplace_hint_multi(__p, _VSTD::move(__v)); + return __emplace_hint_multi(__p, std::move(__v)); } template _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(_Vp&& __v) { - return __emplace_multi(_VSTD::forward<_Vp>(__v)); + return __emplace_multi(std::forward<_Vp>(__v)); } template _LIBCPP_INLINE_VISIBILITY iterator __insert_multi(const_iterator __p, _Vp&& __v) { - return __emplace_hint_multi(__p, _VSTD::forward<_Vp>(__v)); + return __emplace_hint_multi(__p, std::forward<_Vp>(__v)); } #endif // !_LIBCPP_CXX03_LANG @@ -1505,7 +1505,7 @@ _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__tree& __t, true_type) _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) - {__node_alloc() = _VSTD::move(__t.__node_alloc());} + {__node_alloc() = std::move(__t.__node_alloc());} _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {} @@ -1709,9 +1709,9 @@ _NOEXCEPT_( is_nothrow_move_constructible<__node_allocator>::value && is_nothrow_move_constructible::value) - : __begin_node_(_VSTD::move(__t.__begin_node_)), - __pair1_(_VSTD::move(__t.__pair1_)), - __pair3_(_VSTD::move(__t.__pair3_)) + : __begin_node_(std::move(__t.__begin_node_)), + __pair1_(std::move(__t.__pair1_)), + __pair3_(std::move(__t.__pair3_)) { if (size() == 0) __begin_node() = __end_node(); @@ -1727,7 +1727,7 @@ template __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a) : __pair1_(__second_tag(), __node_allocator(__a)), - __pair3_(0, _VSTD::move(__t.value_comp())) + __pair3_(0, std::move(__t.value_comp())) { if (__a == __t.__alloc()) { @@ -1760,7 +1760,7 @@ __begin_node_ = __t.__begin_node_; __pair1_.first() = __t.__pair1_.first(); __move_assign_alloc(__t); - __pair3_ = _VSTD::move(__t.__pair3_); + __pair3_ = std::move(__t.__pair3_); if (size() == 0) __begin_node() = __end_node(); else @@ -1780,7 +1780,7 @@ __move_assign(__t, true_type()); else { - value_comp() = _VSTD::move(__t.value_comp()); + value_comp() = std::move(__t.value_comp()); const_iterator __e = end(); if (size() != 0) { @@ -1791,7 +1791,7 @@ #endif // _LIBCPP_NO_EXCEPTIONS while (__cache != nullptr && __t.size() != 0) { - __cache->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_); + __cache->__value_ = std::move(__t.remove(__t.begin())->__value_); __node_pointer __next = __detach(__cache); __node_insert_multi(__cache); __cache = __next; @@ -1869,7 +1869,7 @@ _NOEXCEPT_(__is_nothrow_swappable::value) #endif { - using _VSTD::swap; + using std::swap; swap(__begin_node_, __t.__begin_node_); swap(__pair1_.first(), __t.__pair1_.first()); __swap_allocator(__node_alloc(), __t.__node_alloc()); @@ -2028,7 +2028,7 @@ if (value_comp()(__v, __nd->__value_)) { if (__nd->__left_ != nullptr) { - __nd_ptr = _VSTD::addressof(__nd->__left_); + __nd_ptr = std::addressof(__nd->__left_); __nd = static_cast<__node_pointer>(__nd->__left_); } else { __parent = static_cast<__parent_pointer>(__nd); @@ -2038,7 +2038,7 @@ else if (value_comp()(__nd->__value_, __v)) { if (__nd->__right_ != nullptr) { - __nd_ptr = _VSTD::addressof(__nd->__right_); + __nd_ptr = std::addressof(__nd->__right_); __nd = static_cast<__node_pointer>(__nd->__right_); } else { __parent = static_cast<__parent_pointer>(__nd); @@ -2095,10 +2095,10 @@ else if (value_comp()(*__hint, __v)) // check after { // *__hint < __v - const_iterator __next = _VSTD::next(__hint); + const_iterator __next = std::next(__hint); if (__next == end() || value_comp()(__v, *__next)) { - // *__hint < __v < *_VSTD::next(__hint) + // *__hint < __v < *std::next(__hint) if (__hint.__get_np()->__right_ == nullptr) { __parent = static_cast<__parent_pointer>(__hint.__ptr_); @@ -2154,7 +2154,7 @@ if (__child == nullptr) { #ifndef _LIBCPP_CXX03_LANG - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); #else __node_holder __h = __construct_node(__args); #endif @@ -2187,7 +2187,7 @@ if (__child == nullptr) { #ifndef _LIBCPP_CXX03_LANG - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); #else __node_holder __h = __construct_node(__args); #endif @@ -2209,7 +2209,7 @@ "Cannot construct from __value_type"); __node_allocator& __na = __node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); - __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...); + __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), std::forward<_Args>(__args)...); __h.get_deleter().__value_constructed = true; return __h; } @@ -2220,7 +2220,7 @@ pair::iterator, bool> __tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); __parent_pointer __parent; __node_base_pointer& __child = __find_equal(__parent, __h->__value_); __node_pointer __r = static_cast<__node_pointer>(__child); @@ -2239,7 +2239,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); __parent_pointer __parent; __node_base_pointer __dummy; __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_); @@ -2257,7 +2257,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); __parent_pointer __parent; __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_)); __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get())); @@ -2270,7 +2270,7 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) { - __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); + __node_holder __h = __construct_node(std::forward<_Args>(__args)...); __parent_pointer __parent; __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_)); __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get())); @@ -2404,7 +2404,7 @@ if (__child != nullptr) return _InsertReturnType{ iterator(static_cast<__node_pointer>(__child)), - false, _VSTD::move(__nh)}; + false, std::move(__nh)}; __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr)); @@ -2650,7 +2650,7 @@ else if (value_comp()(__rt->__value_, __k)) __rt = static_cast<__node_pointer>(__rt->__right_); else - return _VSTD::distance( + return std::distance( __lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)), __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result) ); Index: include/algorithm =================================================================== --- include/algorithm +++ include/algorithm @@ -660,7 +660,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD -// I'd like to replace these with _VSTD::equal_to, but can't because: +// I'd like to replace these with std::equal_to, but can't because: // * That only works with C++14 and later, and // * We haven't included here. template @@ -769,8 +769,8 @@ template inline _LIBCPP_INLINE_VISIBILITY - decltype((void)_VSTD::declval<_Compare&>()( - _VSTD::declval<_LHS const&>(), _VSTD::declval<_RHS const&>())) + decltype((void)std::declval<_Compare&>()( + std::declval<_LHS const&>(), std::declval<_RHS const&>())) __do_compare_assert(int, _LHS const& __l, _RHS const& __r) { _LIBCPP_ASSERT(!__comp_(__l, __r), "Comparator does not induce a strict weak ordering"); @@ -1023,7 +1023,7 @@ find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { - return _VSTD::__find_end::type> + return std::__find_end::type> (__first1, __last1, __first2, __last2, __pred, typename iterator_traits<_ForwardIterator1>::iterator_category(), typename iterator_traits<_ForwardIterator2>::iterator_category()); @@ -1037,7 +1037,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; - return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); + return std::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); } // find_first_of @@ -1061,7 +1061,7 @@ find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { - return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred); + return std::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred); } template @@ -1072,7 +1072,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; - return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); + return std::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); } // adjacent_find @@ -1101,7 +1101,7 @@ adjacent_find(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type __v; - return _VSTD::adjacent_find(__first, __last, __equal_to<__v>()); + return std::adjacent_find(__first, __last, __equal_to<__v>()); } // count @@ -1153,7 +1153,7 @@ { typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator2>::value_type __v2; - return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); + return std::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>()); } #if _LIBCPP_STD_VER > 11 @@ -1178,7 +1178,7 @@ { typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator2>::value_type __v2; - return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); + return std::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); } #endif @@ -1202,7 +1202,7 @@ { typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator2>::value_type __v2; - return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); + return std::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>()); } #if _LIBCPP_STD_VER > 11 @@ -1226,9 +1226,9 @@ _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred, random_access_iterator_tag, random_access_iterator_tag ) { - if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) + if ( std::distance(__first1, __last1) != std::distance(__first2, __last2)) return false; - return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2, + return std::equal<_RandomAccessIterator1, _RandomAccessIterator2, typename add_lvalue_reference<_BinaryPredicate>::type> (__first1, __last1, __first2, __pred ); } @@ -1239,7 +1239,7 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred ) { - return _VSTD::__equal::type> + return std::__equal::type> (__first1, __last1, __first2, __last2, __pred, typename iterator_traits<_InputIterator1>::iterator_category(), typename iterator_traits<_InputIterator2>::iterator_category()); @@ -1253,7 +1253,7 @@ { typedef typename iterator_traits<_InputIterator1>::value_type __v1; typedef typename iterator_traits<_InputIterator2>::value_type __v2; - return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), + return std::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), typename iterator_traits<_InputIterator1>::iterator_category(), typename iterator_traits<_InputIterator2>::iterator_category()); } @@ -1275,10 +1275,10 @@ // __first1 != __last1 && *__first1 != *__first2 typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; - _D1 __l1 = _VSTD::distance(__first1, __last1); + _D1 __l1 = std::distance(__first1, __last1); if (__l1 == _D1(1)) return false; - _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1); + _ForwardIterator2 __last2 = std::next(__first2, __l1); // For each element in [f1, l1) see if there are the same number of // equal elements in [f2, l2) for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i) @@ -1298,7 +1298,7 @@ return false; // Count number of *__i in [__i, l1) (we can start with 1) _D1 __c1 = 1; - for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) + for (_ForwardIterator1 __j = std::next(__i); __j != __last1; ++__j) if (__pred(*__i, *__j)) ++__c1; if (__c1 != __c2) @@ -1316,7 +1316,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; - return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); + return std::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>()); } #if _LIBCPP_STD_VER > 11 @@ -1337,10 +1337,10 @@ return false; typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1; - _D1 __l1 = _VSTD::distance(__first1, __last1); + _D1 __l1 = std::distance(__first1, __last1); typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2; - _D2 __l2 = _VSTD::distance(__first2, __last2); + _D2 __l2 = std::distance(__first2, __last2); if (__l1 != __l2) return false; @@ -1363,7 +1363,7 @@ return false; // Count number of *__i in [__i, l1) (we can start with 1) _D1 __c1 = 1; - for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j) + for (_ForwardIterator1 __j = std::next(__i); __j != __last1; ++__j) if (__pred(*__i, *__j)) ++__c1; if (__c1 != __c2) @@ -1380,9 +1380,9 @@ _BinaryPredicate __pred, random_access_iterator_tag, random_access_iterator_tag ) { - if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2)) + if ( std::distance(__first1, __last1) != std::distance(__first2, __last2)) return false; - return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2, + return std::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2, typename add_lvalue_reference<_BinaryPredicate>::type> (__first1, __last1, __first2, __pred ); } @@ -1394,7 +1394,7 @@ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred ) { - return _VSTD::__is_permutation::type> + return std::__is_permutation::type> (__first1, __last1, __first2, __last2, __pred, typename iterator_traits<_ForwardIterator1>::iterator_category(), typename iterator_traits<_ForwardIterator2>::iterator_category()); @@ -1408,7 +1408,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; - return _VSTD::__is_permutation(__first1, __last1, __first2, __last2, + return std::__is_permutation(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(), typename iterator_traits<_ForwardIterator1>::iterator_category(), typename iterator_traits<_ForwardIterator2>::iterator_category()); @@ -1424,7 +1424,7 @@ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { - return _VSTD::__search::type> + return std::__search::type> (__first1, __last1, __first2, __last2, __pred, typename iterator_traits<_ForwardIterator1>::iterator_category(), typename iterator_traits<_ForwardIterator2>::iterator_category()) @@ -1439,7 +1439,7 @@ { typedef typename iterator_traits<_ForwardIterator1>::value_type __v1; typedef typename iterator_traits<_ForwardIterator2>::value_type __v2; - return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); + return std::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>()); } @@ -1535,7 +1535,7 @@ search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_, _BinaryPredicate __pred) { - return _VSTD::__search_n::type> + return std::__search_n::type> (__first, __last, __convert_to_integral(__count), __value_, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); } @@ -1546,7 +1546,7 @@ search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) { typedef typename iterator_traits<_ForwardIterator>::value_type __v; - return _VSTD::search_n(__first, __last, __convert_to_integral(__count), + return std::search_n(__first, __last, __convert_to_integral(__count), __value_, __equal_to<__v, _Tp>()); } @@ -1623,7 +1623,7 @@ { const size_t __n = static_cast(__last - __first); if (__n > 0) - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + std::memmove(__result, __first, __n * sizeof(_Up)); return __result + __n; } @@ -1632,7 +1632,7 @@ _OutputIterator copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { - return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); + return std::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); } // copy_backward @@ -1661,7 +1661,7 @@ if (__n > 0) { __result -= __n; - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + std::memmove(__result, __first, __n * sizeof(_Up)); } return __result; } @@ -1672,7 +1672,7 @@ copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) { - return _VSTD::__copy_backward(__unwrap_iter(__first), + return std::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); } @@ -1735,7 +1735,7 @@ { typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize; _IntegralSize __n = __orig_n; - return _VSTD::copy(__first, __first + __n, __result); + return std::copy(__first, __first + __n, __result); } // move @@ -1746,7 +1746,7 @@ __move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { for (; __first != __last; ++__first, (void) ++__result) - *__result = _VSTD::move(*__first); + *__result = std::move(*__first); return __result; } @@ -1762,7 +1762,7 @@ { const size_t __n = static_cast(__last - __first); if (__n > 0) - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + std::memmove(__result, __first, __n * sizeof(_Up)); return __result + __n; } @@ -1771,7 +1771,7 @@ _OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { - return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); + return std::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); } // move_backward @@ -1782,7 +1782,7 @@ __move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { while (__first != __last) - *--__result = _VSTD::move(*--__last); + *--__result = std::move(*--__last); return __result; } @@ -1800,7 +1800,7 @@ if (__n > 0) { __result -= __n; - _VSTD::memmove(__result, __first, __n * sizeof(_Up)); + std::memmove(__result, __first, __n * sizeof(_Up)); } return __result; } @@ -1811,7 +1811,7 @@ move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) { - return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); + return std::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result)); } // iter_swap @@ -1914,7 +1914,7 @@ _OutputIterator fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_) { - return _VSTD::__fill_n(__first, __convert_to_integral(__n), __value_); + return std::__fill_n(__first, __convert_to_integral(__n), __value_); } // fill @@ -1933,7 +1933,7 @@ void __fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag) { - _VSTD::fill_n(__first, __last - __first, __value_); + std::fill_n(__first, __last - __first, __value_); } template @@ -1941,7 +1941,7 @@ void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - _VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); + std::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category()); } // generate @@ -1975,7 +1975,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - __first = _VSTD::find(__first, __last, __value_); + __first = std::find(__first, __last, __value_); if (__first != __last) { _ForwardIterator __i = __first; @@ -1983,7 +1983,7 @@ { if (!(*__i == __value_)) { - *__first = _VSTD::move(*__i); + *__first = std::move(*__i); ++__first; } } @@ -1997,7 +1997,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { - __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> + __first = std::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type> (__first, __last, __pred); if (__first != __last) { @@ -2006,7 +2006,7 @@ { if (!__pred(*__i)) { - *__first = _VSTD::move(*__i); + *__first = std::move(*__i); ++__first; } } @@ -2056,7 +2056,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { - __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> + __first = std::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type> (__first, __last, __pred); if (__first != __last) { @@ -2065,7 +2065,7 @@ _ForwardIterator __i = __first; for (++__i; ++__i != __last;) if (!__pred(*__first, *__i)) - *++__first = _VSTD::move(*__i); + *++__first = std::move(*__i); ++__first; } return __first; @@ -2077,7 +2077,7 @@ unique(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type __v; - return _VSTD::unique(__first, __last, __equal_to<__v>()); + return std::unique(__first, __last, __equal_to<__v>()); } // unique_copy @@ -2149,7 +2149,7 @@ _OutputIterator unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred) { - return _VSTD::__unique_copy::type> + return std::__unique_copy::type> (__first, __last, __result, __pred, typename iterator_traits<_InputIterator>::iterator_category(), typename iterator_traits<_OutputIterator>::iterator_category()); @@ -2161,7 +2161,7 @@ unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type __v; - return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>()); + return std::unique_copy(__first, __last, __result, __equal_to<__v>()); } // reverse @@ -2175,7 +2175,7 @@ { if (__first == --__last) break; - _VSTD::iter_swap(__first, __last); + std::iter_swap(__first, __last); ++__first; } } @@ -2187,7 +2187,7 @@ { if (__first != __last) for (; __first < --__last; ++__first) - _VSTD::iter_swap(__first, __last); + std::iter_swap(__first, __last); } template @@ -2195,7 +2195,7 @@ void reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) { - _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); + std::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category()); } // reverse_copy @@ -2217,9 +2217,9 @@ __rotate_left(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type value_type; - value_type __tmp = _VSTD::move(*__first); - _ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first); - *__lm1 = _VSTD::move(__tmp); + value_type __tmp = std::move(*__first); + _ForwardIterator __lm1 = std::move(std::next(__first), __last, __first); + *__lm1 = std::move(__tmp); return __lm1; } @@ -2228,10 +2228,10 @@ __rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) { typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; - _BidirectionalIterator __lm1 = _VSTD::prev(__last); - value_type __tmp = _VSTD::move(*__lm1); - _BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last); - *__first = _VSTD::move(__tmp); + _BidirectionalIterator __lm1 = std::prev(__last); + value_type __tmp = std::move(*__lm1); + _BidirectionalIterator __fp1 = std::move_backward(__first, __lm1, __last); + *__first = std::move(__tmp); return __fp1; } @@ -2295,18 +2295,18 @@ const difference_type __m2 = __last - __middle; if (__m1 == __m2) { - _VSTD::swap_ranges(__first, __middle, __middle); + std::swap_ranges(__first, __middle, __middle); return __middle; } - const difference_type __g = _VSTD::__algo_gcd(__m1, __m2); + const difference_type __g = std::__algo_gcd(__m1, __m2); for (_RandomAccessIterator __p = __first + __g; __p != __first;) { - value_type __t(_VSTD::move(*--__p)); + value_type __t(std::move(*--__p)); _RandomAccessIterator __p1 = __p; _RandomAccessIterator __p2 = __p1 + __m1; do { - *__p1 = _VSTD::move(*__p2); + *__p1 = std::move(*__p2); __p1 = __p2; const difference_type __d = __last - __p2; if (__m1 < __d) @@ -2314,7 +2314,7 @@ else __p2 = __first + (__m1 - __d); } while (__p2 != __p); - *__p1 = _VSTD::move(__t); + *__p1 = std::move(__t); } return __first + __m2; } @@ -2323,50 +2323,50 @@ inline _LIBCPP_INLINE_VISIBILITY _ForwardIterator __rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, - _VSTD::forward_iterator_tag) + std::forward_iterator_tag) { - typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type; - if (_VSTD::is_trivially_move_assignable::value) + typedef typename std::iterator_traits<_ForwardIterator>::value_type value_type; + if (std::is_trivially_move_assignable::value) { - if (_VSTD::next(__first) == __middle) - return _VSTD::__rotate_left(__first, __last); + if (std::next(__first) == __middle) + return std::__rotate_left(__first, __last); } - return _VSTD::__rotate_forward(__first, __middle, __last); + return std::__rotate_forward(__first, __middle, __last); } template inline _LIBCPP_INLINE_VISIBILITY _BidirectionalIterator __rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, - _VSTD::bidirectional_iterator_tag) + std::bidirectional_iterator_tag) { - typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type; - if (_VSTD::is_trivially_move_assignable::value) + typedef typename std::iterator_traits<_BidirectionalIterator>::value_type value_type; + if (std::is_trivially_move_assignable::value) { - if (_VSTD::next(__first) == __middle) - return _VSTD::__rotate_left(__first, __last); - if (_VSTD::next(__middle) == __last) - return _VSTD::__rotate_right(__first, __last); + if (std::next(__first) == __middle) + return std::__rotate_left(__first, __last); + if (std::next(__middle) == __last) + return std::__rotate_right(__first, __last); } - return _VSTD::__rotate_forward(__first, __middle, __last); + return std::__rotate_forward(__first, __middle, __last); } template inline _LIBCPP_INLINE_VISIBILITY _RandomAccessIterator __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, - _VSTD::random_access_iterator_tag) + std::random_access_iterator_tag) { - typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type; - if (_VSTD::is_trivially_move_assignable::value) + typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type; + if (std::is_trivially_move_assignable::value) { - if (_VSTD::next(__first) == __middle) - return _VSTD::__rotate_left(__first, __last); - if (_VSTD::next(__middle) == __last) - return _VSTD::__rotate_right(__first, __last); - return _VSTD::__rotate_gcd(__first, __middle, __last); + if (std::next(__first) == __middle) + return std::__rotate_left(__first, __last); + if (std::next(__middle) == __last) + return std::__rotate_right(__first, __last); + return std::__rotate_gcd(__first, __middle, __last); } - return _VSTD::__rotate_forward(__first, __middle, __last); + return std::__rotate_forward(__first, __middle, __last); } template @@ -2378,8 +2378,8 @@ return __last; if (__middle == __last) return __first; - return _VSTD::__rotate(__first, __middle, __last, - typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category()); + return std::__rotate(__first, __middle, __last, + typename std::iterator_traits<_ForwardIterator>::iterator_category()); } // rotate_copy @@ -2389,7 +2389,7 @@ _OutputIterator rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) { - return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result)); + return std::copy(__first, __middle, std::copy(__middle, __last, __result)); } // min_element @@ -2416,7 +2416,7 @@ _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last) { - return _VSTD::min_element(__first, __last, + return std::min_element(__first, __last, __less::value_type>()); } @@ -2435,7 +2435,7 @@ const _Tp& min(const _Tp& __a, const _Tp& __b) { - return _VSTD::min(__a, __b, __less<_Tp>()); + return std::min(__a, __b, __less<_Tp>()); } #ifndef _LIBCPP_CXX03_LANG @@ -2445,7 +2445,7 @@ _Tp min(initializer_list<_Tp> __t, _Compare __comp) { - return *_VSTD::min_element(__t.begin(), __t.end(), __comp); + return *std::min_element(__t.begin(), __t.end(), __comp); } template @@ -2453,7 +2453,7 @@ _Tp min(initializer_list<_Tp> __t) { - return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>()); + return *std::min_element(__t.begin(), __t.end(), __less<_Tp>()); } #endif // _LIBCPP_CXX03_LANG @@ -2483,7 +2483,7 @@ _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last) { - return _VSTD::max_element(__first, __last, + return std::max_element(__first, __last, __less::value_type>()); } @@ -2502,7 +2502,7 @@ const _Tp& max(const _Tp& __a, const _Tp& __b) { - return _VSTD::max(__a, __b, __less<_Tp>()); + return std::max(__a, __b, __less<_Tp>()); } #ifndef _LIBCPP_CXX03_LANG @@ -2512,7 +2512,7 @@ _Tp max(initializer_list<_Tp> __t, _Compare __comp) { - return *_VSTD::max_element(__t.begin(), __t.end(), __comp); + return *std::max_element(__t.begin(), __t.end(), __comp); } template @@ -2520,7 +2520,7 @@ _Tp max(initializer_list<_Tp> __t) { - return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>()); + return *std::max_element(__t.begin(), __t.end(), __less<_Tp>()); } #endif // _LIBCPP_CXX03_LANG @@ -2542,7 +2542,7 @@ const _Tp& clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi) { - return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>()); + return std::clamp(__v, __lo, __hi, __less<_Tp>()); } #endif @@ -2603,7 +2603,7 @@ std::pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) { - return _VSTD::minmax_element(__first, __last, + return std::minmax_element(__first, __last, __less::value_type>()); } @@ -2623,7 +2623,7 @@ pair minmax(const _Tp& __a, const _Tp& __b) { - return _VSTD::minmax(__a, __b, __less<_Tp>()); + return std::minmax(__a, __b, __less<_Tp>()); } #ifndef _LIBCPP_CXX03_LANG @@ -2670,7 +2670,7 @@ pair<_Tp, _Tp> minmax(initializer_list<_Tp> __t) { - return _VSTD::minmax(__t, __less<_Tp>()); + return std::minmax(__t, __less<_Tp>()); } #endif // _LIBCPP_CXX03_LANG @@ -3010,11 +3010,11 @@ __output_iter[__k] = *__first; _Distance __sz = __k; for (; __first != __last; ++__first, (void)++__k) { - _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g); + _Distance __r = std::uniform_int_distribution<_Distance>(0, __k)(__g); if (__r < __sz) __output_iter[__r] = *__first; } - return __output_iter + _VSTD::min(__n, __k); + return __output_iter + std::min(__n, __k); } template (0, --__unsampled_sz)(__g); + std::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g); if (__r < __n) { *__output_iter++ = *__first; --__n; @@ -3052,7 +3052,7 @@ "SampleIterator must meet the requirements of RandomAccessIterator"); typedef typename common_type<_Distance, _Difference>::type _CommonType; _LIBCPP_ASSERT(__n >= 0, "N must be a positive number."); - return _VSTD::__sample( + return std::__sample( __first, __last, __output_iter, _CommonType(__n), __g, _PopCategory()); } @@ -3064,7 +3064,7 @@ _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, _SampleIterator __output_iter, _Distance __n, _UniformRandomNumberGenerator&& __g) { - return _VSTD::__sample(__first, __last, __output_iter, __n, __g); + return std::__sample(__first, __last, __output_iter, __n, __g); } #endif // _LIBCPP_STD_VER > 14 @@ -3163,7 +3163,7 @@ _ForwardIterator partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { - return _VSTD::__partition::type> + return std::__partition::type> (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category()); } @@ -3199,12 +3199,12 @@ partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; - difference_type __len = _VSTD::distance(__first, __last); + difference_type __len = std::distance(__first, __last); while (__len != 0) { difference_type __l2 = __len / 2; _ForwardIterator __m = __first; - _VSTD::advance(__m, __l2); + std::advance(__m, __l2); if (__pred(*__m)) { __first = ++__m; @@ -3245,7 +3245,7 @@ // Move the falses into the temporary buffer, and the trues to the front of the line // Update __first to always point to the end of the trues value_type* __t = __p.first; - ::new(__t) value_type(_VSTD::move(*__first)); + ::new(__t) value_type(std::move(*__first)); __d.__incr((value_type*)0); ++__t; _ForwardIterator __i = __first; @@ -3253,12 +3253,12 @@ { if (__pred(*__i)) { - *__first = _VSTD::move(*__i); + *__first = std::move(*__i); ++__first; } else { - ::new(__t) value_type(_VSTD::move(*__i)); + ::new(__t) value_type(std::move(*__i)); __d.__incr((value_type*)0); ++__t; } @@ -3267,7 +3267,7 @@ // Move falses back into range, but don't mess up __first which points to first false __i = __first; for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) - *__i = _VSTD::move(*__t2); + *__i = std::move(*__t2); // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer return __first; } @@ -3275,7 +3275,7 @@ // __len >= 3 _ForwardIterator __m = __first; _Distance __len2 = __len / 2; // __len2 >= 2 - _VSTD::advance(__m, __len2); + std::advance(__m, __len2); // recurse on [__first, __m), *__first know to be false // F????????????????? // f m l @@ -3299,7 +3299,7 @@ __second_half_done: // TTTFFFFFTTTTTFFFFF // f ff m sf l - return _VSTD::rotate(__first_false, __m, __second_false); + return std::rotate(__first_false, __m, __second_false); // TTTTTTTTFFFFFFFFFF // | } @@ -3307,7 +3307,7 @@ struct __return_temporary_buffer { template - _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);} + _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {std::return_temporary_buffer(__p);} }; template @@ -3329,12 +3329,12 @@ // *__first is known to be false typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; typedef typename iterator_traits<_ForwardIterator>::value_type value_type; - difference_type __len = _VSTD::distance(__first, __last); + difference_type __len = std::distance(__first, __last); pair __p(0, 0); unique_ptr __h; if (__len >= __alloc_limit) { - __p = _VSTD::get_temporary_buffer(__len); + __p = std::get_temporary_buffer(__len); __h.reset(__p.first); } return __stable_partition::type> @@ -3375,7 +3375,7 @@ // Move the falses into the temporary buffer, and the trues to the front of the line // Update __first to always point to the end of the trues value_type* __t = __p.first; - ::new(__t) value_type(_VSTD::move(*__first)); + ::new(__t) value_type(std::move(*__first)); __d.__incr((value_type*)0); ++__t; _BidirectionalIterator __i = __first; @@ -3383,23 +3383,23 @@ { if (__pred(*__i)) { - *__first = _VSTD::move(*__i); + *__first = std::move(*__i); ++__first; } else { - ::new(__t) value_type(_VSTD::move(*__i)); + ::new(__t) value_type(std::move(*__i)); __d.__incr((value_type*)0); ++__t; } } // move *__last, known to be true - *__first = _VSTD::move(*__i); + *__first = std::move(*__i); __i = ++__first; // All trues now at start of range, all falses in buffer // Move falses back into range, but don't mess up __first which points to first false for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i) - *__i = _VSTD::move(*__t2); + *__i = std::move(*__t2); // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer return __first; } @@ -3407,7 +3407,7 @@ // __len >= 4 _BidirectionalIterator __m = __first; _Distance __len2 = __len / 2; // __len2 >= 2 - _VSTD::advance(__m, __len2); + std::advance(__m, __len2); // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false // F????????????????T // f m l @@ -3444,7 +3444,7 @@ __second_half_done: // TTTFFFFFTTTTTFFFFF // f ff m sf l - return _VSTD::rotate(__first_false, __m, __second_false); + return std::rotate(__first_false, __m, __second_false); // TTTTTTTTFFFFFFFFFF // | } @@ -3477,12 +3477,12 @@ // *__first is known to be false // *__last is known to be true // __len >= 2 - difference_type __len = _VSTD::distance(__first, __last) + 1; + difference_type __len = std::distance(__first, __last) + 1; pair __p(0, 0); unique_ptr __h; if (__len >= __alloc_limit) { - __p = _VSTD::get_temporary_buffer(__len); + __p = std::get_temporary_buffer(__len); __h.reset(__p.first); } return __stable_partition::type> @@ -3522,7 +3522,7 @@ _ForwardIterator is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) { - return _VSTD::is_sorted_until(__first, __last, __less::value_type>()); + return std::is_sorted_until(__first, __last, __less::value_type>()); } // is_sorted @@ -3532,7 +3532,7 @@ bool is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { - return _VSTD::is_sorted_until(__first, __last, __comp) == __last; + return std::is_sorted_until(__first, __last, __comp) == __last; } template @@ -3540,7 +3540,7 @@ bool is_sorted(_ForwardIterator __first, _ForwardIterator __last) { - return _VSTD::is_sorted(__first, __last, __less::value_type>()); + return std::is_sorted(__first, __last, __less::value_type>()); } // sort @@ -3648,7 +3648,7 @@ _BirdirectionalIterator __lm1 = __last; for (--__lm1; __first != __lm1; ++__first) { - _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator, + _BirdirectionalIterator __i = std::min_element<_BirdirectionalIterator, typename add_lvalue_reference<_Compare>::type> (__first, __last, __comp); if (__i != __first) @@ -3667,10 +3667,10 @@ for (++__i; __i != __last; ++__i) { _BirdirectionalIterator __j = __i; - value_type __t(_VSTD::move(*__j)); + value_type __t(std::move(*__j)); for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j) - *__j = _VSTD::move(*__k); - *__j = _VSTD::move(__t); + *__j = std::move(*__k); + *__j = std::move(__t); } } } @@ -3686,15 +3686,15 @@ { if (__comp(*__i, *__j)) { - value_type __t(_VSTD::move(*__i)); + value_type __t(std::move(*__i)); _RandomAccessIterator __k = __j; __j = __i; do { - *__j = _VSTD::move(*__k); + *__j = std::move(*__k); __j = __k; } while (__j != __first && __comp(__t, *--__k)); - *__j = _VSTD::move(__t); + *__j = std::move(__t); } __j = __i; } @@ -3714,13 +3714,13 @@ swap(*__first, *__last); return true; case 3: - _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); + std::__sort3<_Compare>(__first, __first+1, --__last, __comp); return true; case 4: - _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); + std::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); return true; case 5: - _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); + std::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); return true; } typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; @@ -3732,15 +3732,15 @@ { if (__comp(*__i, *__j)) { - value_type __t(_VSTD::move(*__i)); + value_type __t(std::move(*__i)); _RandomAccessIterator __k = __j; __j = __i; do { - *__j = _VSTD::move(*__k); + *__j = std::move(*__k); __j = __k; } while (__j != __first && __comp(__t, *--__k)); - *__j = _VSTD::move(__t); + *__j = std::move(__t); if (++__count == __limit) return ++__i == __last; } @@ -3760,7 +3760,7 @@ __destruct_n __d(0); unique_ptr __h(__first2, __d); value_type* __last2 = __first2; - ::new(__last2) value_type(_VSTD::move(*__first1)); + ::new(__last2) value_type(std::move(*__first1)); __d.__incr((value_type*)0); for (++__last2; ++__first1 != __last1; ++__last2) { @@ -3768,15 +3768,15 @@ value_type* __i2 = __j2; if (__comp(*__first1, *--__i2)) { - ::new(__j2) value_type(_VSTD::move(*__i2)); + ::new(__j2) value_type(std::move(*__i2)); __d.__incr((value_type*)0); for (--__j2; __i2 != __first2 && __comp(*__first1, *--__i2); --__j2) - *__j2 = _VSTD::move(*__i2); - *__j2 = _VSTD::move(*__first1); + *__j2 = std::move(*__i2); + *__j2 = std::move(*__first1); } else { - ::new(__j2) value_type(_VSTD::move(*__first1)); + ::new(__j2) value_type(std::move(*__first1)); __d.__incr((value_type*)0); } } @@ -3807,18 +3807,18 @@ swap(*__first, *__last); return; case 3: - _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp); + std::__sort3<_Compare>(__first, __first+1, --__last, __comp); return; case 4: - _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); + std::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp); return; case 5: - _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); + std::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp); return; } if (__len <= __limit) { - _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp); + std::__insertion_sort_3<_Compare>(__first, __last, __comp); return; } // __len > 5 @@ -3833,13 +3833,13 @@ __delta = __len/2; __m += __delta; __delta /= 2; - __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); + __n_swaps = std::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp); } else { __delta = __len/2; __m += __delta; - __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp); + __n_swaps = std::__sort3<_Compare>(__first, __m, __lm1, __comp); } } // *__m is median @@ -3895,7 +3895,7 @@ } // [__first, __i) == *__first and *__first < [__i, __last) // The first part is sorted, sort the secod part - // _VSTD::__sort<_Compare>(__i, __last, __comp); + // std::__sort<_Compare>(__i, __last, __comp); __first = __i; goto __restart; } @@ -3944,8 +3944,8 @@ // If we were given a perfect partition, see if insertion sort is quick... if (__n_swaps == 0) { - bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); - if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) + bool __fs = std::__insertion_sort_incomplete<_Compare>(__first, __i, __comp); + if (std::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp)) { if (__fs) return; @@ -3964,14 +3964,14 @@ // sort smaller range with recursive call and larger with tail recursion elimination if (__i - __first < __last - __i) { - _VSTD::__sort<_Compare>(__first, __i, __comp); - // _VSTD::__sort<_Compare>(__i+1, __last, __comp); + std::__sort<_Compare>(__first, __i, __comp); + // std::__sort<_Compare>(__i+1, __last, __comp); __first = ++__i; } else { - _VSTD::__sort<_Compare>(__i+1, __last, __comp); - // _VSTD::__sort<_Compare>(__first, __i, __comp); + std::__sort<_Compare>(__i+1, __last, __comp); + // std::__sort<_Compare>(__first, __i, __comp); __last = __i; } } @@ -3998,7 +3998,7 @@ void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::sort(__first, __last, __less::value_type>()); + std::sort(__first, __last, __less::value_type>()); } template @@ -4006,7 +4006,7 @@ void sort(_Tp** __first, _Tp** __last) { - _VSTD::sort((size_t*)__first, (size_t*)__last, __less()); + std::sort((size_t*)__first, (size_t*)__last, __less()); } template @@ -4014,7 +4014,7 @@ void sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last) { - _VSTD::sort(__first.base(), __last.base()); + std::sort(__first.base(), __last.base()); } template @@ -4023,7 +4023,7 @@ sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last, _Compare __comp) { typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; - _VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); + std::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp); } _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less&, char*>(char*, char*, __less&)) @@ -4067,12 +4067,12 @@ __lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; - difference_type __len = _VSTD::distance(__first, __last); + difference_type __len = std::distance(__first, __last); while (__len != 0) { difference_type __l2 = __len / 2; _ForwardIterator __m = __first; - _VSTD::advance(__m, __l2); + std::advance(__m, __l2); if (__comp(*__m, __value_)) { __first = ++__m; @@ -4098,7 +4098,7 @@ _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - return _VSTD::lower_bound(__first, __last, __value_, + return std::lower_bound(__first, __last, __value_, __less::value_type, _Tp>()); } @@ -4109,12 +4109,12 @@ __upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; - difference_type __len = _VSTD::distance(__first, __last); + difference_type __len = std::distance(__first, __last); while (__len != 0) { difference_type __l2 = __len / 2; _ForwardIterator __m = __first; - _VSTD::advance(__m, __l2); + std::advance(__m, __l2); if (__comp(__value_, *__m)) __len = __l2; else @@ -4140,7 +4140,7 @@ _ForwardIterator upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - return _VSTD::upper_bound(__first, __last, __value_, + return std::upper_bound(__first, __last, __value_, __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>()); } @@ -4151,12 +4151,12 @@ __equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type; - difference_type __len = _VSTD::distance(__first, __last); + difference_type __len = std::distance(__first, __last); while (__len != 0) { difference_type __l2 = __len / 2; _ForwardIterator __m = __first; - _VSTD::advance(__m, __l2); + std::advance(__m, __l2); if (__comp(*__m, __value_)) { __first = ++__m; @@ -4200,7 +4200,7 @@ pair<_ForwardIterator, _ForwardIterator> equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - return _VSTD::equal_range(__first, __last, __value_, + return std::equal_range(__first, __last, __value_, __less::value_type, _Tp>()); } @@ -4235,7 +4235,7 @@ bool binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) { - return _VSTD::binary_search(__first, __last, __value_, + return std::binary_search(__first, __last, __value_, __less::value_type, _Tp>()); } @@ -4249,7 +4249,7 @@ for (; __first1 != __last1; ++__result) { if (__first2 == __last2) - return _VSTD::copy(__first1, __last1, __result); + return std::copy(__first1, __last1, __result); if (__comp(*__first2, *__first1)) { *__result = *__first2; @@ -4261,7 +4261,7 @@ ++__first1; } } - return _VSTD::copy(__first2, __last2, __result); + return std::copy(__first2, __last2, __result); } template @@ -4273,10 +4273,10 @@ #ifdef _LIBCPP_DEBUG typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; __debug_less<_Compare> __c(__comp); - return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); + return std::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c); #else // _LIBCPP_DEBUG typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; - return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); + return std::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp); #endif // _LIBCPP_DEBUG } @@ -4303,18 +4303,18 @@ { if (__first2 == __last2) { - _VSTD::move(__first1, __last1, __result); + std::move(__first1, __last1, __result); return; } if (__comp(*__first2, *__first1)) { - *__result = _VSTD::move(*__first2); + *__result = std::move(*__first2); ++__first2; } else { - *__result = _VSTD::move(*__first1); + *__result = std::move(*__first1); ++__first1; } } @@ -4335,14 +4335,14 @@ { value_type* __p = __buff; for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p) - ::new(__p) value_type(_VSTD::move(*__i)); + ::new(__p) value_type(std::move(*__i)); __half_inplace_merge(__buff, __p, __middle, __last, __first, __comp); } else { value_type* __p = __buff; for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, ++__p) - ::new(__p) value_type(_VSTD::move(*__i)); + ::new(__p) value_type(std::move(*__i)); typedef reverse_iterator<_BidirectionalIterator> _RBi; typedef reverse_iterator _Rv; __half_inplace_merge(_Rv(__p), _Rv(__buff), @@ -4392,9 +4392,9 @@ { // __len >= 1, __len2 >= 2 __len21 = __len2 / 2; __m2 = __middle; - _VSTD::advance(__m2, __len21); + std::advance(__m2, __len21); __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp); - __len11 = _VSTD::distance(__first, __m1); + __len11 = std::distance(__first, __m1); } else { @@ -4407,15 +4407,15 @@ // __len1 >= 2, __len2 >= 1 __len11 = __len1 / 2; __m1 = __first; - _VSTD::advance(__m1, __len11); + std::advance(__m1, __len11); __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp); - __len21 = _VSTD::distance(__middle, __m2); + __len21 = std::distance(__middle, __m2); } difference_type __len12 = __len1 - __len11; // distance(__m1, __middle) difference_type __len22 = __len2 - __len21; // distance(__m2, __last) // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) // swap middle two partitions - __middle = _VSTD::rotate(__m1, __middle, __m2); + __middle = std::rotate(__m1, __middle, __m2); // __len12 and __len21 now have swapped meanings // merge smaller range with recurisve call and larger with tail recursion elimination if (__len11 + __len21 < __len12 + __len22) @@ -4447,20 +4447,20 @@ { typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type; typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type; - difference_type __len1 = _VSTD::distance(__first, __middle); - difference_type __len2 = _VSTD::distance(__middle, __last); - difference_type __buf_size = _VSTD::min(__len1, __len2); - pair __buf = _VSTD::get_temporary_buffer(__buf_size); + difference_type __len1 = std::distance(__first, __middle); + difference_type __len2 = std::distance(__middle, __last); + difference_type __buf_size = std::min(__len1, __len2); + pair __buf = std::get_temporary_buffer(__buf_size); unique_ptr __h(__buf.first); #ifdef _LIBCPP_DEBUG typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref; __debug_less<_Compare> __c(__comp); - return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, + return std::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2, __buf.first, __buf.second); #else // _LIBCPP_DEBUG typedef typename add_lvalue_reference<_Compare>::type _Comp_ref; - return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, + return std::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2, __buf.first, __buf.second); #endif // _LIBCPP_DEBUG } @@ -4470,7 +4470,7 @@ void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { - _VSTD::inplace_merge(__first, __middle, __last, + std::inplace_merge(__first, __middle, __last, __less::value_type>()); } @@ -4490,26 +4490,26 @@ if (__first1 == __last1) { for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0)) - ::new (__result) value_type(_VSTD::move(*__first2)); + ::new (__result) value_type(std::move(*__first2)); __h.release(); return; } if (__first2 == __last2) { for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0)) - ::new (__result) value_type(_VSTD::move(*__first1)); + ::new (__result) value_type(std::move(*__first1)); __h.release(); return; } if (__comp(*__first2, *__first1)) { - ::new (__result) value_type(_VSTD::move(*__first2)); + ::new (__result) value_type(std::move(*__first2)); __d.__incr((value_type*)0); ++__first2; } else { - ::new (__result) value_type(_VSTD::move(*__first1)); + ::new (__result) value_type(std::move(*__first1)); __d.__incr((value_type*)0); ++__first1; } @@ -4527,22 +4527,22 @@ if (__first2 == __last2) { for (; __first1 != __last1; ++__first1, ++__result) - *__result = _VSTD::move(*__first1); + *__result = std::move(*__first1); return; } if (__comp(*__first2, *__first1)) { - *__result = _VSTD::move(*__first2); + *__result = std::move(*__first2); ++__first2; } else { - *__result = _VSTD::move(*__first1); + *__result = std::move(*__first1); ++__first1; } } for (; __first2 != __last2; ++__first2, ++__result) - *__result = _VSTD::move(*__first2); + *__result = std::move(*__first2); } template @@ -4563,24 +4563,24 @@ case 0: return; case 1: - ::new(__first2) value_type(_VSTD::move(*__first1)); + ::new(__first2) value_type(std::move(*__first1)); return; case 2: __destruct_n __d(0); unique_ptr __h2(__first2, __d); if (__comp(*--__last1, *__first1)) { - ::new(__first2) value_type(_VSTD::move(*__last1)); + ::new(__first2) value_type(std::move(*__last1)); __d.__incr((value_type*)0); ++__first2; - ::new(__first2) value_type(_VSTD::move(*__first1)); + ::new(__first2) value_type(std::move(*__first1)); } else { - ::new(__first2) value_type(_VSTD::move(*__first1)); + ::new(__first2) value_type(std::move(*__first1)); __d.__incr((value_type*)0); ++__first2; - ::new(__first2) value_type(_VSTD::move(*__last1)); + ::new(__first2) value_type(std::move(*__last1)); } __h2.release(); return; @@ -4661,7 +4661,7 @@ unique_ptr __h; if (__len > static_cast(__stable_sort_switch::value)) { - __buf = _VSTD::get_temporary_buffer(__len); + __buf = std::get_temporary_buffer(__len); __h.reset(__buf.first); } #ifdef _LIBCPP_DEBUG @@ -4679,7 +4679,7 @@ void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::stable_sort(__first, __last, __less::value_type>()); + std::stable_sort(__first, __last, __less::value_type>()); } // is_heap_until @@ -4688,7 +4688,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { - typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type; + typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type; difference_type __len = __last - __first; difference_type __p = 0; difference_type __c = 1; @@ -4716,7 +4716,7 @@ _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) { - return _VSTD::is_heap_until(__first, __last, __less::value_type>()); + return std::is_heap_until(__first, __last, __less::value_type>()); } // is_heap @@ -4726,7 +4726,7 @@ bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { - return _VSTD::is_heap_until(__first, __last, __comp) == __last; + return std::is_heap_until(__first, __last, __comp) == __last; } template @@ -4734,7 +4734,7 @@ bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { - return _VSTD::is_heap(__first, __last, __less::value_type>()); + return std::is_heap(__first, __last, __less::value_type>()); } // push_heap @@ -4751,17 +4751,17 @@ _RandomAccessIterator __ptr = __first + __len; if (__comp(*__ptr, *--__last)) { - value_type __t(_VSTD::move(*__last)); + value_type __t(std::move(*__last)); do { - *__last = _VSTD::move(*__ptr); + *__last = std::move(*__ptr); __last = __ptr; if (__len == 0) break; __len = (__len - 1) / 2; __ptr = __first + __len; } while (__comp(*__ptr, __t)); - *__last = _VSTD::move(__t); + *__last = std::move(__t); } } } @@ -4786,7 +4786,7 @@ void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::push_heap(__first, __last, __less::value_type>()); + std::push_heap(__first, __last, __less::value_type>()); } // pop_heap @@ -4821,11 +4821,11 @@ // we are, __start is larger than it's largest child return; - value_type __top(_VSTD::move(*__start)); + value_type __top(std::move(*__start)); do { // we are not in heap-order, swap the parent with it's largest child - *__start = _VSTD::move(*__child_i); + *__start = std::move(*__child_i); __start = __child_i; if ((__len - 2) / 2 < __child) @@ -4843,7 +4843,7 @@ // check if we are in heap-order } while (!__comp(*__child_i, __top)); - *__start = _VSTD::move(__top); + *__start = std::move(__top); } template @@ -4879,7 +4879,7 @@ void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::pop_heap(__first, __last, __less::value_type>()); + std::pop_heap(__first, __last, __less::value_type>()); } // make_heap @@ -4920,7 +4920,7 @@ void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::make_heap(__first, __last, __less::value_type>()); + std::make_heap(__first, __last, __less::value_type>()); } // sort_heap @@ -4954,7 +4954,7 @@ void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { - _VSTD::sort_heap(__first, __last, __less::value_type>()); + std::sort_heap(__first, __last, __less::value_type>()); } // partial_sort @@ -4998,7 +4998,7 @@ void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) { - _VSTD::partial_sort(__first, __middle, __last, + std::partial_sort(__first, __middle, __last, __less::value_type>()); } @@ -5049,7 +5049,7 @@ partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) { - return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last, + return std::partial_sort_copy(__first, __last, __result_first, __result_last, __less::value_type>()); } @@ -5080,7 +5080,7 @@ case 3: { _RandomAccessIterator __m = __first; - _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp); + std::__sort3<_Compare>(__first, ++__m, --__last, __comp); return; } } @@ -5092,7 +5092,7 @@ // __len > __limit >= 3 _RandomAccessIterator __m = __first + __len/2; _RandomAccessIterator __lm1 = __last; - unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp); + unsigned __n_swaps = std::__sort3<_Compare>(__first, __m, --__lm1, __comp); // *__m is median // partition [__first, __m) < *__m and *__m <= [__m, __last) // (this inhibits tossing elements equivalent to __m around unnecessarily) @@ -5262,7 +5262,7 @@ void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { - _VSTD::nth_element(__first, __nth, __last, __less::value_type>()); + std::nth_element(__first, __nth, __last, __less::value_type>()); } // includes @@ -5303,7 +5303,7 @@ bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { - return _VSTD::includes(__first1, __last1, __first2, __last2, + return std::includes(__first1, __last1, __first2, __last2, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5318,7 +5318,7 @@ for (; __first1 != __last1; ++__result) { if (__first2 == __last2) - return _VSTD::copy(__first1, __last1, __result); + return std::copy(__first1, __last1, __result); if (__comp(*__first2, *__first1)) { *__result = *__first2; @@ -5332,7 +5332,7 @@ ++__first1; } } - return _VSTD::copy(__first2, __last2, __result); + return std::copy(__first2, __last2, __result); } template @@ -5357,7 +5357,7 @@ set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { - return _VSTD::set_union(__first1, __last1, __first2, __last2, __result, + return std::set_union(__first1, __last1, __first2, __last2, __result, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5409,7 +5409,7 @@ set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { - return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result, + return std::set_intersection(__first1, __last1, __first2, __last2, __result, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5424,7 +5424,7 @@ while (__first1 != __last1) { if (__first2 == __last2) - return _VSTD::copy(__first1, __last1, __result); + return std::copy(__first1, __last1, __result); if (__comp(*__first1, *__first2)) { *__result = *__first1; @@ -5463,7 +5463,7 @@ set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { - return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result, + return std::set_difference(__first1, __last1, __first2, __last2, __result, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5478,7 +5478,7 @@ while (__first1 != __last1) { if (__first2 == __last2) - return _VSTD::copy(__first1, __last1, __result); + return std::copy(__first1, __last1, __result); if (__comp(*__first1, *__first2)) { *__result = *__first1; @@ -5497,7 +5497,7 @@ ++__first2; } } - return _VSTD::copy(__first2, __last2, __result); + return std::copy(__first2, __last2, __result); } template @@ -5522,7 +5522,7 @@ set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { - return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, + return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5566,7 +5566,7 @@ lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { - return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2, + return std::lexicographical_compare(__first1, __last1, __first2, __last2, __less::value_type, typename iterator_traits<_InputIterator2>::value_type>()); } @@ -5589,12 +5589,12 @@ while (!__comp(*__i, *--__j)) ; swap(*__i, *__j); - _VSTD::reverse(__ip1, __last); + std::reverse(__ip1, __last); return true; } if (__i == __first) { - _VSTD::reverse(__first, __last); + std::reverse(__first, __last); return false; } } @@ -5620,7 +5620,7 @@ bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { - return _VSTD::next_permutation(__first, __last, + return std::next_permutation(__first, __last, __less::value_type>()); } @@ -5642,12 +5642,12 @@ while (!__comp(*--__j, *__i)) ; swap(*__i, *__j); - _VSTD::reverse(__ip1, __last); + std::reverse(__ip1, __last); return true; } if (__i == __first) { - _VSTD::reverse(__first, __last); + std::reverse(__first, __last); return false; } } @@ -5673,7 +5673,7 @@ bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { - return _VSTD::prev_permutation(__first, __last, + return std::prev_permutation(__first, __last, __less::value_type>()); } Index: include/any =================================================================== --- include/any +++ include/any @@ -112,7 +112,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_any_cast(); #else - _VSTD::abort(); + std::abort(); #endif } @@ -241,7 +241,7 @@ _LIBCPP_INLINE_VISIBILITY any & operator=(any && __rhs) _NOEXCEPT { - any(_VSTD::move(__rhs)).swap(*this); + any(std::move(__rhs)).swap(*this); return *this; } @@ -369,7 +369,7 @@ template _LIBCPP_INLINE_VISIBILITY static _Tp& __create(any & __dest, _Args&&... __args) { - _Tp* __ret = ::new (static_cast(&__dest.__s.__buf)) _Tp(_VSTD::forward<_Args>(__args)...); + _Tp* __ret = ::new (static_cast(&__dest.__s.__buf)) _Tp(std::forward<_Args>(__args)...); __dest.__h = &_SmallHandler::__handle; return *__ret; } @@ -390,7 +390,7 @@ _LIBCPP_INLINE_VISIBILITY static void __move(any & __this, any & __dest) { - _SmallHandler::__create(__dest, _VSTD::move( + _SmallHandler::__create(__dest, std::move( *static_cast<_Tp*>(static_cast(&__this.__s.__buf)))); __destroy(__this); } @@ -449,7 +449,7 @@ typedef __allocator_destructor<_Alloc> _Dp; _Alloc __a; unique_ptr<_Tp, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); - _Tp* __ret = ::new ((void*)__hold.get()) _Tp(_VSTD::forward<_Args>(__args)...); + _Tp* __ret = ::new ((void*)__hold.get()) _Tp(std::forward<_Args>(__args)...); __dest.__s.__ptr = __hold.release(); __dest.__h = &_LargeHandler::__handle; return *__ret; @@ -502,24 +502,24 @@ template any::any(_ValueType && __v) : __h(nullptr) { - __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_ValueType>(__v)); + __any_imp::_Handler<_Tp>::__create(*this, std::forward<_ValueType>(__v)); } template any::any(in_place_type_t<_ValueType>, _Args&&... __args) { - __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...); + __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...); }; template any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) { - __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...); + __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY any & any::operator=(_ValueType && __v) { - any(_VSTD::forward<_ValueType>(__v)).swap(*this); + any(std::forward<_ValueType>(__v)).swap(*this); return *this; } @@ -527,14 +527,14 @@ inline _LIBCPP_INLINE_VISIBILITY _Tp& any::emplace(_Args&&... __args) { reset(); - return __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...); + return __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY _Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) { reset(); - return __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...); + return __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...); } inline _LIBCPP_INLINE_VISIBILITY @@ -567,13 +567,13 @@ template inline _LIBCPP_INLINE_VISIBILITY any make_any(_Args&&... __args) { - return any(in_place_type<_Tp>, _VSTD::forward<_Args>(__args)...); + return any(in_place_type<_Tp>, std::forward<_Args>(__args)...); } template inline _LIBCPP_INLINE_VISIBILITY any make_any(initializer_list<_Up> __il, _Args&&... __args) { - return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...); + return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...); } template @@ -585,7 +585,7 @@ static_assert(is_constructible<_ValueType, _RawValueType const &>::value, "ValueType is required to be a const lvalue reference " "or a CopyConstructible type"); - auto __tmp = _VSTD::any_cast>(&__v); + auto __tmp = std::any_cast>(&__v); if (__tmp == nullptr) __throw_bad_any_cast(); return static_cast<_ValueType>(*__tmp); @@ -600,7 +600,7 @@ static_assert(is_constructible<_ValueType, _RawValueType &>::value, "ValueType is required to be an lvalue reference " "or a CopyConstructible type"); - auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); + auto __tmp = std::any_cast<_RawValueType>(&__v); if (__tmp == nullptr) __throw_bad_any_cast(); return static_cast<_ValueType>(*__tmp); @@ -615,10 +615,10 @@ static_assert(is_constructible<_ValueType, _RawValueType>::value, "ValueType is required to be an rvalue reference " "or a CopyConstructible type"); - auto __tmp = _VSTD::any_cast<_RawValueType>(&__v); + auto __tmp = std::any_cast<_RawValueType>(&__v); if (__tmp == nullptr) __throw_bad_any_cast(); - return static_cast<_ValueType>(_VSTD::move(*__tmp)); + return static_cast<_ValueType>(std::move(*__tmp)); } template @@ -628,7 +628,7 @@ { static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference."); - return _VSTD::any_cast<_ValueType>(const_cast(__any)); + return std::any_cast<_ValueType>(const_cast(__any)); } template @@ -659,7 +659,7 @@ nullptr, #endif __any_imp::__get_fallback_typeid<_ValueType>()); - return _VSTD::__pointer_or_func_cast<_ReturnType>( + return std::__pointer_or_func_cast<_ReturnType>( __p, is_function<_ValueType>{}); } return nullptr; Index: include/array =================================================================== --- include/array +++ include/array @@ -145,7 +145,7 @@ // No explicit construct/copy/destroy for aggregate type _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) { - _VSTD::fill_n(__elems_, _Size, __u); + std::fill_n(__elems_, _Size, __u); } _LIBCPP_INLINE_VISIBILITY @@ -371,7 +371,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 bool operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { - return _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -387,7 +387,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 bool operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } @@ -467,7 +467,7 @@ get(array<_Tp, _Size>&& __a) _NOEXCEPT { static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)"); - return _VSTD::move(__a.__elems_[_Ip]); + return std::move(__a.__elems_[_Ip]); } template @@ -476,7 +476,7 @@ get(const array<_Tp, _Size>&& __a) _NOEXCEPT { static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)"); - return _VSTD::move(__a.__elems_[_Ip]); + return std::move(__a.__elems_[_Ip]); } #endif // !_LIBCPP_CXX03_LANG Index: include/bitset =================================================================== --- include/bitset +++ include/bitset @@ -224,7 +224,7 @@ #endif { #ifdef _LIBCPP_CXX03_LANG - _VSTD::fill_n(__first_, _N_words, __storage_type(0)); + std::fill_n(__first_, _N_words, __storage_type(0)); #endif } @@ -242,8 +242,8 @@ else __t[__i] = static_cast<__storage_type>(__v); - _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_); - _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]), + std::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_); + std::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0)); } @@ -256,7 +256,7 @@ if (_Size < __bits_per_word) __first_[0] &= ( 1ULL << _Size ) - 1; - _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0)); + std::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0)); } #endif // _LIBCPP_CXX03_LANG @@ -333,7 +333,7 @@ __bitset<_N_words, _Size>::to_ulong(false_type) const { const_iterator __e = __make_iter(_Size); - const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true); + const_iterator __i = std::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true); if (__i != __e) __throw_overflow_error("bitset to_ulong overflow error"); @@ -353,7 +353,7 @@ __bitset<_N_words, _Size>::to_ullong(false_type) const { const_iterator __e = __make_iter(_Size); - const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true); + const_iterator __i = std::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true); if (__i != __e) __throw_overflow_error("bitset to_ullong overflow error"); @@ -766,12 +766,12 @@ typename basic_string<_CharT>::size_type __n, _CharT __zero, _CharT __one) { - size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str)); + size_t __rlen = std::min(__n, char_traits<_CharT>::length(__str)); for (size_t __i = 0; __i < __rlen; ++__i) if (__str[__i] != __zero && __str[__i] != __one) __throw_invalid_argument("bitset string ctor has invalid argument"); - size_t _Mp = _VSTD::min(__rlen, _Size); + size_t _Mp = std::min(__rlen, _Size); size_t __i = 0; for (; __i < _Mp; ++__i) { @@ -781,7 +781,7 @@ else (*this)[__i] = true; } - _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false); + std::fill(base::__make_iter(__i), base::__make_iter(_Size), false); } template @@ -794,12 +794,12 @@ if (__pos > __str.size()) __throw_out_of_range("bitset string pos out of range"); - size_t __rlen = _VSTD::min(__n, __str.size() - __pos); + size_t __rlen = std::min(__n, __str.size() - __pos); for (size_t __i = __pos; __i < __pos + __rlen; ++__i) if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one)) __throw_invalid_argument("bitset string ctor has invalid argument"); - size_t _Mp = _VSTD::min(__rlen, _Size); + size_t _Mp = std::min(__rlen, _Size); size_t __i = 0; for (; __i < _Mp; ++__i) { @@ -809,7 +809,7 @@ else (*this)[__i] = true; } - _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false); + std::fill(base::__make_iter(__i), base::__make_iter(_Size), false); } template @@ -843,9 +843,9 @@ bitset<_Size>& bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT { - __pos = _VSTD::min(__pos, _Size); - _VSTD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size)); - _VSTD::fill_n(base::__make_iter(0), __pos, false); + __pos = std::min(__pos, _Size); + std::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size)); + std::fill_n(base::__make_iter(0), __pos, false); return *this; } @@ -853,9 +853,9 @@ bitset<_Size>& bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT { - __pos = _VSTD::min(__pos, _Size); - _VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0)); - _VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false); + __pos = std::min(__pos, _Size); + std::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0)); + std::fill_n(base::__make_iter(_Size - __pos), __pos, false); return *this; } @@ -864,7 +864,7 @@ bitset<_Size>& bitset<_Size>::set() _NOEXCEPT { - _VSTD::fill_n(base::__make_iter(0), _Size, true); + std::fill_n(base::__make_iter(0), _Size, true); return *this; } @@ -884,7 +884,7 @@ bitset<_Size>& bitset<_Size>::reset() _NOEXCEPT { - _VSTD::fill_n(base::__make_iter(0), _Size, false); + std::fill_n(base::__make_iter(0), _Size, false); return *this; } @@ -991,7 +991,7 @@ size_t bitset<_Size>::count() const _NOEXCEPT { - return static_cast(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true)); + return static_cast(std::count(base::__make_iter(0), base::__make_iter(_Size), true)); } template @@ -999,7 +999,7 @@ bool bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT { - return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0)); + return std::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0)); } template Index: include/chrono =================================================================== --- include/chrono +++ include/chrono @@ -1056,7 +1056,7 @@ (__no_overflow<_Period2, period>::type::den == 1 && !treat_as_floating_point<_Rep2>::value)) >::type* = 0) - : __rep_(_VSTD::chrono::duration_cast(__d).count()) {} + : __rep_(std::chrono::duration_cast(__d).count()) {} // observer @@ -1389,7 +1389,7 @@ time_point<_Clock, _ToDuration> time_point_cast(const time_point<_Clock, _Duration>& __t) { - return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); + return time_point<_Clock, _ToDuration>(std::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); } #if _LIBCPP_STD_VER > 14 @@ -1871,13 +1871,13 @@ class _LIBCPP_TYPE_VIS weekday_indexed { private: - _VSTD::chrono::weekday __wd; + std::chrono::weekday __wd; unsigned char __idx; public: weekday_indexed() = default; - inline constexpr weekday_indexed(const _VSTD::chrono::weekday& __wdval, unsigned __idxval) noexcept + inline constexpr weekday_indexed(const std::chrono::weekday& __wdval, unsigned __idxval) noexcept : __wd{__wdval}, __idx(__idxval) {} - inline constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; } + inline constexpr std::chrono::weekday weekday() const noexcept { return __wd; } inline constexpr unsigned index() const noexcept { return __idx; } inline constexpr bool ok() const noexcept { return __wd.ok() && __idx >= 1 && __idx <= 5; } }; @@ -1893,11 +1893,11 @@ class _LIBCPP_TYPE_VIS weekday_last { private: - _VSTD::chrono::weekday __wd; + std::chrono::weekday __wd; public: - explicit constexpr weekday_last(const _VSTD::chrono::weekday& __val) noexcept + explicit constexpr weekday_last(const std::chrono::weekday& __val) noexcept : __wd{__val} {} - constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; } + constexpr std::chrono::weekday weekday() const noexcept { return __wd; } constexpr bool ok() const noexcept { return __wd.ok(); } }; Index: include/complex =================================================================== --- include/complex +++ include/complex @@ -1097,7 +1097,7 @@ pow(const complex<_Tp>& __x, const complex<_Up>& __y) { typedef complex::type> result_type; - return _VSTD::pow(result_type(__x), result_type(__y)); + return std::pow(result_type(__x), result_type(__y)); } template @@ -1110,7 +1110,7 @@ pow(const complex<_Tp>& __x, const _Up& __y) { typedef complex::type> result_type; - return _VSTD::pow(result_type(__x), result_type(__y)); + return std::pow(result_type(__x), result_type(__y)); } template @@ -1123,7 +1123,7 @@ pow(const _Tp& __x, const complex<_Up>& __y) { typedef complex::type> result_type; - return _VSTD::pow(result_type(__x), result_type(__y)); + return std::pow(result_type(__x), result_type(__y)); } // __sqr, computes pow(x, 2) Index: include/condition_variable =================================================================== --- include/condition_variable +++ include/condition_variable @@ -256,7 +256,7 @@ _Predicate __pred) { return wait_until(__lock, chrono::steady_clock::now() + __d, - _VSTD::move(__pred)); + std::move(__pred)); } _LIBCPP_FUNC_VIS Index: include/cstdlib =================================================================== --- include/cstdlib +++ include/cstdlib @@ -92,7 +92,7 @@ #ifdef __GNUC__ #define _LIBCPP_UNREACHABLE() __builtin_unreachable() #else -#define _LIBCPP_UNREACHABLE() _VSTD::abort() +#define _LIBCPP_UNREACHABLE() std::abort() #endif _LIBCPP_BEGIN_NAMESPACE_STD Index: include/deque =================================================================== --- include/deque +++ include/deque @@ -571,7 +571,7 @@ __n = __bs; __m = __f + __n; } - _VSTD::copy(__f, __m, __rb); + std::copy(__f, __m, __rb); __f = __m; __r += __n; } @@ -599,7 +599,7 @@ __bs = __n; __fe = __fb + __bs; } - __r = _VSTD::copy(__fb, __fe, __r); + __r = std::copy(__fb, __fe, __r); __n -= __bs; __f += __bs; } @@ -627,7 +627,7 @@ __bs = __n; __fe = __fb + __bs; } - __r = _VSTD::copy(__fb, __fe, __r); + __r = std::copy(__fb, __fe, __r); __n -= __bs; __f += __bs; } @@ -648,7 +648,7 @@ typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer; while (__f != __l) { - __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r); + __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = std::prev(__r); pointer __rb = *__rp.__m_iter_; pointer __re = __rp.__ptr_ + 1; difference_type __bs = __re - __rb; @@ -659,7 +659,7 @@ __n = __bs; __m = __l - __n; } - _VSTD::copy_backward(__m, __l, __re); + std::copy_backward(__m, __l, __re); __l = __m; __r -= __n; } @@ -687,7 +687,7 @@ __bs = __n; __lb = __le - __bs; } - __r = _VSTD::copy_backward(__lb, __le, __r); + __r = std::copy_backward(__lb, __le, __r); __n -= __bs; __l -= __bs - 1; } @@ -715,7 +715,7 @@ __bs = __n; __lb = __le - __bs; } - __r = _VSTD::copy_backward(__lb, __le, __r); + __r = std::copy_backward(__lb, __le, __r); __n -= __bs; __l -= __bs - 1; } @@ -747,7 +747,7 @@ __n = __bs; __m = __f + __n; } - _VSTD::move(__f, __m, __rb); + std::move(__f, __m, __rb); __f = __m; __r += __n; } @@ -775,7 +775,7 @@ __bs = __n; __fe = __fb + __bs; } - __r = _VSTD::move(__fb, __fe, __r); + __r = std::move(__fb, __fe, __r); __n -= __bs; __f += __bs; } @@ -803,7 +803,7 @@ __bs = __n; __fe = __fb + __bs; } - __r = _VSTD::move(__fb, __fe, __r); + __r = std::move(__fb, __fe, __r); __n -= __bs; __f += __bs; } @@ -824,7 +824,7 @@ typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer; while (__f != __l) { - __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r); + __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = std::prev(__r); pointer __rb = *__rp.__m_iter_; pointer __re = __rp.__ptr_ + 1; difference_type __bs = __re - __rb; @@ -835,7 +835,7 @@ __n = __bs; __m = __l - __n; } - _VSTD::move_backward(__m, __l, __re); + std::move_backward(__m, __l, __re); __l = __m; __r -= __n; } @@ -863,7 +863,7 @@ __bs = __n; __lb = __le - __bs; } - __r = _VSTD::move_backward(__lb, __le, __r); + __r = std::move_backward(__lb, __le, __r); __n -= __bs; __l -= __bs - 1; } @@ -891,7 +891,7 @@ __bs = __n; __lb = __le - __bs; } - __r = _VSTD::move_backward(__lb, __le, __r); + __r = std::move_backward(__lb, __le, __r); __n -= __bs; __l -= __bs - 1; } @@ -910,14 +910,14 @@ void __deque_base_common<__b>::__throw_length_error() const { - _VSTD::__throw_length_error("deque"); + std::__throw_length_error("deque"); } template void __deque_base_common<__b>::__throw_out_of_range() const { - _VSTD::__throw_out_of_range("deque"); + std::__throw_out_of_range("deque"); } template @@ -1000,7 +1000,7 @@ _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value && is_nothrow_move_assignable::value) { - __map_ = _VSTD::move(__c.__map_); + __map_ = std::move(__c.__map_); __start_ = __c.__start_; size() = __c.size(); __move_assign_alloc(__c); @@ -1019,7 +1019,7 @@ void __move_assign_alloc(__deque_base& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable::value) { - __alloc() = _VSTD::move(__c.__alloc()); + __alloc() = std::move(__c.__alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -1121,9 +1121,9 @@ template __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c) _NOEXCEPT_(is_nothrow_move_constructible::value) - : __map_(_VSTD::move(__c.__map_)), - __start_(_VSTD::move(__c.__start_)), - __size_(_VSTD::move(__c.__size_)) + : __map_(std::move(__c.__map_)), + __start_(std::move(__c.__start_)), + __size_(std::move(__c.__size_)) { __c.__start_ = 0; __c.size() = 0; @@ -1131,9 +1131,9 @@ template __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a) - : __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)), - __start_(_VSTD::move(__c.__start_)), - __size_(_VSTD::move(__c.size()), __a) + : __map_(std::move(__c.__map_), __pointer_allocator(__a)), + __start_(std::move(__c.__start_)), + __size_(std::move(__c.size()), __a) { if (__a == __c.__alloc()) { @@ -1161,8 +1161,8 @@ #endif { __map_.swap(__c.__map_); - _VSTD::swap(__start_, __c.__start_); - _VSTD::swap(size(), __c.size()); + std::swap(__start_, __c.__start_); + std::swap(size(), __c.size()); __swap_allocator(__alloc(), __c.__alloc()); } @@ -1172,7 +1172,7 @@ { allocator_type& __a = __alloc(); for (iterator __i = begin(), __e = end(); __i != __e; ++__i) - __alloc_traits::destroy(__a, _VSTD::addressof(*__i)); + __alloc_traits::destroy(__a, std::addressof(*__i)); size() = 0; while (__map_.size() > 2) { @@ -1215,8 +1215,8 @@ typedef typename __base::pointer pointer; typedef typename __base::const_pointer const_pointer; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; // construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY @@ -1579,14 +1579,14 @@ inline deque<_Tp, _Allocator>::deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value) - : __base(_VSTD::move(__c)) + : __base(std::move(__c)) { } template inline deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a) - : __base(_VSTD::move(__c), __a) + : __base(std::move(__c), __a) { if (__a != __c.__alloc()) { @@ -1658,11 +1658,11 @@ if (static_cast(__l - __f) > __base::size()) { _RAIter __m = __f + __base::size(); - _VSTD::copy(__f, __m, __base::begin()); + std::copy(__f, __m, __base::begin()); __append(__m, __l); } else - __erase_to_end(_VSTD::copy(__f, __l, __base::begin())); + __erase_to_end(std::copy(__f, __l, __base::begin())); } template @@ -1671,12 +1671,12 @@ { if (__n > __base::size()) { - _VSTD::fill_n(__base::begin(), __base::size(), __v); + std::fill_n(__base::begin(), __base::size(), __v); __n -= __base::size(); __append(__n, __v); } else - __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v)); + __erase_to_end(std::fill_n(__base::begin(), __n, __v)); } template @@ -1822,7 +1822,7 @@ if (__back_spare() == 0) __add_back_capacity(); // __back_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v); + __alloc_traits::construct(__a, std::addressof(*__base::end()), __v); ++__base::size(); } @@ -1834,7 +1834,7 @@ if (__front_spare() == 0) __add_front_capacity(); // __front_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), __v); --__base::__start_; ++__base::size(); } @@ -1848,7 +1848,7 @@ if (__back_spare() == 0) __add_back_capacity(); // __back_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v)); + __alloc_traits::construct(__a, std::addressof(*__base::end()), std::move(__v)); ++__base::size(); } @@ -1865,8 +1865,8 @@ if (__back_spare() == 0) __add_back_capacity(); // __back_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), - _VSTD::forward<_Args>(__args)...); + __alloc_traits::construct(__a, std::addressof(*__base::end()), + std::forward<_Args>(__args)...); ++__base::size(); #if _LIBCPP_STD_VER > 14 return *--__base::end(); @@ -1881,7 +1881,7 @@ if (__front_spare() == 0) __add_front_capacity(); // __front_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v)); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), std::move(__v)); --__base::__start_; ++__base::size(); } @@ -1900,7 +1900,7 @@ if (__front_spare() == 0) __add_front_capacity(); // __front_spare() >= 1 - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), std::forward<_Args>(__args)...); --__base::__start_; ++__base::size(); #if _LIBCPP_STD_VER > 14 @@ -1922,20 +1922,20 @@ // __front_spare() >= 1 if (__pos == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v)); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), std::move(__v)); --__base::__start_; ++__base::size(); } else { iterator __b = __base::begin(); - iterator __bm1 = _VSTD::prev(__b); - __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b)); + iterator __bm1 = std::prev(__b); + __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b)); --__base::__start_; ++__base::size(); if (__pos > 1) - __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b); - *__b = _VSTD::move(__v); + __b = std::move(std::next(__b), __b + __pos, __b); + *__b = std::move(__v); } } else @@ -1946,18 +1946,18 @@ size_type __de = __base::size() - __pos; if (__de == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v)); + __alloc_traits::construct(__a, std::addressof(*__base::end()), std::move(__v)); ++__base::size(); } else { iterator __e = __base::end(); - iterator __em1 = _VSTD::prev(__e); - __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1)); + iterator __em1 = std::prev(__e); + __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1)); ++__base::size(); if (__de > 1) - __e = _VSTD::move_backward(__e - __de, __em1, __e); - *--__e = _VSTD::move(__v); + __e = std::move_backward(__e - __de, __em1, __e); + *--__e = std::move(__v); } } return __base::begin() + __pos; @@ -1978,21 +1978,21 @@ // __front_spare() >= 1 if (__pos == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), std::forward<_Args>(__args)...); --__base::__start_; ++__base::size(); } else { - __temp_value __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...); + __temp_value __tmp(this->__alloc(), std::forward<_Args>(__args)...); iterator __b = __base::begin(); - iterator __bm1 = _VSTD::prev(__b); - __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b)); + iterator __bm1 = std::prev(__b); + __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b)); --__base::__start_; ++__base::size(); if (__pos > 1) - __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b); - *__b = _VSTD::move(__tmp.get()); + __b = std::move(std::next(__b), __b + __pos, __b); + *__b = std::move(__tmp.get()); } } else @@ -2003,19 +2003,19 @@ size_type __de = __base::size() - __pos; if (__de == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...); + __alloc_traits::construct(__a, std::addressof(*__base::end()), std::forward<_Args>(__args)...); ++__base::size(); } else { - __temp_value __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...); + __temp_value __tmp(this->__alloc(), std::forward<_Args>(__args)...); iterator __e = __base::end(); - iterator __em1 = _VSTD::prev(__e); - __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1)); + iterator __em1 = std::prev(__e); + __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1)); ++__base::size(); if (__de > 1) - __e = _VSTD::move_backward(__e - __de, __em1, __e); - *--__e = _VSTD::move(__tmp.get()); + __e = std::move_backward(__e - __de, __em1, __e); + *--__e = std::move(__tmp.get()); } } return __base::begin() + __pos; @@ -2038,7 +2038,7 @@ // __front_spare() >= 1 if (__pos == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v); + __alloc_traits::construct(__a, std::addressof(*--__base::begin()), __v); --__base::__start_; ++__base::size(); } @@ -2046,14 +2046,14 @@ { const_pointer __vt = pointer_traits::pointer_to(__v); iterator __b = __base::begin(); - iterator __bm1 = _VSTD::prev(__b); + iterator __bm1 = std::prev(__b); if (__vt == pointer_traits::pointer_to(*__b)) __vt = pointer_traits::pointer_to(*__bm1); - __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b)); + __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b)); --__base::__start_; ++__base::size(); if (__pos > 1) - __b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt); + __b = __move_and_check(std::next(__b), __b + __pos, __b, __vt); *__b = *__vt; } } @@ -2065,17 +2065,17 @@ size_type __de = __base::size() - __pos; if (__de == 0) { - __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v); + __alloc_traits::construct(__a, std::addressof(*__base::end()), __v); ++__base::size(); } else { const_pointer __vt = pointer_traits::pointer_to(__v); iterator __e = __base::end(); - iterator __em1 = _VSTD::prev(__e); + iterator __em1 = std::prev(__e); if (__vt == pointer_traits::pointer_to(*__em1)) __vt = pointer_traits::pointer_to(*__e); - __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1)); + __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1)); ++__base::size(); if (__de > 1) __e = __move_backward_and_check(__e - __de, __em1, __e, __vt); @@ -2102,7 +2102,7 @@ if (__n > __pos) { for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v); + __alloc_traits::construct(__a, std::addressof(*--__i), __v); __n = __pos; } if (__n > 0) @@ -2112,7 +2112,7 @@ __move_construct_backward_and_check(__old_begin, __obn, __i, __vt); if (__n < __pos) __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt); - _VSTD::fill_n(__old_begin, __n, *__vt); + std::fill_n(__old_begin, __n, *__vt); } } else @@ -2127,7 +2127,7 @@ if (__n > __de) { for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v); + __alloc_traits::construct(__a, std::addressof(*__i), __v); __n = __de; } if (__n > 0) @@ -2137,7 +2137,7 @@ __move_construct_and_check(__oen, __old_end, __i, __vt); if (__n < __de) __old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt); - _VSTD::fill_n(__old_end - __n, __n, *__vt); + std::fill_n(__old_end - __n, __n, *__vt); } } return __base::begin() + __pos; @@ -2163,7 +2163,7 @@ typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&!__is_bidirectional_iterator<_ForwardIterator>::value>::type*) { - size_type __n = _VSTD::distance(__f, __l); + size_type __n = std::distance(__f, __l); __split_buffer __buf(__n, 0, __base::__alloc()); __buf.__construct_at_end(__f, __l); typedef typename __split_buffer::iterator __fwd; @@ -2176,7 +2176,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l, typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type*) { - size_type __n = _VSTD::distance(__f, __l); + size_type __n = std::distance(__f, __l); size_type __pos = __p - __base::begin(); size_type __to_end = __base::size() - __pos; allocator_type& __a = __base::__alloc(); @@ -2190,9 +2190,9 @@ _BiIter __m = __f; if (__n > __pos) { - __m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos); + __m = __pos < __n / 2 ? std::prev(__l, __pos) : std::next(__f, __n - __pos); for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j); + __alloc_traits::construct(__a, std::addressof(*--__i), *--__j); __n = __pos; } if (__n > 0) @@ -2200,13 +2200,13 @@ iterator __obn = __old_begin + __n; for (iterator __j = __obn; __j != __old_begin;) { - __alloc_traits::construct(__a, _VSTD::addressof(*--__i), _VSTD::move(*--__j)); + __alloc_traits::construct(__a, std::addressof(*--__i), std::move(*--__j)); --__base::__start_; ++__base::size(); } if (__n < __pos) - __old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin); - _VSTD::copy(__m, __l, __old_begin); + __old_begin = std::move(__obn, __old_begin + __pos, __old_begin); + std::copy(__m, __l, __old_begin); } } else @@ -2221,19 +2221,19 @@ size_type __de = __base::size() - __pos; if (__n > __de) { - __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de); + __m = __de < __n / 2 ? std::next(__f, __de) : std::prev(__l, __n - __de); for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j); + __alloc_traits::construct(__a, std::addressof(*__i), *__j); __n = __de; } if (__n > 0) { iterator __oen = __old_end - __n; for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j)); + __alloc_traits::construct(__a, std::addressof(*__i), std::move(*__j)); if (__n < __de) - __old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end); - _VSTD::copy_backward(__f, __m, __old_end); + __old_end = std::move_backward(__old_end - __de, __oen, __old_end); + std::copy_backward(__f, __m, __old_end); } } return __base::begin() + __pos; @@ -2260,14 +2260,14 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l, typename enable_if<__is_forward_iterator<_ForIter>::value>::type*) { - size_type __n = _VSTD::distance(__f, __l); + size_type __n = std::distance(__f, __l); allocator_type& __a = __base::__alloc(); size_type __back_capacity = __back_spare(); if (__n > __back_capacity) __add_back_capacity(__n - __back_capacity); // __n <= __back_capacity for (iterator __i = __base::end(); __f != __l; ++__i, (void) ++__f, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__f); + __alloc_traits::construct(__a, std::addressof(*__i), *__f); } template @@ -2280,7 +2280,7 @@ __add_back_capacity(__n - __back_capacity); // __n <= __back_capacity for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i)); + __alloc_traits::construct(__a, std::addressof(*__i)); } template @@ -2293,7 +2293,7 @@ __add_back_capacity(__n - __back_capacity); // __n <= __back_capacity for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v); + __alloc_traits::construct(__a, std::addressof(*__i), __v); } // Create front capacity for one block of elements. @@ -2346,10 +2346,10 @@ for (typename __base::__map_pointer __i = __base::__map_.begin(); __i != __base::__map_.end(); ++__i) __buf.push_back(*__i); - _VSTD::swap(__base::__map_.__first_, __buf.__first_); - _VSTD::swap(__base::__map_.__begin_, __buf.__begin_); - _VSTD::swap(__base::__map_.__end_, __buf.__end_); - _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap()); + std::swap(__base::__map_.__first_, __buf.__first_); + std::swap(__base::__map_.__begin_, __buf.__begin_); + std::swap(__base::__map_.__end_, __buf.__end_); + std::swap(__base::__map_.__end_cap(), __buf.__end_cap()); __base::__start_ = __base::__map_.size() == 1 ? __base::__block_size / 2 : __base::__start_ + __base::__block_size; @@ -2366,7 +2366,7 @@ size_type __nb = __recommend_blocks(__n + __base::__map_.empty()); // Number of unused blocks at back: size_type __back_capacity = __back_spare() / __base::__block_size; - __back_capacity = _VSTD::min(__back_capacity, __nb); // don't take more than you need + __back_capacity = std::min(__back_capacity, __nb); // don't take more than you need __nb -= __back_capacity; // number of blocks need to allocate // If __nb == 0, then we have sufficient capacity. if (__nb == 0) @@ -2433,10 +2433,10 @@ for (typename __base::__map_pointer __i = __base::__map_.begin(); __i != __base::__map_.end(); ++__i) __buf.push_back(*__i); - _VSTD::swap(__base::__map_.__first_, __buf.__first_); - _VSTD::swap(__base::__map_.__begin_, __buf.__begin_); - _VSTD::swap(__base::__map_.__end_, __buf.__end_); - _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap()); + std::swap(__base::__map_.__first_, __buf.__first_); + std::swap(__base::__map_.__begin_, __buf.__begin_); + std::swap(__base::__map_.__end_, __buf.__end_); + std::swap(__base::__map_.__end_cap(), __buf.__end_cap()); __base::__start_ += __ds; } } @@ -2489,10 +2489,10 @@ for (typename __base::__map_pointer __i = __base::__map_.end(); __i != __base::__map_.begin();) __buf.push_front(*--__i); - _VSTD::swap(__base::__map_.__first_, __buf.__first_); - _VSTD::swap(__base::__map_.__begin_, __buf.__begin_); - _VSTD::swap(__base::__map_.__end_, __buf.__end_); - _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap()); + std::swap(__base::__map_.__first_, __buf.__first_); + std::swap(__base::__map_.__begin_, __buf.__begin_); + std::swap(__base::__map_.__end_, __buf.__end_); + std::swap(__base::__map_.__end_cap(), __buf.__end_cap()); } } @@ -2506,7 +2506,7 @@ size_type __nb = __recommend_blocks(__n + __base::__map_.empty()); // Number of unused blocks at front: size_type __front_capacity = __front_spare() / __base::__block_size; - __front_capacity = _VSTD::min(__front_capacity, __nb); // don't take more than you need + __front_capacity = std::min(__front_capacity, __nb); // don't take more than you need __nb -= __front_capacity; // number of blocks need to allocate // If __nb == 0, then we have sufficient capacity. if (__nb == 0) @@ -2575,10 +2575,10 @@ for (typename __base::__map_pointer __i = __base::__map_.end(); __i != __base::__map_.begin();) __buf.push_front(*--__i); - _VSTD::swap(__base::__map_.__first_, __buf.__first_); - _VSTD::swap(__base::__map_.__begin_, __buf.__begin_); - _VSTD::swap(__base::__map_.__end_, __buf.__end_); - _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap()); + std::swap(__base::__map_.__first_, __buf.__first_); + std::swap(__base::__map_.__begin_, __buf.__begin_); + std::swap(__base::__map_.__end_, __buf.__end_); + std::swap(__base::__map_.__end_cap(), __buf.__end_cap()); __base::__start_ -= __ds; } } @@ -2626,7 +2626,7 @@ { // as if // for (; __f != __l; ++__f, ++__r) - // *__r = _VSTD::move(*__f); + // *__r = std::move(*__f); difference_type __n = __l - __f; while (__n > 0) { @@ -2640,7 +2640,7 @@ } if (__fb <= __vt && __vt < __fe) __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) -= __f - __r).__ptr_; - __r = _VSTD::move(__fb, __fe, __r); + __r = std::move(__fb, __fe, __r); __n -= __bs; __f += __bs; } @@ -2656,7 +2656,7 @@ { // as if // while (__f != __l) - // *--__r = _VSTD::move(*--__l); + // *--__r = std::move(*--__l); difference_type __n = __l - __f; while (__n > 0) { @@ -2671,7 +2671,7 @@ } if (__lb <= __vt && __vt < __le) __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) += __r - __l - 1).__ptr_; - __r = _VSTD::move_backward(__lb, __le, __r); + __r = std::move_backward(__lb, __le, __r); __n -= __bs; __l -= __bs - 1; } @@ -2688,7 +2688,7 @@ allocator_type& __a = __base::__alloc(); // as if // for (; __f != __l; ++__r, ++__f, ++__base::size()) - // __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__f)); + // __alloc_traits::construct(__a, std::addressof(*__r), std::move(*__f)); difference_type __n = __l - __f; while (__n > 0) { @@ -2703,7 +2703,7 @@ if (__fb <= __vt && __vt < __fe) __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) += __r - __f).__ptr_; for (; __fb != __fe; ++__fb, ++__r, ++__base::size()) - __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__fb)); + __alloc_traits::construct(__a, std::addressof(*__r), std::move(*__fb)); __n -= __bs; __f += __bs; } @@ -2720,7 +2720,7 @@ // as if // for (iterator __j = __l; __j != __f;) // { - // __alloc_traitsconstruct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__j)); + // __alloc_traitsconstruct(__a, std::addressof(*--__r), std::move(*--__j)); // --__base::__start_; // ++__base::size(); // } @@ -2740,7 +2740,7 @@ __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) -= __l - __r + 1).__ptr_; while (__le != __lb) { - __alloc_traits::construct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__le)); + __alloc_traits::construct(__a, std::addressof(*--__r), std::move(*--__le)); --__base::__start_; ++__base::size(); } @@ -2759,8 +2759,8 @@ allocator_type& __a = __base::__alloc(); if (static_cast(__pos) <= (__base::size() - 1) / 2) { // erase from front - _VSTD::move_backward(__b, __p, _VSTD::next(__p)); - __alloc_traits::destroy(__a, _VSTD::addressof(*__b)); + std::move_backward(__b, __p, std::next(__p)); + __alloc_traits::destroy(__a, std::addressof(*__b)); --__base::size(); ++__base::__start_; if (__front_spare() >= 2 * __base::__block_size) @@ -2772,8 +2772,8 @@ } else { // erase from back - iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p); - __alloc_traits::destroy(__a, _VSTD::addressof(*__i)); + iterator __i = std::move(std::next(__p), __base::end(), __p); + __alloc_traits::destroy(__a, std::addressof(*__i)); --__base::size(); if (__back_spare() >= 2 * __base::__block_size) { @@ -2797,9 +2797,9 @@ allocator_type& __a = __base::__alloc(); if (static_cast(__pos) <= (__base::size() - __n) / 2) { // erase from front - iterator __i = _VSTD::move_backward(__b, __p, __p + __n); + iterator __i = std::move_backward(__b, __p, __p + __n); for (; __b != __i; ++__b) - __alloc_traits::destroy(__a, _VSTD::addressof(*__b)); + __alloc_traits::destroy(__a, std::addressof(*__b)); __base::size() -= __n; __base::__start_ += __n; while (__front_spare() >= 2 * __base::__block_size) @@ -2811,9 +2811,9 @@ } else { // erase from back - iterator __i = _VSTD::move(__p + __n, __base::end(), __p); + iterator __i = std::move(__p + __n, __base::end(), __p); for (iterator __e = __base::end(); __i != __e; ++__i) - __alloc_traits::destroy(__a, _VSTD::addressof(*__i)); + __alloc_traits::destroy(__a, std::addressof(*__i)); __base::size() -= __n; while (__back_spare() >= 2 * __base::__block_size) { @@ -2837,7 +2837,7 @@ iterator __b = __base::begin(); difference_type __pos = __f - __b; for (iterator __p = __b + __pos; __p != __e; ++__p) - __alloc_traits::destroy(__a, _VSTD::addressof(*__p)); + __alloc_traits::destroy(__a, std::addressof(*__p)); __base::size() -= __n; while (__back_spare() >= 2 * __base::__block_size) { @@ -2875,7 +2875,7 @@ operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { const typename deque<_Tp, _Allocator>::size_type __sz = __x.size(); - return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -2891,7 +2891,7 @@ bool operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template Index: include/exception =================================================================== --- include/exception +++ include/exception @@ -178,7 +178,7 @@ } #else ((void)__e); - _VSTD::abort(); + std::abort(); #endif } @@ -226,7 +226,7 @@ _LIBCPP_INLINE_VISIBILITY exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT { - return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e)); + return __copy_exception_ptr(std::addressof(__e), __GetExceptionInfo(__e)); } #endif // _LIBCPP_ABI_MICROSOFT @@ -267,7 +267,7 @@ __do_throw (_Tp& __t) #endif // _LIBCPP_CXX03_LANG { - throw __nested<_Up>(_VSTD::forward<_Tp>(__t)); + throw __nested<_Up>(std::forward<_Tp>(__t)); } }; @@ -280,7 +280,7 @@ __do_throw (_Tp& __t) #endif // _LIBCPP_CXX03_LANG { - throw _VSTD::forward<_Tp>(__t); + throw std::forward<_Tp>(__t); } }; #endif @@ -301,7 +301,7 @@ is_class<_Up>::value && !is_base_of::value && !__libcpp_is_final<_Up>::value>:: - __do_throw(_VSTD::forward<_Tp>(__t)); + __do_throw(std::forward<_Tp>(__t)); #else ((void)__t); // FIXME: Make this abort @@ -320,7 +320,7 @@ rethrow_if_nested(const _Ep& __e, typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0) { - const nested_exception* __nep = dynamic_cast(_VSTD::addressof(__e)); + const nested_exception* __nep = dynamic_cast(std::addressof(__e)); if (__nep) __nep->rethrow_nested(); } Index: include/experimental/__memory =================================================================== --- include/experimental/__memory +++ include/experimental/__memory @@ -79,9 +79,9 @@ void __lfts_user_alloc_construct( _Tp * __store, const _Alloc & __a, _Args &&... __args) { - _VSTD::__user_alloc_construct_impl( + std::__user_alloc_construct_impl( typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type() - , __store, __a, _VSTD::forward<_Args>(__args)... + , __store, __a, std::forward<_Args>(__args)... ); } Index: include/experimental/coroutine =================================================================== --- include/experimental/coroutine +++ include/experimental/coroutine @@ -253,7 +253,7 @@ typedef typename remove_cv<_Promise>::type _RawPromise; coroutine_handle __tmp; __tmp.__handle_ = __builtin_coro_promise( - _VSTD::addressof(const_cast<_RawPromise&>(__promise)), + std::addressof(const_cast<_RawPromise&>(__promise)), __alignof(_Promise), true); return __tmp; } Index: include/experimental/deque =================================================================== --- include/experimental/deque +++ include/experimental/deque @@ -40,7 +40,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template -using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>; +using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/forward_list =================================================================== --- include/experimental/forward_list +++ include/experimental/forward_list @@ -40,7 +40,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template -using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; +using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/functional =================================================================== --- include/experimental/functional +++ include/experimental/functional @@ -123,9 +123,9 @@ pair<_ForwardIterator2, _ForwardIterator2> operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const { - return _VSTD::__search(__f, __l, __first_, __last_, __pred_, - typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(), - typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category()); + return std::__search(__f, __l, __first_, __last_, __pred_, + typename std::iterator_traits<_ForwardIterator>::iterator_category(), + typename std::iterator_traits<_ForwardIterator2>::iterator_category()); } private: @@ -182,7 +182,7 @@ typedef _Key key_type; typedef typename std::make_unsigned::type unsigned_key_type; - typedef std::array::max()> skip_map; + typedef std::array::max()> skip_map; skip_map __table; public: @@ -215,7 +215,7 @@ typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; typedef _BMSkipTable::value && // what about enums? + std::is_integral::value && // what about enums? sizeof(value_type) == 1 && is_same<_Hash, hash>::value && is_same<_BinaryPredicate, equal_to<>>::value @@ -225,7 +225,7 @@ boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : __first_(__f), __last_(__l), __pred_(__pred), - __pattern_length_(_VSTD::distance(__first_, __last_)), + __pattern_length_(std::distance(__first_, __last_)), __skip_{make_shared(__pattern_length_, -1, __hf, __pred_)}, __suffix_{make_shared>(__pattern_length_ + 1)} { @@ -250,7 +250,7 @@ if (__first_ == __last_) return make_pair(__f, __f); // empty pattern // If the pattern is larger than the corpus, we can't find it! - if ( __pattern_length_ > _VSTD::distance (__f, __l)) + if ( __pattern_length_ > std::distance (__f, __l)) return make_pair(__l, __l); // Do the search @@ -302,7 +302,7 @@ template void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix ) { - const std::size_t __count = _VSTD::distance(__f, __l); + const std::size_t __count = std::distance(__f, __l); __prefix[0] = 0; std::size_t __k = 0; @@ -320,17 +320,17 @@ void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, _BinaryPredicate __pred) { - const std::size_t __count = _VSTD::distance(__f, __l); + const std::size_t __count = std::distance(__f, __l); vector & __suffix = *__suffix_.get(); if (__count > 0) { - _VSTD::vector __scratch(__count); + std::vector __scratch(__count); __compute_bm_prefix(__f, __l, __pred, __scratch); for ( std::size_t __i = 0; __i <= __count; __i++ ) __suffix[__i] = __count - __scratch[__count-1]; - typedef _VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter; + typedef std::reverse_iterator<_RandomAccessIterator1> _RevIter; __compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch); for ( std::size_t __i = 0; __i < __count; __i++ ) @@ -367,7 +367,7 @@ typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type; typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type; typedef _BMSkipTable::value && // what about enums? + std::is_integral::value && // what about enums? sizeof(value_type) == 1 && is_same<_Hash, hash>::value && is_same<_BinaryPredicate, equal_to<>>::value @@ -377,8 +377,8 @@ boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : __first_(__f), __last_(__l), __pred_(__pred), - __pattern_length_(_VSTD::distance(__first_, __last_)), - __skip_{_VSTD::make_shared(__pattern_length_, __pattern_length_, __hf, __pred_)} + __pattern_length_(std::distance(__first_, __last_)), + __skip_{std::make_shared(__pattern_length_, __pattern_length_, __hf, __pred_)} { // build the skip table if ( __f != __l ) @@ -403,7 +403,7 @@ if (__first_ == __last_) return make_pair(__f, __f); // empty pattern // If the pattern is larger than the corpus, we can't find it! - if ( __pattern_length_ > _VSTD::distance (__f, __l)) + if ( __pattern_length_ > std::distance (__f, __l)) return make_pair(__l, __l); // Do the search Index: include/experimental/iterator =================================================================== --- include/experimental/iterator +++ include/experimental/iterator @@ -75,10 +75,10 @@ typedef void reference; ostream_joiner(ostream_type& __os, _Delim&& __d) - : __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {} + : __output_iter(std::addressof(__os)), __delim(std::move(__d)), __first(true) {} ostream_joiner(ostream_type& __os, const _Delim& __d) - : __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {} + : __output_iter(std::addressof(__os)), __delim(__d), __first(true) {} template @@ -105,7 +105,7 @@ template ostream_joiner::type, _CharT, _Traits> make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d) -{ return ostream_joiner::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); } +{ return ostream_joiner::type, _CharT, _Traits>(__os, std::forward<_Delim>(__d)); } _LIBCPP_END_NAMESPACE_LFTS Index: include/experimental/list =================================================================== --- include/experimental/list +++ include/experimental/list @@ -40,7 +40,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template -using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>; +using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/map =================================================================== --- include/experimental/map +++ include/experimental/map @@ -45,11 +45,11 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template > -using map = _VSTD::map<_Key, _Value, _Compare, +using map = std::map<_Key, _Value, _Compare, polymorphic_allocator>>; template > -using multimap = _VSTD::multimap<_Key, _Value, _Compare, +using multimap = std::multimap<_Key, _Value, _Compare, polymorphic_allocator>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/memory_resource =================================================================== --- include/experimental/memory_resource +++ include/experimental/memory_resource @@ -206,7 +206,7 @@ void construct(_Tp* __p, _Ts &&... __args) { _VSTD_LFTS::__lfts_user_alloc_construct( - __p, *this, _VSTD::forward<_Ts>(__args)... + __p, *this, std::forward<_Ts>(__args)... ); } @@ -220,14 +220,14 @@ typename __lfts_uses_alloc_ctor< _T1, polymorphic_allocator&, _Args1... >::type() - , _VSTD::move(__x) + , std::move(__x) , typename __make_tuple_indices::type{} ) , __transform_tuple( typename __lfts_uses_alloc_ctor< _T2, polymorphic_allocator&, _Args2... >::type() - , _VSTD::move(__y) + , std::move(__y) , typename __make_tuple_indices::type{} ) ); @@ -243,24 +243,24 @@ _LIBCPP_INLINE_VISIBILITY void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) { construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u)) - , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v))); + , std::forward_as_tuple(std::forward<_Up>(__u)) + , std::forward_as_tuple(std::forward<_Vp>(__v))); } template _LIBCPP_INLINE_VISIBILITY void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) { construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(__pr.first) - , _VSTD::forward_as_tuple(__pr.second)); + , std::forward_as_tuple(__pr.first) + , std::forward_as_tuple(__pr.second)); } template _LIBCPP_INLINE_VISIBILITY void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){ construct(__p, piecewise_construct - , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first)) - , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second))); + , std::forward_as_tuple(std::forward<_U1>(__pr.first)) + , std::forward_as_tuple(std::forward<_U2>(__pr.second))); } template @@ -284,7 +284,7 @@ __transform_tuple(integral_constant, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) const { - return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); + return std::forward_as_tuple(std::get<_Idx>(std::move(__t))...); } template @@ -295,7 +295,7 @@ { using _Tup = tuple; return _Tup(allocator_arg, *this, - _VSTD::get<_Idx>(_VSTD::move(__t))...); + std::get<_Idx>(std::move(__t))...); } template @@ -305,7 +305,7 @@ __tuple_indices<_Idx...>) { using _Tup = tuple<_Args&&..., polymorphic_allocator&>; - return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this); + return _Tup(std::get<_Idx>(std::move(__t))..., *this); } _LIBCPP_INLINE_VISIBILITY @@ -371,7 +371,7 @@ _LIBCPP_INLINE_VISIBILITY explicit __resource_adaptor_imp(allocator_type && __a) - : __alloc_(_VSTD::move(__a)) + : __alloc_(std::move(__a)) {} __resource_adaptor_imp & Index: include/experimental/propagate_const =================================================================== --- include/experimental/propagate_const +++ include/experimental/propagate_const @@ -136,7 +136,7 @@ class propagate_const { public: - typedef remove_reference_t())> element_type; + typedef remove_reference_t())> element_type; static_assert(!is_array<_Tp>::value, "Instantiation of propagate_const with an array type is ill-formed."); @@ -292,7 +292,7 @@ _LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { - using _VSTD::swap; + using std::swap; swap(__t_, __pt.__t_); } }; Index: include/experimental/regex =================================================================== --- include/experimental/regex +++ include/experimental/regex @@ -49,8 +49,8 @@ template using match_results = - _VSTD::match_results<_BiDirIter, - polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>; + std::match_results<_BiDirIter, + polymorphic_allocator>>; typedef match_results cmatch; typedef match_results wcmatch; Index: include/experimental/set =================================================================== --- include/experimental/set +++ include/experimental/set @@ -45,11 +45,11 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template > -using set = _VSTD::set<_Value, _Compare, +using set = std::set<_Value, _Compare, polymorphic_allocator<_Value>>; template > -using multiset = _VSTD::multiset<_Value, _Compare, +using multiset = std::multiset<_Value, _Compare, polymorphic_allocator<_Value>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/string =================================================================== --- include/experimental/string +++ include/experimental/string @@ -50,7 +50,7 @@ template > using basic_string = - _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; + std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; typedef basic_string string; typedef basic_string u16string; Index: include/experimental/unordered_map =================================================================== --- include/experimental/unordered_map +++ include/experimental/unordered_map @@ -52,12 +52,12 @@ template , class _Pred = equal_to<_Key>> -using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred, +using unordered_map = std::unordered_map<_Key, _Value, _Hash, _Pred, polymorphic_allocator>>; template , class _Pred = equal_to<_Key>> -using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred, +using unordered_multimap = std::unordered_multimap<_Key, _Value, _Hash, _Pred, polymorphic_allocator>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/unordered_set =================================================================== --- include/experimental/unordered_set +++ include/experimental/unordered_set @@ -46,12 +46,12 @@ template , class _Pred = equal_to<_Value>> -using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred, +using unordered_set = std::unordered_set<_Value, _Hash, _Pred, polymorphic_allocator<_Value>>; template , class _Pred = equal_to<_Value>> -using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred, +using unordered_multiset = std::unordered_multiset<_Value, _Hash, _Pred, polymorphic_allocator<_Value>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/experimental/vector =================================================================== --- include/experimental/vector +++ include/experimental/vector @@ -40,7 +40,7 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR template -using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>; +using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>; _LIBCPP_END_NAMESPACE_LFTS_PMR Index: include/ext/hash_map =================================================================== --- include/ext/hash_map +++ include/ext/hash_map @@ -355,9 +355,9 @@ void operator()(pointer __p) { if (__second_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.second)); if (__first_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.first)); if (__p) __alloc_traits::deallocate(__na_, __p, 1); } @@ -666,9 +666,9 @@ { __node_allocator& __na = __table_.__node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k); + __node_traits::construct(__na, std::addressof(__h->__value_.first), __k); __h.get_deleter().__first_constructed = true; - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second)); + __node_traits::construct(__na, std::addressof(__h->__value_.second)); __h.get_deleter().__second_constructed = true; return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03 } @@ -961,9 +961,9 @@ { _EqRng __xeq = __x.equal_range(__i->first); _EqRng __yeq = __y.equal_range(__i->first); - if (_VSTD::distance(__xeq.first, __xeq.second) != - _VSTD::distance(__yeq.first, __yeq.second) || - !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) + if (std::distance(__xeq.first, __xeq.second) != + std::distance(__yeq.first, __yeq.second) || + !std::is_permutation(__xeq.first, __xeq.second, __yeq.first)) return false; __i = __xeq.second; } Index: include/ext/hash_set =================================================================== --- include/ext/hash_set +++ include/ext/hash_set @@ -640,9 +640,9 @@ { _EqRng __xeq = __x.equal_range(*__i); _EqRng __yeq = __y.equal_range(*__i); - if (_VSTD::distance(__xeq.first, __xeq.second) != - _VSTD::distance(__yeq.first, __yeq.second) || - !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) + if (std::distance(__xeq.first, __xeq.second) != + std::distance(__yeq.first, __yeq.second) || + !std::is_permutation(__xeq.first, __xeq.second, __yeq.first)) return false; __i = __xeq.second; } Index: include/filesystem =================================================================== --- include/filesystem +++ include/filesystem @@ -778,7 +778,7 @@ public: typedef char value_type; typedef basic_string string_type; - typedef _VSTD::string_view __string_view; + typedef std::string_view __string_view; static constexpr value_type preferred_separator = '/'; enum class _LIBCPP_ENUM_VIS format : unsigned char { @@ -791,11 +791,11 @@ _LIBCPP_INLINE_VISIBILITY path() noexcept {} _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {} _LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept - : __pn_(_VSTD::move(__p.__pn_)) {} + : __pn_(std::move(__p.__pn_)) {} _LIBCPP_INLINE_VISIBILITY path(string_type&& __s, format = format::auto_format) noexcept - : __pn_(_VSTD::move(__s)) {} + : __pn_(std::move(__s)) {} template > path(const _Source& __src, format = format::auto_format) { @@ -827,19 +827,19 @@ _LIBCPP_INLINE_VISIBILITY path& operator=(path&& __p) noexcept { - __pn_ = _VSTD::move(__p.__pn_); + __pn_ = std::move(__p.__pn_); return *this; } template _LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept { - __pn_ = _VSTD::move(__s); + __pn_ = std::move(__s); return *this; } _LIBCPP_INLINE_VISIBILITY path& assign(string_type&& __s) noexcept { - __pn_ = _VSTD::move(__s); + __pn_ = std::move(__s); return *this; } @@ -1415,7 +1415,7 @@ #else void __throw_filesystem_error(_Args&&...) { - _VSTD::abort(); + std::abort(); } #endif @@ -2428,7 +2428,7 @@ class __dir_element_proxy { public: inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() { - return _VSTD::move(__elem_); + return std::move(__elem_); } private: @@ -2436,7 +2436,7 @@ friend class recursive_directory_iterator; explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {} __dir_element_proxy(__dir_element_proxy&& __o) - : __elem_(_VSTD::move(__o.__elem_)) {} + : __elem_(std::move(__o.__elem_)) {} directory_entry __elem_; }; @@ -2472,7 +2472,7 @@ directory_iterator& operator=(directory_iterator&& __o) noexcept { // non-default implementation provided to support self-move assign. if (this != &__o) { - __imp_ = _VSTD::move(__o.__imp_); + __imp_ = std::move(__o.__imp_); } return *this; } @@ -2577,7 +2577,7 @@ operator=(recursive_directory_iterator&& __o) noexcept { // non-default implementation provided to support self-move assign. if (this != &__o) { - __imp_ = _VSTD::move(__o.__imp_); + __imp_ = std::move(__o.__imp_); __rec_ = __o.__rec_; } return *this; Index: include/forward_list =================================================================== --- include/forward_list +++ include/forward_list @@ -549,7 +549,7 @@ _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__forward_list_base& __x, true_type) _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) - {__alloc() = _VSTD::move(__x.__alloc());} + {__alloc() = std::move(__x.__alloc());} }; #ifndef _LIBCPP_CXX03_LANG @@ -558,7 +558,7 @@ inline __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x) _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value) - : __before_begin_(_VSTD::move(__x.__before_begin_)) + : __before_begin_(std::move(__x.__before_begin_)) { __x.__before_begin()->__next_ = nullptr; } @@ -597,7 +597,7 @@ { __swap_allocator(__alloc(), __x.__alloc(), integral_constant()); - using _VSTD::swap; + using std::swap; swap(__before_begin()->__next_, __x.__before_begin()->__next_); } @@ -609,7 +609,7 @@ for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;) { __node_pointer __next = __p->__next_; - __node_traits::destroy(__a, _VSTD::addressof(__p->__value_)); + __node_traits::destroy(__a, std::addressof(__p->__value_)); __node_traits::deallocate(__a, __p, 1); __p = __next; } @@ -676,7 +676,7 @@ _LIBCPP_INLINE_VISIBILITY forward_list(forward_list&& __x) _NOEXCEPT_(is_nothrow_move_constructible::value) - : base(_VSTD::move(__x)) {} + : base(std::move(__x)) {} forward_list(forward_list&& __x, const allocator_type& __a); forward_list(initializer_list __il); @@ -828,7 +828,7 @@ template _LIBCPP_INLINE_VISIBILITY void merge(forward_list&& __x, _Compare __comp) - {merge(__x, _VSTD::move(__comp));} + {merge(__x, std::move(__comp));} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY void merge(forward_list& __x) {merge(__x, __less());} @@ -893,7 +893,7 @@ __p = __p->__next_as_begin()) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_)); + __node_traits::construct(__a, std::addressof(__h->__value_)); __h->__next_ = nullptr; __p->__next_ = __h.release(); } @@ -915,7 +915,7 @@ __p = __p->__next_as_begin()) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_)); + __node_traits::construct(__a, std::addressof(__h->__value_)); __h->__next_ = nullptr; __p->__next_ = __h.release(); } @@ -990,7 +990,7 @@ template forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x, const allocator_type& __a) - : base(_VSTD::move(__x), __a) + : base(std::move(__x), __a) { if (base::__alloc() != __x.__alloc()) { @@ -1071,7 +1071,7 @@ forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l) { iterator __i = before_begin(); - iterator __j = _VSTD::next(__i); + iterator __j = std::next(__i); iterator __e = end(); for (; __j != __e && __f != __l; ++__i, (void) ++__j, ++__f) *__j = *__f; @@ -1086,7 +1086,7 @@ forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v) { iterator __i = before_begin(); - iterator __j = _VSTD::next(__i); + iterator __j = std::next(__i); iterator __e = end(); for (; __j != __e && __n > 0; --__n, ++__i, ++__j) *__j = __v; @@ -1118,8 +1118,8 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), - _VSTD::forward<_Args>(__args)...); + __node_traits::construct(__a, std::addressof(__h->__value_), + std::forward<_Args>(__args)...); __h->__next_ = base::__before_begin()->__next_; base::__before_begin()->__next_ = __h.release(); #if _LIBCPP_STD_VER > 14 @@ -1134,7 +1134,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v)); + __node_traits::construct(__a, std::addressof(__h->__value_), std::move(__v)); __h->__next_ = base::__before_begin()->__next_; base::__before_begin()->__next_ = __h.release(); } @@ -1148,7 +1148,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); + __node_traits::construct(__a, std::addressof(__h->__value_), __v); __h->__next_ = base::__before_begin()->__next_; base::__before_begin()->__next_ = __h.release(); } @@ -1160,7 +1160,7 @@ __node_allocator& __a = base::__alloc(); __node_pointer __p = base::__before_begin()->__next_; base::__before_begin()->__next_ = __p->__next_; - __node_traits::destroy(__a, _VSTD::addressof(__p->__value_)); + __node_traits::destroy(__a, std::addressof(__p->__value_)); __node_traits::deallocate(__a, __p, 1); } @@ -1175,8 +1175,8 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), - _VSTD::forward<_Args>(__args)...); + __node_traits::construct(__a, std::addressof(__h->__value_), + std::forward<_Args>(__args)...); __h->__next_ = __r->__next_; __r->__next_ = __h.release(); return iterator(__r->__next_); @@ -1190,7 +1190,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v)); + __node_traits::construct(__a, std::addressof(__h->__value_), std::move(__v)); __h->__next_ = __r->__next_; __r->__next_ = __h.release(); return iterator(__r->__next_); @@ -1206,7 +1206,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); + __node_traits::construct(__a, std::addressof(__h->__value_), __v); __h->__next_ = __r->__next_; __r->__next_ = __h.release(); return iterator(__r->__next_); @@ -1223,7 +1223,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); + __node_traits::construct(__a, std::addressof(__h->__value_), __v); __node_pointer __first = __h.release(); __node_pointer __last = __first; #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1233,7 +1233,7 @@ for (--__n; __n != 0; --__n, __last = __last->__next_) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); + __node_traits::construct(__a, std::addressof(__h->__value_), __v); __last->__next_ = __h.release(); } #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1243,7 +1243,7 @@ while (__first != nullptr) { __node_pointer __next = __first->__next_; - __node_traits::destroy(__a, _VSTD::addressof(__first->__value_)); + __node_traits::destroy(__a, std::addressof(__first->__value_)); __node_traits::deallocate(__a, __first, 1); __first = __next; } @@ -1273,7 +1273,7 @@ __node_allocator& __a = base::__alloc(); typedef __allocator_destructor<__node_allocator> _Dp; unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f); + __node_traits::construct(__a, std::addressof(__h->__value_), *__f); __node_pointer __first = __h.release(); __node_pointer __last = __first; #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1283,7 +1283,7 @@ for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_))) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f); + __node_traits::construct(__a, std::addressof(__h->__value_), *__f); __last->__next_ = __h.release(); } #ifndef _LIBCPP_NO_EXCEPTIONS @@ -1293,7 +1293,7 @@ while (__first != nullptr) { __node_pointer __next = __first->__next_; - __node_traits::destroy(__a, _VSTD::addressof(__first->__value_)); + __node_traits::destroy(__a, std::addressof(__first->__value_)); __node_traits::deallocate(__a, __first, 1); __first = __next; } @@ -1315,7 +1315,7 @@ __node_pointer __n = __p->__next_; __p->__next_ = __n->__next_; __node_allocator& __a = base::__alloc(); - __node_traits::destroy(__a, _VSTD::addressof(__n->__value_)); + __node_traits::destroy(__a, std::addressof(__n->__value_)); __node_traits::deallocate(__a, __n, 1); return iterator(__p->__next_); } @@ -1337,7 +1337,7 @@ do { __node_pointer __tmp = __n->__next_; - __node_traits::destroy(__a, _VSTD::addressof(__n->__value_)); + __node_traits::destroy(__a, std::addressof(__n->__value_)); __node_traits::deallocate(__a, __n, 1); __n = __tmp; } while (__n != __e); @@ -1370,7 +1370,7 @@ __ptr = __ptr->__next_as_begin()) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_)); + __node_traits::construct(__a, std::addressof(__h->__value_)); __h->__next_ = nullptr; __ptr->__next_ = __h.release(); } @@ -1402,7 +1402,7 @@ __ptr = __ptr->__next_as_begin()) { __h.reset(__node_traits::allocate(__a, 1)); - __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); + __node_traits::construct(__a, std::addressof(__h->__value_), __v); __h->__next_ = nullptr; __ptr->__next_ = __h.release(); } @@ -1435,7 +1435,7 @@ forward_list& /*__other*/, const_iterator __i) { - const_iterator __lm1 = _VSTD::next(__i); + const_iterator __lm1 = std::next(__i); if (__p != __i && __p != __lm1) { __i.__get_begin()->__next_ = __lm1.__get_begin()->__next_; @@ -1507,7 +1507,7 @@ { if (__i.__get_begin()->__next_->__value_ == __v) { - iterator __j = _VSTD::next(__i, 2); + iterator __j = std::next(__i, 2); for (; __j != __e && *__j == __v; ++__j) ; __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j); @@ -1530,7 +1530,7 @@ { if (__pred(__i.__get_begin()->__next_->__value_)) { - iterator __j = _VSTD::next(__i, 2); + iterator __j = std::next(__i, 2); for (; __j != __e && __pred(*__j); ++__j) ; erase_after(__i, __j); @@ -1550,7 +1550,7 @@ { for (iterator __i = begin(), __e = end(); __i != __e;) { - iterator __j = _VSTD::next(__i); + iterator __j = std::next(__i); for (; __j != __e && __binary_pred(*__i, *__j); ++__j) ; if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer()) @@ -1625,7 +1625,7 @@ forward_list<_Tp, _Alloc>::sort(_Compare __comp) { base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_, - _VSTD::distance(begin(), end()), __comp); + std::distance(begin(), end()), __comp); } template @@ -1651,7 +1651,7 @@ } difference_type __sz1 = __sz / 2; difference_type __sz2 = __sz - __sz1; - __node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer(); + __node_pointer __t = std::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer(); __node_pointer __f2 = __t->__next_; __t->__next_ = nullptr; return __merge(__sort(__f1, __sz1, __comp), @@ -1707,7 +1707,7 @@ bool operator< (const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } Index: include/fstream =================================================================== --- include/fstream +++ include/fstream @@ -416,9 +416,9 @@ basic_streambuf::swap(__rhs); if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) { - _VSTD::swap(__extbuf_, __rhs.__extbuf_); - _VSTD::swap(__extbufnext_, __rhs.__extbufnext_); - _VSTD::swap(__extbufend_, __rhs.__extbufend_); + std::swap(__extbuf_, __rhs.__extbuf_); + std::swap(__extbufnext_, __rhs.__extbufnext_); + std::swap(__extbufend_, __rhs.__extbufend_); } else { @@ -441,18 +441,18 @@ __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln; __rhs.__extbufend_ = __rhs.__extbuf_ + __le; } - _VSTD::swap(__ebs_, __rhs.__ebs_); - _VSTD::swap(__intbuf_, __rhs.__intbuf_); - _VSTD::swap(__ibs_, __rhs.__ibs_); - _VSTD::swap(__file_, __rhs.__file_); - _VSTD::swap(__cv_, __rhs.__cv_); - _VSTD::swap(__st_, __rhs.__st_); - _VSTD::swap(__st_last_, __rhs.__st_last_); - _VSTD::swap(__om_, __rhs.__om_); - _VSTD::swap(__cm_, __rhs.__cm_); - _VSTD::swap(__owns_eb_, __rhs.__owns_eb_); - _VSTD::swap(__owns_ib_, __rhs.__owns_ib_); - _VSTD::swap(__always_noconv_, __rhs.__always_noconv_); + std::swap(__ebs_, __rhs.__ebs_); + std::swap(__intbuf_, __rhs.__intbuf_); + std::swap(__ibs_, __rhs.__ibs_); + std::swap(__file_, __rhs.__file_); + std::swap(__cv_, __rhs.__cv_); + std::swap(__st_, __rhs.__st_); + std::swap(__st_last_, __rhs.__st_last_); + std::swap(__om_, __rhs.__om_); + std::swap(__cm_, __rhs.__cm_); + std::swap(__owns_eb_, __rhs.__owns_eb_); + std::swap(__owns_ib_, __rhs.__owns_ib_); + std::swap(__always_noconv_, __rhs.__always_noconv_); if (this->eback() == (char_type*)__rhs.__extbuf_min_) { ptrdiff_t __n = this->gptr() - this->eback(); @@ -740,7 +740,7 @@ memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); - size_t __nmemb = _VSTD::min(static_cast(__ibs_ - __unget_sz), + size_t __nmemb = std::min(static_cast(__ibs_ - __unget_sz), static_cast(__extbufend_ - __extbufnext_)); codecvt_base::result __r; __st_last_ = __st_; @@ -1237,8 +1237,8 @@ template inline basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs) - : basic_istream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_istream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { this->set_rdbuf(&__sb_); } @@ -1248,8 +1248,8 @@ basic_ifstream<_CharT, _Traits>& basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) { - basic_istream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_istream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } @@ -1450,8 +1450,8 @@ template inline basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs) - : basic_ostream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_ostream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { this->set_rdbuf(&__sb_); } @@ -1461,8 +1461,8 @@ basic_ofstream<_CharT, _Traits>& basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) { - basic_ostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_ostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } @@ -1663,8 +1663,8 @@ template inline basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs) - : basic_iostream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_iostream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { this->set_rdbuf(&__sb_); } @@ -1674,8 +1674,8 @@ basic_fstream<_CharT, _Traits>& basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) { - basic_iostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_iostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } Index: include/functional =================================================================== --- include/functional +++ include/functional @@ -523,9 +523,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) + std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) + std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) + std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -550,9 +550,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) - std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) - std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) - std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -577,9 +577,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) * std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) * std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) * std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -604,9 +604,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) / std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) / std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) / std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -631,9 +631,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) % std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) % std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) % std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -658,9 +658,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - _NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x))) - -> decltype (- _VSTD::forward<_Tp>(__x)) - { return - _VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(- std::forward<_Tp>(__x))) + -> decltype (- std::forward<_Tp>(__x)) + { return - std::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -685,9 +685,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) == std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) == std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) == std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -712,9 +712,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) != std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) != std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) != std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -739,9 +739,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) > std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) > std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) > std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -768,9 +768,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) >= std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) >= std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) >= std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -795,9 +795,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) <= std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) <= std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) <= std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -822,9 +822,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) && std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) && std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) && std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -849,9 +849,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) || std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) || std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) || std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -876,9 +876,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - _NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x))) - -> decltype (!_VSTD::forward<_Tp>(__x)) - { return !_VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(!std::forward<_Tp>(__x))) + -> decltype (!std::forward<_Tp>(__x)) + { return !std::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -903,9 +903,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) & std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) & std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) & std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -930,9 +930,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) | std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) | std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) | std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -957,9 +957,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_T1&& __t, _T2&& __u) const - _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) - -> decltype (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) - { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } + _NOEXCEPT_(noexcept(std::forward<_T1>(__t) ^ std::forward<_T2>(__u))) + -> decltype (std::forward<_T1>(__t) ^ std::forward<_T2>(__u)) + { return std::forward<_T1>(__t) ^ std::forward<_T2>(__u); } typedef void is_transparent; }; #endif @@ -980,9 +980,9 @@ template _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY auto operator()(_Tp&& __x) const - _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x))) - -> decltype (~_VSTD::forward<_Tp>(__x)) - { return ~_VSTD::forward<_Tp>(__x); } + _NOEXCEPT_(noexcept(~std::forward<_Tp>(__x))) + -> decltype (~std::forward<_Tp>(__x)) + { return ~std::forward<_Tp>(__x); } typedef void is_transparent; }; #endif @@ -1285,7 +1285,7 @@ _LIBCPP_INLINE_VISIBILITY typename __invoke_return::type operator() (_ArgTypes&&... __args) const { - return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...); + return __invoke(__f_, std::forward<_ArgTypes>(__args)...); } #else @@ -1420,7 +1420,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_function_call(); #else - _VSTD::abort(); + std::abort(); #endif } @@ -1494,29 +1494,29 @@ _LIBCPP_INLINE_VISIBILITY explicit __alloc_func(_Target&& __f) - : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), - _VSTD::forward_as_tuple()) + : __f_(piecewise_construct, std::forward_as_tuple(std::move(__f)), + std::forward_as_tuple()) { } _LIBCPP_INLINE_VISIBILITY explicit __alloc_func(const _Target& __f, const _Alloc& __a) - : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), - _VSTD::forward_as_tuple(__a)) + : __f_(piecewise_construct, std::forward_as_tuple(__f), + std::forward_as_tuple(__a)) { } _LIBCPP_INLINE_VISIBILITY explicit __alloc_func(const _Target& __f, _Alloc&& __a) - : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f), - _VSTD::forward_as_tuple(_VSTD::move(__a))) + : __f_(piecewise_construct, std::forward_as_tuple(__f), + std::forward_as_tuple(std::move(__a))) { } _LIBCPP_INLINE_VISIBILITY explicit __alloc_func(_Target&& __f, _Alloc&& __a) - : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)), - _VSTD::forward_as_tuple(_VSTD::move(__a))) + : __f_(piecewise_construct, std::forward_as_tuple(std::move(__f)), + std::forward_as_tuple(std::move(__a))) { } @@ -1525,7 +1525,7 @@ { typedef __invoke_void_return_wrapper<_Rp> _Invoker; return _Invoker::__call(__f_.first(), - _VSTD::forward<_ArgTypes>(__arg)...); + std::forward<_ArgTypes>(__arg)...); } _LIBCPP_INLINE_VISIBILITY @@ -1581,7 +1581,7 @@ public: _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp&& __f) - : __f_(_VSTD::move(__f)) {} + : __f_(std::move(__f)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(const _Fp& __f, const _Alloc& __a) @@ -1589,11 +1589,11 @@ _LIBCPP_INLINE_VISIBILITY explicit __func(const _Fp& __f, _Alloc&& __a) - : __f_(__f, _VSTD::move(__a)) {} + : __f_(__f, std::move(__a)) {} _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp&& __f, _Alloc&& __a) - : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} + : __f_(std::move(__f), std::move(__a)) {} virtual __base<_Rp(_ArgTypes...)>* __clone() const; virtual void __clone(__base<_Rp(_ArgTypes...)>*) const; @@ -1648,7 +1648,7 @@ _Rp __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) { - return __f_(_VSTD::forward<_ArgTypes>(__arg)...); + return __f_(std::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI @@ -1708,13 +1708,13 @@ is_nothrow_copy_constructible<_FunAlloc>::value) { __f_ = - ::new ((void*)&__buf_) _Fun(_VSTD::move(__f), _Alloc(__af)); + ::new ((void*)&__buf_) _Fun(std::move(__f), _Alloc(__af)); } else { typedef __allocator_destructor<_FunAlloc> _Dp; unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); - ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f), _Alloc(__a)); + ::new ((void*)__hold.get()) _Fun(std::move(__f), _Alloc(__a)); __f_ = __hold.release(); } } @@ -1796,7 +1796,7 @@ { if (__f_ == 0) __throw_bad_function_call(); - return (*__f_)(_VSTD::forward<_ArgTypes>(__args)...); + return (*__f_)(std::forward<_ArgTypes>(__args)...); } _LIBCPP_INLINE_VISIBILITY @@ -1834,7 +1834,7 @@ __f_ = __as_base(&__buf_); } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } _LIBCPP_INLINE_VISIBILITY @@ -1870,11 +1870,11 @@ // True if _Fun can safely be held in __policy_storage.__small. template struct __use_small_storage - : public _VSTD::integral_constant< + : public std::integral_constant< bool, sizeof(_Fun) <= sizeof(__policy_storage) && alignof(_Fun) <= alignof(__policy_storage) && - _VSTD::is_trivially_copy_constructible<_Fun>::value && - _VSTD::is_trivially_destructible<_Fun>::value> {}; + std::is_trivially_copy_constructible<_Fun>::value && + std::is_trivially_destructible<_Fun>::value> {}; // Policy contains information about how to copy, destroy, and move the // underlying functor. You can think of it as a vtable of sorts. @@ -1965,7 +1965,7 @@ // faster for types that can be passed in registers. template using __fast_forward = - typename _VSTD::conditional<_VSTD::is_scalar<_Tp>::value, _Tp, _Tp&&>::type; + typename std::conditional::value, _Tp, _Tp&&>::type; // __policy_invoker calls an instance of __alloc_func held in __policy_storage. @@ -2007,7 +2007,7 @@ _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value ? &__buf->__small : __buf->__large); - return (*__f)(_VSTD::forward<_ArgTypes>(__args)...); + return (*__f)(std::forward<_ArgTypes>(__args)...); } }; @@ -2053,14 +2053,14 @@ if (__use_small_storage<_Fun>()) { ::new ((void*)&__buf_.__small) - _Fun(_VSTD::move(__f), _Alloc(__af)); + _Fun(std::move(__f), _Alloc(__af)); } else { typedef __allocator_destructor<_FunAlloc> _Dp; unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1)); ::new ((void*)__hold.get()) - _Fun(_VSTD::move(__f), _Alloc(__af)); + _Fun(std::move(__f), _Alloc(__af)); __buf_.__large = __hold.release(); } } @@ -2120,16 +2120,16 @@ _LIBCPP_INLINE_VISIBILITY _Rp operator()(_ArgTypes&&... __args) const { - return __invoker_.__call_(_VSTD::addressof(__buf_), - _VSTD::forward<_ArgTypes>(__args)...); + return __invoker_.__call_(std::addressof(__buf_), + std::forward<_ArgTypes>(__args)...); } _LIBCPP_INLINE_VISIBILITY void swap(__policy_func& __f) { - _VSTD::swap(__invoker_, __f.__invoker_); - _VSTD::swap(__policy_, __f.__policy_); - _VSTD::swap(__buf_, __f.__buf_); + std::swap(__invoker_, __f.__invoker_); + std::swap(__policy_, __f.__policy_); + std::swap(__buf_, __f.__buf_); } _LIBCPP_INLINE_VISIBILITY @@ -2236,7 +2236,7 @@ template _LIBCPP_INLINE_VISIBILITY void assign(_Fp&& __f, const _Alloc& __a) - {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);} + {function(allocator_arg, __a, std::forward<_Fp>(__f)).swap(*this);} #endif // function capacity: @@ -2274,27 +2274,27 @@ template function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT - : __f_(_VSTD::move(__f.__f_)) {} + : __f_(std::move(__f.__f_)) {} #if _LIBCPP_STD_VER <= 14 template template function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, function&& __f) - : __f_(_VSTD::move(__f.__f_)) {} + : __f_(std::move(__f.__f_)) {} #endif template template function<_Rp(_ArgTypes...)>::function(_Fp __f) - : __f_(_VSTD::move(__f), allocator<_Fp>()) {} + : __f_(std::move(__f), allocator<_Fp>()) {} #if _LIBCPP_STD_VER <= 14 template template function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a, _Fp __f) - : __f_(_VSTD::move(__f), __a) {} + : __f_(std::move(__f), __a) {} #endif template @@ -2326,7 +2326,7 @@ function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) { - function(_VSTD::forward<_Fp>(__f)).swap(*this); + function(std::forward<_Fp>(__f)).swap(*this); return *this; } @@ -2344,7 +2344,7 @@ _Rp function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const { - return __f_(_VSTD::forward<_ArgTypes>(__arg)...); + return __f_(std::forward<_ArgTypes>(__arg)...); } #ifndef _LIBCPP_NO_RTTI @@ -2479,7 +2479,7 @@ typename __invoke_of<_Ti&, _Uj...>::type __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) { - return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...); + return __ti(std::forward<_Uj>(std::get<_Indx>(__uj))...); } template @@ -2514,7 +2514,7 @@ __mu(_Ti&, _Uj& __uj) { const size_t _Indx = is_placeholder<_Ti>::value - 1; - return _VSTD::forward::type>(_VSTD::get<_Indx>(__uj)); + return std::forward::type>(std::get<_Indx>(__uj)); } template @@ -2641,7 +2641,7 @@ __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) { - return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...); + return std::__invoke(__f, std::__mu(std::get<_Indx>(__bound_args), __args)...); } template @@ -2666,16 +2666,16 @@ >::type> _LIBCPP_INLINE_VISIBILITY explicit __bind(_Gp&& __f, _BA&& ...__bound_args) - : __f_(_VSTD::forward<_Gp>(__f)), - __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} + : __f_(std::forward<_Gp>(__f)), + __bound_args_(std::forward<_BA>(__bound_args)...) {} template _LIBCPP_INLINE_VISIBILITY typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type operator()(_Args&& ...__args) { - return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), - tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); + return std::__apply_functor(__f_, __bound_args_, __indices(), + tuple<_Args&&...>(std::forward<_Args>(__args)...)); } template @@ -2683,8 +2683,8 @@ typename __bind_return >::type operator()(_Args&& ...__args) const { - return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), - tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); + return std::__apply_functor(__f_, __bound_args_, __indices(), + tuple<_Args&&...>(std::forward<_Args>(__args)...)); } }; @@ -2711,8 +2711,8 @@ >::type> _LIBCPP_INLINE_VISIBILITY explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) - : base(_VSTD::forward<_Gp>(__f), - _VSTD::forward<_BA>(__bound_args)...) {} + : base(std::forward<_Gp>(__f), + std::forward<_BA>(__bound_args)...) {} template _LIBCPP_INLINE_VISIBILITY @@ -2725,7 +2725,7 @@ operator()(_Args&& ...__args) { typedef __invoke_void_return_wrapper<_Rp> _Invoker; - return _Invoker::__call(static_cast(*this), _VSTD::forward<_Args>(__args)...); + return _Invoker::__call(static_cast(*this), std::forward<_Args>(__args)...); } template @@ -2739,7 +2739,7 @@ operator()(_Args&& ...__args) const { typedef __invoke_void_return_wrapper<_Rp> _Invoker; - return _Invoker::__call(static_cast(*this), _VSTD::forward<_Args>(__args)...); + return _Invoker::__call(static_cast(*this), std::forward<_Args>(__args)...); } }; @@ -2752,7 +2752,7 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind<_Fp, _BoundArgs...> type; - return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); + return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...); } template @@ -2761,7 +2761,7 @@ bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; - return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); + return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...); } #endif // _LIBCPP_CXX03_LANG @@ -2771,9 +2771,9 @@ template result_of_t<_Fn&&(_Args&&...)> invoke(_Fn&& __f, _Args&&... __args) - noexcept(noexcept(_VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...))) + noexcept(noexcept(std::__invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...))) { - return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); + return std::__invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...); } template @@ -2786,38 +2786,38 @@ template _LIBCPP_INLINE_VISIBILITY auto operator()(_Args&& ...__args) & - noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))) - -> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)) - { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); } + noexcept(noexcept(!std::invoke(__fd, std::forward<_Args>(__args)...))) + -> decltype( !std::invoke(__fd, std::forward<_Args>(__args)...)) + { return !std::invoke(__fd, std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY auto operator()(_Args&& ...__args) && - noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))) - -> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)) - { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); } + noexcept(noexcept(!std::invoke(std::move(__fd), std::forward<_Args>(__args)...))) + -> decltype( !std::invoke(std::move(__fd), std::forward<_Args>(__args)...)) + { return !std::invoke(std::move(__fd), std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY auto operator()(_Args&& ...__args) const& - noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))) - -> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)) - { return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); } + noexcept(noexcept(!std::invoke(__fd, std::forward<_Args>(__args)...))) + -> decltype( !std::invoke(__fd, std::forward<_Args>(__args)...)) + { return !std::invoke(__fd, std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY auto operator()(_Args&& ...__args) const&& - noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))) - -> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)) - { return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); } + noexcept(noexcept(!std::invoke(std::move(__fd), std::forward<_Args>(__args)...))) + -> decltype( !std::invoke(std::move(__fd), std::forward<_Args>(__args)...)) + { return !std::invoke(std::move(__fd), std::forward<_Args>(__args)...); } private: template , __not_fn_imp>::value>> _LIBCPP_INLINE_VISIBILITY explicit __not_fn_imp(_RawFunc&& __rf) - : __fd(_VSTD::forward<_RawFunc>(__rf)) {} + : __fd(std::forward<_RawFunc>(__rf)) {} template friend inline _LIBCPP_INLINE_VISIBILITY @@ -2827,7 +2827,7 @@ template inline _LIBCPP_INLINE_VISIBILITY __not_fn_imp> not_fn(_RawFunc&& __fn) { - return __not_fn_imp>(_VSTD::forward<_RawFunc>(__fn)); + return __not_fn_imp>(std::forward<_RawFunc>(__fn)); } #endif @@ -2932,9 +2932,9 @@ pair<_ForwardIterator2, _ForwardIterator2> operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const { - return _VSTD::__search(__f, __l, __first_, __last_, __pred_, - typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(), - typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category()); + return std::__search(__f, __l, __first_, __last_, __pred_, + typename std::iterator_traits<_ForwardIterator>::iterator_category(), + typename std::iterator_traits<_ForwardIterator2>::iterator_category()); } private: Index: include/future =================================================================== --- include/future +++ include/future @@ -524,7 +524,7 @@ throw future_error(make_error_code(_Ev)); #else ((void)_Ev); - _VSTD::abort(); + std::abort(); #endif } @@ -667,7 +667,7 @@ unique_lock __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); - ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); + ::new(&__value_) _Rp(std::forward<_Arg>(__arg)); this->__state_ |= base::__constructed | base::ready; __cv_.notify_all(); } @@ -684,7 +684,7 @@ unique_lock __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); - ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); + ::new(&__value_) _Rp(std::forward<_Arg>(__arg)); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this); } @@ -697,7 +697,7 @@ this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); - return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_)); + return std::move(*reinterpret_cast<_Rp*>(&__value_)); } template @@ -743,7 +743,7 @@ unique_lock __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); - __value_ = _VSTD::addressof(__arg); + __value_ = std::addressof(__arg); this->__state_ |= base::__constructed | base::ready; __cv_.notify_all(); } @@ -755,7 +755,7 @@ unique_lock __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); - __value_ = _VSTD::addressof(__arg); + __value_ = std::addressof(__arg); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this); } @@ -790,7 +790,7 @@ __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT { if (this->__state_ & base::__constructed) - reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp(); + reinterpret_cast<_Rp*>(std::addressof(this->__value_))->~_Rp(); typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; typedef allocator_traits<_Al> _ATraits; typedef pointer_traits _PTraits; @@ -873,7 +873,7 @@ template inline __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) - : __func_(_VSTD::forward<_Fp>(__f)) + : __func_(std::forward<_Fp>(__f)) { this->__set_deferred(); } @@ -920,7 +920,7 @@ template inline __deferred_assoc_state::__deferred_assoc_state(_Fp&& __f) - : __func_(_VSTD::forward<_Fp>(__f)) + : __func_(std::forward<_Fp>(__f)) { this->__set_deferred(); } @@ -969,7 +969,7 @@ template inline __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) - : __func_(_VSTD::forward<_Fp>(__f)) + : __func_(std::forward<_Fp>(__f)) { } @@ -1024,7 +1024,7 @@ template inline __async_assoc_state::__async_assoc_state(_Fp&& __f) - : __func_(_VSTD::forward<_Fp>(__f)) + : __func_(std::forward<_Fp>(__f)) { } @@ -1131,7 +1131,7 @@ _Rp get(); _LIBCPP_INLINE_VISIBILITY - void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -1231,7 +1231,7 @@ _Rp& get(); _LIBCPP_INLINE_VISIBILITY - void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -1326,7 +1326,7 @@ void get(); _LIBCPP_INLINE_VISIBILITY - void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -1398,7 +1398,7 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(promise& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // retrieving the result future<_Rp> get_future(); @@ -1433,8 +1433,8 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); - ::new(static_cast(_VSTD::addressof(*__hold.get()))) _State(__a0); - __state_ = _VSTD::addressof(*__hold.release()); + ::new(static_cast(std::addressof(*__hold.get()))) _State(__a0); + __state_ = std::addressof(*__hold.release()); } template @@ -1476,7 +1476,7 @@ { if (__state_ == nullptr) __throw_future_error(future_errc::no_state); - __state_->set_value(_VSTD::move(__r)); + __state_->set_value(std::move(__r)); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1508,7 +1508,7 @@ { if (__state_ == nullptr) __throw_future_error(future_errc::no_state); - __state_->set_value_at_thread_exit(_VSTD::move(__r)); + __state_->set_value_at_thread_exit(std::move(__r)); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1566,7 +1566,7 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(promise& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // retrieving the result future<_Rp&> get_future(); @@ -1595,8 +1595,8 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); - ::new(static_cast(_VSTD::addressof(*__hold.get()))) _State(__a0); - __state_ = _VSTD::addressof(*__hold.release()); + ::new(static_cast(std::addressof(*__hold.get()))) _State(__a0); + __state_ = std::addressof(*__hold.release()); } template @@ -1703,7 +1703,7 @@ public: #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY - void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(promise& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // retrieving the result future get_future(); @@ -1725,8 +1725,8 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); - ::new(static_cast(_VSTD::addressof(*__hold.get()))) _State(__a0); - __state_ = _VSTD::addressof(*__hold.release()); + ::new(static_cast(std::addressof(*__hold.get()))) _State(__a0); + __state_ = std::addressof(*__hold.release()); } template @@ -1774,13 +1774,13 @@ _LIBCPP_INLINE_VISIBILITY explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY - explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {} + explicit __packaged_task_func(_Fp&& __f) : __f_(std::move(__f)) {} _LIBCPP_INLINE_VISIBILITY __packaged_task_func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {} _LIBCPP_INLINE_VISIBILITY __packaged_task_func(_Fp&& __f, const _Alloc& __a) - : __f_(_VSTD::move(__f), __a) {} + : __f_(std::move(__f), __a) {} virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT; virtual void destroy(); virtual void destroy_deallocate(); @@ -1792,7 +1792,7 @@ __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to( __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT { - ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second())); + ::new (__p) __packaged_task_func(std::move(__f_.first()), std::move(__f_.second())); } template @@ -1818,7 +1818,7 @@ _Rp __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) { - return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); + return __invoke(__f_.first(), std::forward<_ArgTypes>(__arg)...); } template class __packaged_task_function; @@ -1882,7 +1882,7 @@ if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); + ::new (__f_) _FF(std::forward<_Fp>(__f)); } else { @@ -1890,7 +1890,7 @@ _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); - ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a)); + ::new (__hold.get()) _FF(std::forward<_Fp>(__f), allocator<_FR>(__a)); __f_ = __hold.release(); } } @@ -1906,7 +1906,7 @@ if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; - ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); + ::new (__f_) _FF(std::forward<_Fp>(__f)); } else { @@ -1914,9 +1914,9 @@ _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); - ::new (static_cast(_VSTD::addressof(*__hold.get()))) - _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a)); - __f_ = _VSTD::addressof(*__hold.release()); + ::new (static_cast(std::addressof(*__hold.get()))) + _FF(std::forward<_Fp>(__f), _Alloc(__a)); + __f_ = std::addressof(*__hold.release()); } } @@ -1987,7 +1987,7 @@ __f_ = (__base*)&__buf_; } else - _VSTD::swap(__f_, __f.__f_); + std::swap(__f_, __f.__f_); } template @@ -1995,7 +1995,7 @@ _Rp __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const { - return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); + return (*__f_)(std::forward<_ArgTypes>(__arg)...); } template @@ -2022,7 +2022,7 @@ >::type > _LIBCPP_INLINE_VISIBILITY - explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} + explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {} template _LIBCPP_INLINE_VISIBILITY packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) - : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), + : __f_(allocator_arg, __a, std::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; @@ -2045,12 +2045,12 @@ // move support _LIBCPP_INLINE_VISIBILITY packaged_task(packaged_task&& __other) _NOEXCEPT - : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} + : __f_(std::move(__other.__f_)), __p_(std::move(__other.__p_)) {} _LIBCPP_INLINE_VISIBILITY packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { - __f_ = _VSTD::move(__other.__f_); - __p_ = _VSTD::move(__other.__p_); + __f_ = std::move(__other.__f_); + __p_ = std::move(__other.__p_); return *this; } _LIBCPP_INLINE_VISIBILITY @@ -2086,7 +2086,7 @@ try { #endif // _LIBCPP_NO_EXCEPTIONS - __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...)); + __p_.set_value(__f_(std::forward<_ArgTypes>(__args)...)); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -2108,7 +2108,7 @@ try { #endif // _LIBCPP_NO_EXCEPTIONS - __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...)); + __p_.set_value_at_thread_exit(__f_(std::forward<_ArgTypes>(__args)...)); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -2151,7 +2151,7 @@ >::type > _LIBCPP_INLINE_VISIBILITY - explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} + explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {} template _LIBCPP_INLINE_VISIBILITY packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) - : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), + : __f_(allocator_arg, __a, std::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; @@ -2174,12 +2174,12 @@ // move support _LIBCPP_INLINE_VISIBILITY packaged_task(packaged_task&& __other) _NOEXCEPT - : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} + : __f_(std::move(__other.__f_)), __p_(std::move(__other.__p_)) {} _LIBCPP_INLINE_VISIBILITY packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { - __f_ = _VSTD::move(__other.__f_); - __p_ = _VSTD::move(__other.__p_); + __f_ = std::move(__other.__f_); + __p_ = std::move(__other.__p_); return *this; } _LIBCPP_INLINE_VISIBILITY @@ -2215,7 +2215,7 @@ try { #endif // _LIBCPP_NO_EXCEPTIONS - __f_(_VSTD::forward<_ArgTypes>(__args)...); + __f_(std::forward<_ArgTypes>(__args)...); __p_.set_value(); #ifndef _LIBCPP_NO_EXCEPTIONS } @@ -2238,7 +2238,7 @@ try { #endif // _LIBCPP_NO_EXCEPTIONS - __f_(_VSTD::forward<_ArgTypes>(__args)...); + __f_(std::forward<_ArgTypes>(__args)...); __p_.set_value_at_thread_exit(); #ifndef _LIBCPP_NO_EXCEPTIONS } @@ -2279,7 +2279,7 @@ #endif { unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> - __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); + __h(new __deferred_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f))); return future<_Rp>(__h.get()); } @@ -2292,8 +2292,8 @@ #endif { unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> - __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); - _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach(); + __h(new __async_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f))); + std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach(); return future<_Rp>(__h.get()); } @@ -2307,10 +2307,10 @@ _LIBCPP_INLINE_VISIBILITY explicit __async_func(_Fp&& __f, _Args&&... __args) - : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {} + : __f_(std::move(__f), std::move(__args)...) {} _LIBCPP_INLINE_VISIBILITY - __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {} + __async_func(__async_func&& __f) : __f_(std::move(__f.__f_)) {} _Rp operator()() { @@ -2322,7 +2322,7 @@ _Rp __execute(__tuple_indices<_Indices...>) { - return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); + return __invoke(std::move(std::get<0>(__f_)), std::move(std::get<_Indices>(__f_))...); } }; @@ -2342,16 +2342,16 @@ { #endif if (__does_policy_contain(__policy, launch::async)) - return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), - __decay_copy(_VSTD::forward<_Args>(__args))...)); + return std::__make_async_assoc_state<_Rp>(_BF(__decay_copy(std::forward<_Fp>(__f)), + __decay_copy(std::forward<_Args>(__args))...)); #ifndef _LIBCPP_NO_EXCEPTIONS } catch ( ... ) { if (__policy == launch::async) throw ; } #endif if (__does_policy_contain(__policy, launch::deferred)) - return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), - __decay_copy(_VSTD::forward<_Args>(__args))...)); + return std::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(std::forward<_Fp>(__f)), + __decay_copy(std::forward<_Args>(__args))...)); return future<_Rp>{}; } @@ -2360,8 +2360,8 @@ future::type, typename decay<_Args>::type...>::type> async(_Fp&& __f, _Args&&... __args) { - return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f), - _VSTD::forward<_Args>(__args)...); + return std::async(launch::any, std::forward<_Fp>(__f), + std::forward<_Args>(__args)...); } #endif // _LIBCPP_HAS_NO_VARIADICS @@ -2403,7 +2403,7 @@ const _Rp& get() const {return __state_->copy();} _LIBCPP_INLINE_VISIBILITY - void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(shared_future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -2477,7 +2477,7 @@ _Rp& get() const {return __state_->copy();} _LIBCPP_INLINE_VISIBILITY - void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(shared_future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -2551,7 +2551,7 @@ void get() const {__state_->copy();} _LIBCPP_INLINE_VISIBILITY - void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} + void swap(shared_future& __rhs) _NOEXCEPT {std::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY @@ -2584,7 +2584,7 @@ shared_future<_Rp> future<_Rp>::share() _NOEXCEPT { - return shared_future<_Rp>(_VSTD::move(*this)); + return shared_future<_Rp>(std::move(*this)); } template @@ -2592,7 +2592,7 @@ shared_future<_Rp&> future<_Rp&>::share() _NOEXCEPT { - return shared_future<_Rp&>(_VSTD::move(*this)); + return shared_future<_Rp&>(std::move(*this)); } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -2601,7 +2601,7 @@ shared_future future::share() _NOEXCEPT { - return shared_future(_VSTD::move(*this)); + return shared_future(std::move(*this)); } #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES Index: include/iomanip =================================================================== --- include/iomanip +++ include/iomanip @@ -519,7 +519,7 @@ __quoted_output ( basic_ostream<_CharT, _Traits> &__os, _ForwardIterator __first, _ForwardIterator __last, _CharT __delim, _CharT __escape ) { - _VSTD::basic_string<_CharT, _Traits> __str; + std::basic_string<_CharT, _Traits> __str; __str.push_back(__delim); for ( ; __first != __last; ++ __first ) { Index: include/ios =================================================================== --- include/ios +++ include/ios @@ -274,8 +274,8 @@ typedef openmode open_mode; typedef seekdir seek_dir; - typedef _VSTD::streamoff streamoff; - typedef _VSTD::streampos streampos; + typedef std::streamoff streamoff; + typedef std::streampos streampos; #endif class _LIBCPP_TYPE_VIS Init; @@ -812,8 +812,8 @@ basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT { ios_base::swap(__rhs); - _VSTD::swap(__tie_, __rhs.__tie_); - _VSTD::swap(__fill_, __rhs.__fill_); + std::swap(__tie_, __rhs.__tie_); + std::swap(__fill_, __rhs.__fill_); } template Index: include/istream =================================================================== --- include/istream +++ include/istream @@ -202,7 +202,7 @@ inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_istream& __rhs) { - _VSTD::swap(__gc_, __rhs.__gc_); + std::swap(__gc_, __rhs.__gc_); basic_ios::swap(__rhs); } @@ -389,77 +389,77 @@ basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long long& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(float& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(double& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long double& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(bool& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(void*& __n) { - return _VSTD::__input_arithmetic(*this, __n); + return std::__input_arithmetic(*this, __n); } template @@ -506,14 +506,14 @@ basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(short& __n) { - return _VSTD::__input_arithmetic_with_numeric_limits(*this, __n); + return std::__input_arithmetic_with_numeric_limits(*this, __n); } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(int& __n) { - return _VSTD::__input_arithmetic_with_numeric_limits(*this, __n); + return std::__input_arithmetic_with_numeric_limits(*this, __n); } template @@ -570,8 +570,8 @@ { auto __n = _Np; if (__is.width() > 0) - __n = _VSTD::min(size_t(__is.width()), _Np); - return _VSTD::__input_c_string(__is, __buf, __n); + __n = std::min(size_t(__is.width()), _Np); + return std::__input_c_string(__is, __buf, __n); } template @@ -600,7 +600,7 @@ streamsize __n = __is.width(); if (__n <= 0) __n = numeric_limits::max() / sizeof(_CharT) - 1; - return _VSTD::__input_c_string(__is, __s, size_t(__n)); + return std::__input_c_string(__is, __s, size_t(__n)); } template @@ -1043,7 +1043,7 @@ case 0: break; default: - read(__s, _VSTD::min(__c, __n)); + read(__s, std::min(__c, __n)); break; } } @@ -1259,7 +1259,7 @@ basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp&& __x) { - __is >> _VSTD::forward<_Tp>(__x); + __is >> std::forward<_Tp>(__x); return __is; } @@ -1304,7 +1304,7 @@ template basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) - : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) + : basic_istream<_CharT, _Traits>(std::move(__rhs)) { } Index: include/iterator =================================================================== --- include/iterator +++ include/iterator @@ -620,7 +620,7 @@ next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) { - _VSTD::advance(__x, __n); + std::advance(__x, __n); return __x; } @@ -634,7 +634,7 @@ prev(_BidirectionalIter __x, typename iterator_traits<_BidirectionalIter>::difference_type __n = 1) { - _VSTD::advance(__x, -__n); + std::advance(__x, -__n); return __x; } @@ -685,7 +685,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference operator*() const {_Iter __tmp = current; return *--__tmp;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 - pointer operator->() const {return _VSTD::addressof(operator*());} + pointer operator->() const {return std::addressof(operator*());} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reverse_iterator& operator++() {--current; return *this;} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 @@ -803,12 +803,12 @@ public: typedef _Container container_type; - _LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} + _LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(std::addressof(__x)) {} _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value_) {container->push_back(__value_); return *this;} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value_) - {container->push_back(_VSTD::move(__value_)); return *this;} + {container->push_back(std::move(__value_)); return *this;} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++() {return *this;} @@ -836,12 +836,12 @@ public: typedef _Container container_type; - _LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} + _LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(std::addressof(__x)) {} _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_) {container->push_front(__value_); return *this;} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_) - {container->push_front(_VSTD::move(__value_)); return *this;} + {container->push_front(std::move(__value_)); return *this;} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;} @@ -871,12 +871,12 @@ typedef _Container container_type; _LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i) - : container(_VSTD::addressof(__x)), iter(__i) {} + : container(std::addressof(__x)), iter(__i) {} _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_) {iter = container->insert(iter, __value_); ++iter; return *this;} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_) - {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;} + {iter = container->insert(iter, std::move(__value_)); ++iter; return *this;} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY insert_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++() {return *this;} @@ -905,14 +905,14 @@ _Tp __value_; public: _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(0), __value_() {} - _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s)) + _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(std::addressof(__s)) { if (!(*__in_stream_ >> __value_)) __in_stream_ = 0; } _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;} - _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));} + _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return std::addressof((operator*()));} _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++() { if (!(*__in_stream_ >> __value_)) @@ -966,9 +966,9 @@ const char_type* __delim_; public: _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT - : __out_stream_(_VSTD::addressof(__s)), __delim_(0) {} + : __out_stream_(std::addressof(__s)), __delim_(0) {} _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT - : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {} + : __out_stream_(std::addressof(__s)), __delim_(__delimiter) {} _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_) { *__out_stream_ << __value_; @@ -1379,7 +1379,7 @@ _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), "Attempted to dereference a non-dereferenceable iterator"); #endif - return (pointer)_VSTD::addressof(*__i); + return (pointer)std::addressof(*__i); } _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator++() _NOEXCEPT_DEBUG { @@ -1739,16 +1739,16 @@ template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 -auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c)) +auto cbegin(const _Cp& __c) -> decltype(std::begin(__c)) { - return _VSTD::begin(__c); + return std::begin(__c); } template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 -auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c)) +auto cend(const _Cp& __c) -> decltype(std::end(__c)) { - return _VSTD::end(__c); + return std::end(__c); } template @@ -1781,16 +1781,16 @@ template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 -auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c)) +auto crbegin(const _Cp& __c) -> decltype(std::rbegin(__c)) { - return _VSTD::rbegin(__c); + return std::rbegin(__c); } template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 -auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c)) +auto crend(const _Cp& __c) -> decltype(std::rend(__c)) { - return _VSTD::rend(__c); + return std::rend(__c); } #endif @@ -1841,9 +1841,9 @@ // template // _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY // auto operator()(_T1&& __t, _T2&& __u) const -// _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) -// -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) -// { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } +// _NOEXCEPT_(noexcept(std::forward<_T1>(__t) + std::forward<_T2>(__u))) +// -> decltype (std::forward<_T1>(__t) + std::forward<_T2>(__u)) +// { return std::forward<_T1>(__t) + std::forward<_T2>(__u); } // typedef void is_transparent; // }; // #endif Index: include/limits =================================================================== --- include/limits +++ include/limits @@ -237,7 +237,7 @@ static _LIBCPP_CONSTEXPR const bool is_iec559 = false; static _LIBCPP_CONSTEXPR const bool is_bounded = true; - static _LIBCPP_CONSTEXPR const bool is_modulo = !_VSTD::is_signed<_Tp>::value; + static _LIBCPP_CONSTEXPR const bool is_modulo = !std::is_signed<_Tp>::value; #if defined(__i386__) || defined(__x86_64__) || defined(__pnacl__) || \ defined(__wasm__) Index: include/list =================================================================== --- include/list +++ include/list @@ -679,7 +679,7 @@ void __move_assign_alloc(__list_imp& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) { - __node_alloc() = _VSTD::move(__c.__node_alloc()); + __node_alloc() = std::move(__c.__node_alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -754,7 +754,7 @@ { __node_pointer __np = __f->__as_node(); __f = __f->__next_; - __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); + __node_alloc_traits::destroy(__na, std::addressof(__np->__value_)); __node_alloc_traits::deallocate(__na, __np, 1); } __invalidate_all_iterators(); @@ -775,7 +775,7 @@ this->__node_alloc() == __c.__node_alloc(), "list::swap: Either propagate_on_container_swap must be true" " or the allocators must compare equal"); - using _VSTD::swap; + using std::swap; __swap_allocator(__node_alloc(), __c.__node_alloc()); swap(__sz(), __c.__sz()); swap(__end_, __c.__end_); @@ -851,8 +851,8 @@ typedef typename base::difference_type difference_type; typedef typename base::iterator iterator; typedef typename base::const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; _LIBCPP_INLINE_VISIBILITY list() @@ -1019,7 +1019,7 @@ #ifndef _LIBCPP_CXX03_LANG template _LIBCPP_INLINE_VISIBILITY - void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); } + void __emplace_back(_Arg&& __arg) { emplace_back(std::forward<_Arg>(__arg)); } #else _LIBCPP_INLINE_VISIBILITY void __emplace_back(value_type const& __arg) { push_back(__arg); } @@ -1188,8 +1188,8 @@ typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::__iterator(size_type __n) { - return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n) - : _VSTD::prev(end(), base::__sz() - __n); + return __n <= base::__sz() / 2 ? std::next(begin(), __n) + : std::prev(end(), base::__sz() - __n); } template @@ -1314,7 +1314,7 @@ template inline list<_Tp, _Alloc>::list(list&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value) - : base(_VSTD::move(__c.__node_alloc())) { + : base(std::move(__c.__node_alloc())) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif @@ -1444,7 +1444,7 @@ #endif __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link()); ++base::__sz(); #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1471,7 +1471,7 @@ size_type __ds = 0; __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); ++__ds; #if _LIBCPP_DEBUG_LEVEL >= 2 __r = iterator(__hold->__as_link(), this); @@ -1487,7 +1487,7 @@ for (--__n; __n != 0; --__n, ++__e, ++__ds) { __hold.reset(__node_alloc_traits::allocate(__na, 1)); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); __e.__ptr_->__next_ = __hold->__as_link(); __hold->__prev_ = __e.__ptr_; __hold.release(); @@ -1498,7 +1498,7 @@ { while (true) { - __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); + __node_alloc_traits::destroy(__na, std::addressof(*__e)); __link_pointer __prev = __e.__ptr_->__prev_; __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); if (__prev == 0) @@ -1537,7 +1537,7 @@ size_type __ds = 0; __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), *__f); ++__ds; #if _LIBCPP_DEBUG_LEVEL >= 2 __r = iterator(__hold.get()->__as_link(), this); @@ -1553,7 +1553,7 @@ for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds) { __hold.reset(__node_alloc_traits::allocate(__na, 1)); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), *__f); __e.__ptr_->__next_ = __hold.get()->__as_link(); __hold->__prev_ = __e.__ptr_; __hold.release(); @@ -1564,7 +1564,7 @@ { while (true) { - __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); + __node_alloc_traits::destroy(__na, std::addressof(*__e)); __link_pointer __prev = __e.__ptr_->__prev_; __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); if (__prev == 0) @@ -1590,7 +1590,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); __link_pointer __nl = __hold->__as_link(); __link_nodes_at_front(__nl, __nl); ++base::__sz(); @@ -1603,7 +1603,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); ++base::__sz(); __hold.release(); @@ -1617,7 +1617,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::move(__x)); __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); ++base::__sz(); __hold.release(); @@ -1629,7 +1629,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::move(__x)); __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); ++base::__sz(); __hold.release(); @@ -1646,7 +1646,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::forward<_Args>(__args)...); __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); ++base::__sz(); #if _LIBCPP_STD_VER > 14 @@ -1667,7 +1667,7 @@ { __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::forward<_Args>(__args)...); __link_pointer __nl = __hold->__as_link(); __link_nodes_at_back(__nl, __nl); ++base::__sz(); @@ -1690,7 +1690,7 @@ #endif __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::forward<_Args>(__args)...); __link_pointer __nl = __hold.get()->__as_link(); __link_nodes(__p.__ptr_, __nl, __nl); ++base::__sz(); @@ -1713,7 +1713,7 @@ #endif __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), std::move(__x)); __link_pointer __nl = __hold->__as_link(); __link_nodes(__p.__ptr_, __nl, __nl); ++base::__sz(); @@ -1752,7 +1752,7 @@ __get_db()->unlock(); #endif __node_pointer __np = __n->__as_node(); - __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); + __node_alloc_traits::destroy(__na, std::addressof(__np->__value_)); __node_alloc_traits::deallocate(__na, __np, 1); } @@ -1781,7 +1781,7 @@ __get_db()->unlock(); #endif __node_pointer __np = __n->__as_node(); - __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); + __node_alloc_traits::destroy(__na, std::addressof(__np->__value_)); __node_alloc_traits::deallocate(__na, __np, 1); } @@ -1817,7 +1817,7 @@ __get_db()->unlock(); #endif __node_pointer __np = __n->__as_node(); - __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); + __node_alloc_traits::destroy(__na, std::addressof(__np->__value_)); __node_alloc_traits::deallocate(__na, __np, 1); #if _LIBCPP_DEBUG_LEVEL >= 2 return iterator(__r, this); @@ -1863,7 +1863,7 @@ __get_db()->unlock(); #endif __node_pointer __np = __n->__as_node(); - __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_)); + __node_alloc_traits::destroy(__na, std::addressof(__np->__value_)); __node_alloc_traits::deallocate(__na, __np, 1); } } @@ -1886,7 +1886,7 @@ size_type __ds = 0; __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_)); ++__ds; #if _LIBCPP_DEBUG_LEVEL >= 2 iterator __r = iterator(__hold.release()->__as_link(), this); @@ -1901,7 +1901,7 @@ for (--__n; __n != 0; --__n, ++__e, ++__ds) { __hold.reset(__node_alloc_traits::allocate(__na, 1)); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_)); __e.__ptr_->__next_ = __hold.get()->__as_link(); __hold->__prev_ = __e.__ptr_; __hold.release(); @@ -1912,7 +1912,7 @@ { while (true) { - __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); + __node_alloc_traits::destroy(__na, std::addressof(*__e)); __link_pointer __prev = __e.__ptr_->__prev_; __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); if (__prev == 0) @@ -1943,7 +1943,7 @@ size_type __ds = 0; __node_allocator& __na = base::__node_alloc(); __hold_pointer __hold = __allocate_node(__na); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); ++__ds; __link_pointer __nl = __hold.release()->__as_link(); #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1959,7 +1959,7 @@ for (--__n; __n != 0; --__n, ++__e, ++__ds) { __hold.reset(__node_alloc_traits::allocate(__na, 1)); - __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); + __node_alloc_traits::construct(__na, std::addressof(__hold->__value_), __x); __e.__ptr_->__next_ = __hold.get()->__as_link(); __hold->__prev_ = __e.__ptr_; __hold.release(); @@ -1970,7 +1970,7 @@ { while (true) { - __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); + __node_alloc_traits::destroy(__na, std::addressof(*__e)); __link_pointer __prev = __e.__ptr_->__prev_; __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); if (__prev == 0) @@ -2099,7 +2099,7 @@ __link_pointer __last = __l.__ptr_; if (this != &__c) { - size_type __s = _VSTD::distance(__f, __l) + 1; + size_type __s = std::distance(__f, __l) + 1; __c.__sz() -= __s; base::__sz() += __s; } @@ -2139,7 +2139,7 @@ { if (*__i == __x) { - const_iterator __j = _VSTD::next(__i); + const_iterator __j = std::next(__i); for (; __j != __e && *__j == __x; ++__j) ; __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j); @@ -2161,7 +2161,7 @@ { if (__pred(*__i)) { - iterator __j = _VSTD::next(__i); + iterator __j = std::next(__i); for (; __j != __e && __pred(*__j); ++__j) ; __i = erase(__i, __j); @@ -2188,7 +2188,7 @@ { for (iterator __i = begin(), __e = end(); __i != __e;) { - iterator __j = _VSTD::next(__i); + iterator __j = std::next(__i); for (; __j != __e && __binary_pred(*__i, *__j); ++__j) ; if (++__i != __j) @@ -2209,7 +2209,7 @@ void list<_Tp, _Alloc>::merge(list& __c, _Comp __comp) { - if (this != _VSTD::addressof(__c)) + if (this != std::addressof(__c)) { iterator __f1 = begin(); iterator __e1 = end(); @@ -2220,7 +2220,7 @@ if (__comp(*__f2, *__f1)) { size_type __ds = 1; - iterator __m2 = _VSTD::next(__f2); + iterator __m2 = std::next(__f2); for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds) ; base::__sz() += __ds; @@ -2229,7 +2229,7 @@ __link_pointer __l = __m2.__ptr_->__prev_; __f2 = __m2; base::__unlink_nodes(__f, __l); - __m2 = _VSTD::next(__f1); + __m2 = std::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; } @@ -2296,12 +2296,12 @@ return __f1; } size_type __n2 = __n / 2; - iterator __e1 = _VSTD::next(__f1, __n2); + iterator __e1 = std::next(__f1, __n2); iterator __r = __f1 = __sort(__f1, __e1, __n2, __comp); iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp); if (__comp(*__f2, *__f1)) { - iterator __m2 = _VSTD::next(__f2); + iterator __m2 = std::next(__f2); for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2) ; __link_pointer __f = __f2.__ptr_; @@ -2309,7 +2309,7 @@ __r = __f2; __e1 = __f2 = __m2; base::__unlink_nodes(__f, __l); - __m2 = _VSTD::next(__f1); + __m2 = std::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; } @@ -2319,7 +2319,7 @@ { if (__comp(*__f2, *__f1)) { - iterator __m2 = _VSTD::next(__f2); + iterator __m2 = std::next(__f2); for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2) ; __link_pointer __f = __f2.__ptr_; @@ -2328,7 +2328,7 @@ __e1 = __m2; __f2 = __m2; base::__unlink_nodes(__f, __l); - __m2 = _VSTD::next(__f1); + __m2 = std::next(__f1); __link_nodes(__f1.__ptr_, __f, __l); __f1 = __m2; } @@ -2347,10 +2347,10 @@ iterator __e = end(); for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;) { - _VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_); + std::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_); __i.__ptr_ = __i.__ptr_->__prev_; } - _VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_); + std::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_); } } @@ -2358,7 +2358,7 @@ bool list<_Tp, _Alloc>::__invariants() const { - return size() == _VSTD::distance(begin(), end()); + return size() == std::distance(begin(), end()); } #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -2398,7 +2398,7 @@ bool operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) { - return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -2406,7 +2406,7 @@ bool operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template Index: include/locale =================================================================== --- include/locale +++ include/locale @@ -255,7 +255,7 @@ bool __case_sensitive = true) { typedef typename iterator_traits<_InputIterator>::value_type _CharT; - size_t __nkw = static_cast(_VSTD::distance(__kb, __ke)); + size_t __nkw = static_cast(std::distance(__kb, __ke)); const unsigned char __doesnt_match = '\0'; const unsigned char __might_match = '\1'; const unsigned char __does_match = '\2'; @@ -1435,7 +1435,7 @@ typedef typename numpunct::string_type string_type; #if _LIBCPP_DEBUG_LEVEL >= 2 string_type __tmp(__v ? __np.truename() : __np.falsename()); - string_type __nm = _VSTD::move(__tmp); + string_type __nm = std::move(__tmp); #else string_type __nm = __v ? __np.truename() : __np.falsename(); #endif @@ -2578,7 +2578,7 @@ char_type* __nb = __nar; char_type* __ne = __nb + 100; __do_put(__nb, __ne, __tm, __fmt, __mod); - return _VSTD::copy(__nb, __ne, __s); + return std::copy(__nb, __ne, __s); } _LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put) @@ -3125,7 +3125,7 @@ if (__neg) *__nc++ = '-'; for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc) - *__nc = __src[find(__atoms, _VSTD::end(__atoms), *__w) - __atoms]; + *__nc = __src[find(__atoms, std::end(__atoms), *__w) - __atoms]; *__nc = char(); if (sscanf(__nbuf, "%Lf", &__v) != 1) __throw_runtime_error("money_get error"); @@ -3276,7 +3276,7 @@ break; case money_base::symbol: if (!__sym.empty() && (__flags & ios_base::showbase)) - __me = _VSTD::copy(__sym.begin(), __sym.end(), __me); + __me = std::copy(__sym.begin(), __sym.end(), __me); break; case money_base::value: { @@ -3335,7 +3335,7 @@ } // print rest of sign, if any if (__sn.size() > 1) - __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me); + __me = std::copy(__sn.begin()+1, __sn.end(), __me); // set alignment if ((__flags & ios_base::adjustfield) == ios_base::left) __mi = __me; @@ -3725,8 +3725,8 @@ inline wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>:: wstring_convert(wstring_convert&& __wc) - : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)), - __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)), + : __byte_err_string_(std::move(__wc.__byte_err_string_)), + __wide_err_string_(std::move(__wc.__wide_err_string_)), __cvtptr_(__wc.__cvtptr_), __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_) { @@ -4023,7 +4023,7 @@ memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_); __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_); __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_); - streamsize __nmemb = _VSTD::min(static_cast(this->egptr() - this->eback() - __unget_sz), + streamsize __nmemb = std::min(static_cast(this->egptr() - this->eback() - __unget_sz), static_cast(__extbufend_ - __extbufnext_)); codecvt_base::result __r; // FIXME: Do we ever need to restore the state here? Index: include/map =================================================================== --- include/map +++ include/map @@ -514,7 +514,7 @@ void swap(__map_value_compare&__y) _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) { - using _VSTD::swap; + using std::swap; swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y)); } @@ -562,7 +562,7 @@ void swap(__map_value_compare&__y) _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) { - using _VSTD::swap; + using std::swap; swap(comp, __y.comp); } @@ -631,9 +631,9 @@ void operator()(pointer __p) _NOEXCEPT { if (__second_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().second)); if (__first_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().first)); if (__p) __alloc_traits::deallocate(__na_, __p, 1); } @@ -664,7 +664,7 @@ value_type& __get_value() { #if _LIBCPP_STD_VER > 14 - return *_VSTD::launder(_VSTD::addressof(__cc)); + return *std::launder(std::addressof(__cc)); #else return __cc; #endif @@ -674,7 +674,7 @@ const value_type& __get_value() const { #if _LIBCPP_STD_VER > 14 - return *_VSTD::launder(_VSTD::addressof(__cc)); + return *std::launder(std::addressof(__cc)); #else return __cc; #endif @@ -692,8 +692,8 @@ { value_type& __v = __get_value(); return __nc_rref_pair_type( - _VSTD::move(const_cast(__v.first)), - _VSTD::move(__v.second)); + std::move(const_cast(__v.first)), + std::move(__v.second)); } _LIBCPP_INLINE_VISIBILITY @@ -718,7 +718,7 @@ _LIBCPP_INLINE_VISIBILITY __value_type& operator=(_ValueTp&& __v) { - __ref() = _VSTD::forward<_ValueTp>(__v); + __ref() = std::forward<_ValueTp>(__v); return *this; } @@ -921,7 +921,7 @@ private: - typedef _VSTD::__value_type __value_type; + typedef std::__value_type __value_type; typedef __map_value_compare __vc; typedef typename __rebind_alloc_helper, __value_type>::type __allocator_type; @@ -938,8 +938,8 @@ typedef typename __alloc_traits::difference_type difference_type; typedef __map_iterator iterator; typedef __map_const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; #if _LIBCPP_STD_VER > 14 typedef __map_node_handle node_type; @@ -1023,7 +1023,7 @@ _LIBCPP_INLINE_VISIBILITY map(map&& __m) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value) - : __tree_(_VSTD::move(__m.__tree_)) + : __tree_(std::move(__m.__tree_)) { } @@ -1033,7 +1033,7 @@ map& operator=(map&& __m) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) { - __tree_ = _VSTD::move(__m.__tree_); + __tree_ = std::move(__m.__tree_); return *this; } @@ -1135,26 +1135,26 @@ template _LIBCPP_INLINE_VISIBILITY pair emplace(_Args&& ...__args) { - return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...); + return __tree_.__emplace_unique(std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&& ...__args) { - return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_Args>(__args)...); + return __tree_.__emplace_hint_unique(__p.__i_, std::forward<_Args>(__args)...); } template ::value>::type> _LIBCPP_INLINE_VISIBILITY pair insert(_Pp&& __p) - {return __tree_.__insert_unique(_VSTD::forward<_Pp>(__p));} + {return __tree_.__insert_unique(std::forward<_Pp>(__p));} template ::value>::type> _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __pos, _Pp&& __p) - {return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));} + {return __tree_.__insert_unique(__pos.__i_, std::forward<_Pp>(__p));} #endif // _LIBCPP_CXX03_LANG @@ -1170,11 +1170,11 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY pair - insert(value_type&& __v) {return __tree_.__insert_unique(_VSTD::move(__v));} + insert(value_type&& __v) {return __tree_.__insert_unique(std::move(__v));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __v) - {return __tree_.__insert_unique(__p.__i_, _VSTD::move(__v));} + {return __tree_.__insert_unique(__p.__i_, std::move(__v));} _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) @@ -1196,9 +1196,9 @@ pair try_emplace(const key_type& __k, _Args&&... __args) { return __tree_.__emplace_unique_key_args(__k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(__k), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template @@ -1206,9 +1206,9 @@ pair try_emplace(key_type&& __k, _Args&&... __args) { return __tree_.__emplace_unique_key_args(__k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::move(__k)), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template @@ -1216,9 +1216,9 @@ iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) { return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(__k), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template @@ -1226,9 +1226,9 @@ iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) { return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::move(__k)), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template @@ -1238,10 +1238,10 @@ iterator __p = lower_bound(__k); if ( __p != end() && !key_comp()(__k, __p->first)) { - __p->second = _VSTD::forward<_Vp>(__v); - return _VSTD::make_pair(__p, false); + __p->second = std::forward<_Vp>(__v); + return std::make_pair(__p, false); } - return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true); + return std::make_pair(emplace_hint(__p, __k, std::forward<_Vp>(__v)), true); } template @@ -1251,10 +1251,10 @@ iterator __p = lower_bound(__k); if ( __p != end() && !key_comp()(__k, __p->first)) { - __p->second = _VSTD::forward<_Vp>(__v); - return _VSTD::make_pair(__p, false); + __p->second = std::forward<_Vp>(__v); + return std::make_pair(__p, false); } - return _VSTD::make_pair(emplace_hint(__p, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)), true); + return std::make_pair(emplace_hint(__p, std::move(__k), std::forward<_Vp>(__v)), true); } template @@ -1264,10 +1264,10 @@ iterator __p = lower_bound(__k); if ( __p != end() && !key_comp()(__k, __p->first)) { - __p->second = _VSTD::forward<_Vp>(__v); + __p->second = std::forward<_Vp>(__v); return __p; } - return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v)); + return emplace_hint(__h, __k, std::forward<_Vp>(__v)); } template @@ -1277,10 +1277,10 @@ iterator __p = lower_bound(__k); if ( __p != end() && !key_comp()(__k, __p->first)) { - __p->second = _VSTD::forward<_Vp>(__v); + __p->second = std::forward<_Vp>(__v); return __p; } - return emplace_hint(__h, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)); + return emplace_hint(__h, std::move(__k), std::forward<_Vp>(__v)); } #endif // _LIBCPP_STD_VER > 14 @@ -1305,7 +1305,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to map::insert()"); return __tree_.template __node_handle_insert_unique< - node_type, insert_return_type>(_VSTD::move(__nh)); + node_type, insert_return_type>(std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1313,7 +1313,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to map::insert()"); return __tree_.template __node_handle_insert_unique( - __hint.__i_, _VSTD::move(__nh)); + __hint.__i_, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -1459,7 +1459,7 @@ #ifndef _LIBCPP_CXX03_LANG template map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a) - : __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a)) + : __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) { if (__a != __m.get_allocator()) { @@ -1475,9 +1475,9 @@ map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) { return __tree_.__emplace_unique_key_args(__k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(__k), - _VSTD::forward_as_tuple()).first->__get_value().second; + std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple()).first->__get_value().second; } template @@ -1485,9 +1485,9 @@ map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k) { return __tree_.__emplace_unique_key_args(__k, - _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::move(__k)), - _VSTD::forward_as_tuple()).first->__get_value().second; + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple()).first->__get_value().second; } #else // _LIBCPP_CXX03_LANG @@ -1498,9 +1498,9 @@ { __node_allocator& __na = __tree_.__node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k); + __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().first), __k); __h.get_deleter().__first_constructed = true; - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second)); + __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().second)); __h.get_deleter().__second_constructed = true; return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03 } @@ -1556,7 +1556,7 @@ operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) { - return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -1565,7 +1565,7 @@ operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template @@ -1649,7 +1649,7 @@ private: - typedef _VSTD::__value_type __value_type; + typedef std::__value_type __value_type; typedef __map_value_compare __vc; typedef typename __rebind_alloc_helper, __value_type>::type __allocator_type; @@ -1666,8 +1666,8 @@ typedef typename __alloc_traits::difference_type difference_type; typedef __map_iterator iterator; typedef __map_const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; #if _LIBCPP_STD_VER > 14 typedef __map_node_handle node_type; @@ -1751,7 +1751,7 @@ _LIBCPP_INLINE_VISIBILITY multimap(multimap&& __m) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value) - : __tree_(_VSTD::move(__m.__tree_)) + : __tree_(std::move(__m.__tree_)) { } @@ -1761,7 +1761,7 @@ multimap& operator=(multimap&& __m) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) { - __tree_ = _VSTD::move(__m.__tree_); + __tree_ = std::move(__m.__tree_); return *this; } @@ -1856,34 +1856,34 @@ template _LIBCPP_INLINE_VISIBILITY iterator emplace(_Args&& ...__args) { - return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...); + return __tree_.__emplace_multi(std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&& ...__args) { - return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...); + return __tree_.__emplace_hint_multi(__p.__i_, std::forward<_Args>(__args)...); } template ::value>::type> _LIBCPP_INLINE_VISIBILITY iterator insert(_Pp&& __p) - {return __tree_.__insert_multi(_VSTD::forward<_Pp>(__p));} + {return __tree_.__insert_multi(std::forward<_Pp>(__p));} template ::value>::type> _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __pos, _Pp&& __p) - {return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));} + {return __tree_.__insert_multi(__pos.__i_, std::forward<_Pp>(__p));} _LIBCPP_INLINE_VISIBILITY iterator insert(value_type&& __v) - {return __tree_.__insert_multi(_VSTD::move(__v));} + {return __tree_.__insert_multi(std::move(__v));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __v) - {return __tree_.__insert_multi(__p.__i_, _VSTD::move(__v));} + {return __tree_.__insert_multi(__p.__i_, std::move(__v));} _LIBCPP_INLINE_VISIBILITY @@ -1924,7 +1924,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to multimap::insert()"); return __tree_.template __node_handle_insert_multi( - _VSTD::move(__nh)); + std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1932,7 +1932,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to multimap::insert()"); return __tree_.template __node_handle_insert_multi( - __hint.__i_, _VSTD::move(__nh)); + __hint.__i_, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -2075,14 +2075,14 @@ #ifndef _LIBCPP_CXX03_LANG template multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a) - : __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a)) + : __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) { if (__a != __m.get_allocator()) { const_iterator __e = cend(); while (!__m.empty()) __tree_.__insert_multi(__e.__i_, - _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move())); + std::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move())); } } #endif @@ -2093,7 +2093,7 @@ operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) { - return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -2102,7 +2102,7 @@ operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template Index: include/memory =================================================================== --- include/memory +++ include/memory @@ -987,7 +987,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 static pointer pointer_to(typename conditional::value, __nat, element_type>::type& __r) _NOEXCEPT - {return _VSTD::addressof(__r);} + {return std::addressof(__r);} }; template @@ -1114,7 +1114,7 @@ typename pointer_traits<_Pointer>::element_type* __to_raw_pointer(_Pointer __p) _NOEXCEPT { - return _VSTD::__to_raw_pointer(__p.operator->()); + return std::__to_raw_pointer(__p.operator->()); } #else template @@ -1131,7 +1131,7 @@ auto __to_raw_pointer(const _Pointer& __p, _None...) _NOEXCEPT { - return _VSTD::__to_raw_pointer(__p.operator->()); + return std::__to_raw_pointer(__p.operator->()); } template @@ -1148,7 +1148,7 @@ auto to_address(const _Pointer& __p) _NOEXCEPT { - return _VSTD::__to_raw_pointer(__p); + return std::__to_raw_pointer(__p); } #endif @@ -1242,7 +1242,7 @@ template ::value> struct __is_always_equal { - typedef typename _VSTD::is_empty<_Alloc>::type type; + typedef typename std::is_empty<_Alloc>::type type; }; template @@ -1360,7 +1360,7 @@ struct __has_allocate_hint : integral_constant(), + decltype(std::__has_allocate_hint_test(declval<_Alloc>(), declval<_SizeType>(), declval<_ConstVoidPtr>())), true_type>::value> @@ -1380,8 +1380,8 @@ #if !defined(_LIBCPP_CXX03_LANG) template -decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(), - _VSTD::declval<_Args>()...), +decltype(std::declval<_Alloc>().construct(std::declval<_Tp*>(), + std::declval<_Args>()...), true_type()) __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args); @@ -1393,7 +1393,7 @@ struct __has_construct : integral_constant(), + decltype(std::__has_construct_test(declval<_Alloc>(), declval<_Pointer>(), declval<_Args>()...)), true_type>::value> @@ -1414,7 +1414,7 @@ struct __has_destroy : integral_constant(), + decltype(std::__has_destroy_test(declval<_Alloc>(), declval<_Pointer>())), true_type>::value> { @@ -1434,7 +1434,7 @@ struct __has_max_size : integral_constant())), + decltype(std::__has_max_size_test(declval<_Alloc&>())), true_type>::value> { }; @@ -1453,7 +1453,7 @@ struct __has_select_on_container_copy_construction : integral_constant())), + decltype(std::__has_select_on_container_copy_construction_test(declval<_Alloc&>())), true_type>::value> { }; @@ -1561,7 +1561,7 @@ _LIBCPP_INLINE_VISIBILITY static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {__construct(__has_construct(), - __a, __p, _VSTD::forward<_Args>(__args)...);} + __a, __p, std::forward<_Args>(__args)...);} #else // _LIBCPP_HAS_NO_VARIADICS template _LIBCPP_INLINE_VISIBILITY @@ -1614,7 +1614,7 @@ __construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) { for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) - construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1)); + construct(__a, std::__to_raw_pointer(__begin2), std::move_if_noexcept(*__begin1)); } template @@ -1632,7 +1632,7 @@ ptrdiff_t _Np = __end1 - __begin1; if (_Np > 0) { - _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); + std::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); __begin2 += _Np; } } @@ -1644,7 +1644,7 @@ __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) { for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) - construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1); + construct(__a, std::__to_raw_pointer(__begin2), *__begin1); } template @@ -1663,7 +1663,7 @@ ptrdiff_t _Np = __end1 - __begin1; if (_Np > 0) { - _VSTD::memcpy(const_cast<_Vp*>(__begin2), __begin1, _Np * sizeof(_Tp)); + std::memcpy(const_cast<_Vp*>(__begin2), __begin1, _Np * sizeof(_Tp)); __begin2 += _Np; } } @@ -1676,7 +1676,7 @@ { while (__end1 != __begin1) { - construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1)); + construct(__a, std::__to_raw_pointer(__end2-1), std::move_if_noexcept(*--__end1)); --__end2; } } @@ -1696,7 +1696,7 @@ ptrdiff_t _Np = __end1 - __begin1; __end2 -= _Np; if (_Np > 0) - _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); + std::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); } private: @@ -1714,12 +1714,12 @@ template _LIBCPP_INLINE_VISIBILITY static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) - {__a.construct(__p, _VSTD::forward<_Args>(__args)...);} + {__a.construct(__p, std::forward<_Args>(__args)...);} template _LIBCPP_INLINE_VISIBILITY static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) { - ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); + ::new ((void*)__p) _Tp(std::forward<_Args>(__args)...); } #endif // _LIBCPP_HAS_NO_VARIADICS @@ -1788,19 +1788,19 @@ allocator(const allocator<_Up>&) _NOEXCEPT {} _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT - {return _VSTD::addressof(__x);} + {return std::addressof(__x);} _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT - {return _VSTD::addressof(__x);} + {return std::addressof(__x);} _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator::const_pointer = 0) { if (__n > max_size()) __throw_length_error("allocator::allocate(size_t n)" " 'n' exceeds maximum supported size"); - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); + return static_cast(std::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT - {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __alignof(_Tp));} + {std::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), __alignof(_Tp));} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return size_type(~0) / sizeof(_Tp);} #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) @@ -1809,7 +1809,7 @@ void construct(_Up* __p, _Args&&... __args) { - ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); + ::new((void*)__p) _Up(std::forward<_Args>(__args)...); } #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) _LIBCPP_INLINE_VISIBILITY @@ -1892,16 +1892,16 @@ allocator(const allocator<_Up>&) _NOEXCEPT {} _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT - {return _VSTD::addressof(__x);} + {return std::addressof(__x);} _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator::const_pointer = 0) { if (__n > max_size()) __throw_length_error("allocator::allocate(size_t n)" " 'n' exceeds maximum supported size"); - return static_cast(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); + return static_cast(std::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp))); } _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT - {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), __alignof(_Tp));} + {std::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), __alignof(_Tp));} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return size_type(~0) / sizeof(_Tp);} #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) @@ -1910,7 +1910,7 @@ void construct(_Up* __p, _Args&&... __args) { - ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); + ::new((void*)__p) _Up(std::forward<_Args>(__args)...); } #else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) _LIBCPP_INLINE_VISIBILITY @@ -1990,10 +1990,10 @@ _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) - {::new(_VSTD::addressof(*__x_)) _Tp(__element); return *this;} + {::new(std::addressof(*__x_)) _Tp(__element); return *this;} #if _LIBCPP_STD_VER >= 14 _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element) - {::new(_VSTD::addressof(*__x_)) _Tp(_VSTD::move(__element)); return *this;} + {::new(std::addressof(*__x_)) _Tp(std::move(__element)); return *this;} #endif _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) @@ -2052,7 +2052,7 @@ inline _LIBCPP_INLINE_VISIBILITY void return_temporary_buffer(_Tp* __p) _NOEXCEPT { - _VSTD::__libcpp_deallocate_unsized((void*)__p, __alignof(_Tp)); + std::__libcpp_deallocate_unsized((void*)__p, __alignof(_Tp)); } #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) @@ -2131,7 +2131,7 @@ _LIBCPP_INLINE_VISIBILITY constexpr explicit __compressed_pair_elem(_Up&& __u) - : __value_(_VSTD::forward<_Up>(__u)) + : __value_(std::forward<_Up>(__u)) { } @@ -2139,7 +2139,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indexes...>) - : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} + : __value_(std::forward<_Args>(std::get<_Indexes>(__args))...) {} #else _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {} _LIBCPP_INLINE_VISIBILITY @@ -2170,14 +2170,14 @@ _LIBCPP_INLINE_VISIBILITY constexpr explicit __compressed_pair_elem(_Up&& __u) - : __value_type(_VSTD::forward<_Up>(__u)) + : __value_type(std::forward<_Up>(__u)) {} template _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indexes...>) - : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} + : __value_type(std::forward<_Args>(std::get<_Indexes>(__args))...) {} #else _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {} _LIBCPP_INLINE_VISIBILITY @@ -2240,9 +2240,9 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) - : _Base1(__pc, _VSTD::move(__first_args), + : _Base1(__pc, std::move(__first_args), typename __make_tuple_indices::type()), - _Base2(__pc, _VSTD::move(__second_args), + _Base2(__pc, std::move(__second_args), typename __make_tuple_indices::type()) {} #else @@ -2250,15 +2250,15 @@ __compressed_pair() {} _LIBCPP_INLINE_VISIBILITY explicit - __compressed_pair(_T1 __t1) : _Base1(_VSTD::forward<_T1>(__t1)) {} + __compressed_pair(_T1 __t1) : _Base1(std::forward<_T1>(__t1)) {} _LIBCPP_INLINE_VISIBILITY __compressed_pair(__second_tag, _T2 __t2) - : _Base1(), _Base2(_VSTD::forward<_T2>(__t2)) {} + : _Base1(), _Base2(std::forward<_T2>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1 __t1, _T2 __t2) - : _Base1(_VSTD::forward<_T1>(__t1)), _Base2(_VSTD::forward<_T2>(__t2)) {} + : _Base1(std::forward<_T1>(__t1)), _Base2(std::forward<_T2>(__t2)) {} #endif _LIBCPP_INLINE_VISIBILITY @@ -2466,7 +2466,7 @@ class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) noexcept - : __ptr_(__p, _VSTD::move(__d)) { + : __ptr_(__p, std::move(__d)) { static_assert(!is_reference::value, "rvalue deleter bound to reference"); } @@ -2478,7 +2478,7 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) noexcept - : __ptr_(__u.release(), _VSTD::forward(__u.get_deleter())) { + : __ptr_(__u.release(), std::forward(__u.get_deleter())) { } template _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT - : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} + : __ptr_(__u.release(), std::forward<_Ep>(__u.get_deleter())) {} #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) template @@ -2502,7 +2502,7 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT { reset(__u.release()); - __ptr_.second() = _VSTD::forward(__u.get_deleter()); + __ptr_.second() = std::forward(__u.get_deleter()); return *this; } @@ -2513,7 +2513,7 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT { reset(__u.release()); - __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); + __ptr_.second() = std::forward<_Ep>(__u.get_deleter()); return *this; } @@ -2542,7 +2542,7 @@ } _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) - : __ptr_(_VSTD::move(__p)) { + : __ptr_(std::move(__p)) { static_assert(!is_pointer::value, "unique_ptr constructed with null function pointer deleter"); } @@ -2555,7 +2555,7 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv __u) : __ptr_(__u->release(), - _VSTD::forward(__u->get_deleter())) {} + std::forward(__u->get_deleter())) {} template _LIBCPP_INLINE_VISIBILITY @@ -2567,13 +2567,13 @@ unique_ptr&>::type operator=(unique_ptr<_Up, _Ep> __u) { reset(__u.release()); - __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); + __ptr_.second() = std::forward<_Ep>(__u.get_deleter()); return *this; } _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) - : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {} + : __ptr_(std::move(__p), std::move(__d)) {} #endif // _LIBCPP_CXX03_LANG #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) @@ -2753,7 +2753,7 @@ class = _EnableIfPointerConvertible<_Pp>> _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) noexcept - : __ptr_(__p, _VSTD::move(__d)) { + : __ptr_(__p, std::move(__d)) { static_assert(!is_reference::value, "rvalue deleter bound to reference"); } @@ -2762,7 +2762,7 @@ class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>> _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) noexcept - : __ptr_(nullptr, _VSTD::move(__d)) { + : __ptr_(nullptr, std::move(__d)) { static_assert(!is_reference::value, "rvalue deleter bound to reference"); } @@ -2775,13 +2775,13 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) noexcept - : __ptr_(__u.release(), _VSTD::forward(__u.get_deleter())) { + : __ptr_(__u.release(), std::forward(__u.get_deleter())) { } _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) noexcept { reset(__u.release()); - __ptr_.second() = _VSTD::forward(__u.get_deleter()); + __ptr_.second() = std::forward(__u.get_deleter()); return *this; } @@ -2791,7 +2791,7 @@ > _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept - : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) { + : __ptr_(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } template && __u) noexcept { reset(__u.release()); - __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); + __ptr_.second() = std::forward<_Ep>(__u.get_deleter()); return *this; } @@ -2843,11 +2843,11 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d) - : __ptr_(__p, _VSTD::forward(__d)) {} + : __ptr_(__p, std::forward(__d)) {} _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, deleter_type __d) - : __ptr_(pointer(), _VSTD::forward(__d)) {} + : __ptr_(pointer(), std::forward(__d)) {} _LIBCPP_INLINE_VISIBILITY operator __rv() { @@ -2857,12 +2857,12 @@ _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv __u) : __ptr_(__u->release(), - _VSTD::forward(__u->get_deleter())) {} + std::forward(__u->get_deleter())) {} _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(__rv __u) { reset(__u->release()); - __ptr_.second() = _VSTD::forward(__u->get_deleter()); + __ptr_.second() = std::forward(__u->get_deleter()); return *this; } @@ -3115,7 +3115,7 @@ typename __unique_if<_Tp>::__unique_single make_unique(_Args&&... __args) { - return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); + return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } template @@ -3220,7 +3220,7 @@ { #endif for (; __f != __l; ++__f, (void) ++__r) - ::new (static_cast(_VSTD::addressof(*__r))) value_type(*__f); + ::new (static_cast(std::addressof(*__r))) value_type(*__f); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3244,7 +3244,7 @@ { #endif for (; __n > 0; ++__f, (void) ++__r, (void) --__n) - ::new (static_cast(_VSTD::addressof(*__r))) value_type(*__f); + ::new (static_cast(std::addressof(*__r))) value_type(*__f); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3268,7 +3268,7 @@ { #endif for (; __f != __l; ++__f) - ::new (static_cast(_VSTD::addressof(*__f))) value_type(__x); + ::new (static_cast(std::addressof(*__f))) value_type(__x); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3291,7 +3291,7 @@ { #endif for (; __n > 0; ++__f, (void) --__n) - ::new (static_cast(_VSTD::addressof(*__f))) value_type(__x); + ::new (static_cast(std::addressof(*__f))) value_type(__x); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -3317,14 +3317,14 @@ inline _LIBCPP_INLINE_VISIBILITY void destroy(_ForwardIterator __first, _ForwardIterator __last) { for (; __first != __last; ++__first) - _VSTD::destroy_at(_VSTD::addressof(*__first)); + std::destroy_at(std::addressof(*__first)); } template inline _LIBCPP_INLINE_VISIBILITY _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { for (; __n > 0; (void)++__first, --__n) - _VSTD::destroy_at(_VSTD::addressof(*__first)); + std::destroy_at(std::addressof(*__first)); return __first; } @@ -3337,10 +3337,10 @@ try { #endif for (; __idx != __last; ++__idx) - ::new((void*)_VSTD::addressof(*__idx)) _Vt; + ::new((void*)std::addressof(*__idx)) _Vt; #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first, __idx); + std::destroy(__first, __idx); throw; } #endif @@ -3355,11 +3355,11 @@ try { #endif for (; __n > 0; (void)++__idx, --__n) - ::new((void*)_VSTD::addressof(*__idx)) _Vt; + ::new((void*)std::addressof(*__idx)) _Vt; return __idx; #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first, __idx); + std::destroy(__first, __idx); throw; } #endif @@ -3375,10 +3375,10 @@ try { #endif for (; __idx != __last; ++__idx) - ::new((void*)_VSTD::addressof(*__idx)) _Vt(); + ::new((void*)std::addressof(*__idx)) _Vt(); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first, __idx); + std::destroy(__first, __idx); throw; } #endif @@ -3393,11 +3393,11 @@ try { #endif for (; __n > 0; (void)++__idx, --__n) - ::new((void*)_VSTD::addressof(*__idx)) _Vt(); + ::new((void*)std::addressof(*__idx)) _Vt(); return __idx; #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first, __idx); + std::destroy(__first, __idx); throw; } #endif @@ -3413,11 +3413,11 @@ try { #endif for (; __first != __last; (void)++__idx, ++__first) - ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); + ::new((void*)std::addressof(*__idx)) _Vt(std::move(*__first)); return __idx; #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first_res, __idx); + std::destroy(__first_res, __idx); throw; } #endif @@ -3433,11 +3433,11 @@ try { #endif for (; __n > 0; ++__idx, (void)++__first, --__n) - ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first)); + ::new((void*)std::addressof(*__idx)) _Vt(std::move(*__first)); return {__first, __idx}; #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { - _VSTD::destroy(__first_res, __idx); + std::destroy(__first_res, __idx); throw; } #endif @@ -3493,7 +3493,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_weak_ptr(); #else - _VSTD::abort(); + std::abort(); #endif } @@ -3597,7 +3597,7 @@ public: _LIBCPP_INLINE_VISIBILITY __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) - : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} + : __data_(__compressed_pair<_Tp, _Dp>(__p, std::move(__d)), std::move(__a)) {} #ifndef _LIBCPP_NO_RTTI virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; @@ -3614,7 +3614,7 @@ const void* __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT { - return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr; + return __t == typeid(_Dp) ? std::addressof(__data_.first().second()) : nullptr; } #endif // _LIBCPP_NO_RTTI @@ -3650,13 +3650,13 @@ _LIBCPP_INLINE_VISIBILITY __shared_ptr_emplace(_Alloc __a) - : __data_(_VSTD::move(__a)) {} + : __data_(std::move(__a)) {} template _LIBCPP_INLINE_VISIBILITY __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) - : __data_(piecewise_construct, _VSTD::forward_as_tuple(__a), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {} + : __data_(piecewise_construct, std::forward_as_tuple(__a), + std::forward_as_tuple(std::forward<_Args>(__args)...)) {} #else // _LIBCPP_HAS_NO_VARIADICS @@ -3686,7 +3686,7 @@ virtual void __on_zero_shared_weak() _NOEXCEPT; public: _LIBCPP_INLINE_VISIBILITY - _Tp* get() _NOEXCEPT {return _VSTD::addressof(__data_.second());} + _Tp* get() _NOEXCEPT {return std::addressof(__data_.second());} }; template @@ -4119,9 +4119,9 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__p, __d, __a); - __cntrl_ = _VSTD::addressof(*__hold2.release()); + __cntrl_ = std::addressof(*__hold2.release()); __enable_weak_this(__p, __p); #ifndef _LIBCPP_NO_EXCEPTIONS } @@ -4147,9 +4147,9 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__p, __d, __a); - __cntrl_ = _VSTD::addressof(*__hold2.release()); + __cntrl_ = std::addressof(*__hold2.release()); #ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) @@ -4314,7 +4314,7 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a2; unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...); + ::new(__hold2.get()) _CntrlBlk(__a2, std::forward<_Args>(__args)...); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); __r.__cntrl_ = __hold2.release(); @@ -4333,11 +4333,11 @@ typedef __allocator_destructor<_A2> _D2; _A2 __a2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) - _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...); + ::new(static_cast(std::addressof(*__hold2.get()))) + _CntrlBlk(__a, std::forward<_Args>(__args)...); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); - __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); + __r.__cntrl_ = std::addressof(*__hold2.release()); __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); return __r; } @@ -4430,11 +4430,11 @@ typedef __allocator_destructor<_Alloc2> _D2; _Alloc2 __alloc2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__a); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); - __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); + __r.__cntrl_ = std::addressof(*__hold2.release()); __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); return __r; } @@ -4450,11 +4450,11 @@ typedef __allocator_destructor<_Alloc2> _D2; _Alloc2 __alloc2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__a, __a0); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); - __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); + __r.__cntrl_ = std::addressof(*__hold2.release()); __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); return __r; } @@ -4470,11 +4470,11 @@ typedef __allocator_destructor<_Alloc2> _D2; _Alloc2 __alloc2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__a, __a0, __a1); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); - __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); + __r.__cntrl_ = std::addressof(*__hold2.release()); __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); return __r; } @@ -4490,11 +4490,11 @@ typedef __allocator_destructor<_Alloc2> _D2; _Alloc2 __alloc2(__a); unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1)); - ::new(static_cast(_VSTD::addressof(*__hold2.get()))) + ::new(static_cast(std::addressof(*__hold2.get()))) _CntrlBlk(__a, __a0, __a1, __a2); shared_ptr<_Tp> __r; __r.__ptr_ = __hold2.get()->get(); - __r.__cntrl_ = _VSTD::addressof(*__hold2.release()); + __r.__cntrl_ = std::addressof(*__hold2.release()); __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); return __r; } @@ -4538,7 +4538,7 @@ shared_ptr<_Tp>& shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT { - shared_ptr(_VSTD::move(__r)).swap(*this); + shared_ptr(std::move(__r)).swap(*this); return *this; } @@ -4552,7 +4552,7 @@ >::type shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) { - shared_ptr(_VSTD::move(__r)).swap(*this); + shared_ptr(std::move(__r)).swap(*this); return *this; } @@ -4568,7 +4568,7 @@ >::type& shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) { - shared_ptr(_VSTD::move(__r)).swap(*this); + shared_ptr(std::move(__r)).swap(*this); return *this; } #endif @@ -4585,7 +4585,7 @@ >::type shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) { - shared_ptr(_VSTD::move(__r)).swap(*this); + shared_ptr(std::move(__r)).swap(*this); return *this; } @@ -4620,7 +4620,7 @@ >::type shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r) { - shared_ptr(_VSTD::move(__r)).swap(*this); + shared_ptr(std::move(__r)).swap(*this); return *this; } @@ -4631,8 +4631,8 @@ void shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT { - _VSTD::swap(__ptr_, __r.__ptr_); - _VSTD::swap(__cntrl_, __r.__cntrl_); + std::swap(__ptr_, __r.__ptr_); + std::swap(__cntrl_, __r.__cntrl_); } template @@ -4693,7 +4693,7 @@ >::type make_shared(_Args&& ...__args) { - return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...); + return shared_ptr<_Tp>::make_shared(std::forward<_Args>(__args)...); } template @@ -4705,7 +4705,7 @@ >::type allocate_shared(const _Alloc& __a, _Args&& ...__args) { - return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...); + return shared_ptr<_Tp>::allocate_shared(__a, std::forward<_Args>(__args)...); } #else // _LIBCPP_HAS_NO_VARIADICS @@ -5182,7 +5182,7 @@ weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT { - weak_ptr(_VSTD::move(__r)).swap(*this); + weak_ptr(std::move(__r)).swap(*this); return *this; } @@ -5196,7 +5196,7 @@ >::type weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT { - weak_ptr(_VSTD::move(__r)).swap(*this); + weak_ptr(std::move(__r)).swap(*this); return *this; } @@ -5221,8 +5221,8 @@ void weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT { - _VSTD::swap(__ptr_, __r.__ptr_); - _VSTD::swap(__cntrl_, __r.__cntrl_); + std::swap(__ptr_, __r.__ptr_); + std::swap(__cntrl_, __r.__cntrl_); } template @@ -5479,12 +5479,12 @@ __m.lock(); if (__p->__owner_equivalent(*__v)) { - _VSTD::swap(__temp, *__p); + std::swap(__temp, *__p); *__p = __w; __m.unlock(); return true; } - _VSTD::swap(__temp, *__v); + std::swap(__temp, *__v); *__v = *__p; __m.unlock(); return false; @@ -5592,7 +5592,7 @@ #endif { __swap_allocator(__a1, __a2, - integral_constant::propagate_on_container_swap::value>()); + integral_constant::propagate_on_container_swap::value>()); } template @@ -5604,7 +5604,7 @@ _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) #endif { - using _VSTD::swap; + using std::swap; swap(__a1, __a2); } @@ -5638,7 +5638,7 @@ _LIBCPP_NO_CFI __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) { _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)), - _VSTD::forward<_Args>(__args)...); + std::forward<_Args>(__args)...); } ~__temp_value() { _Traits::destroy(__a, __addr()); } @@ -5651,7 +5651,7 @@ template struct __is_allocator<_Alloc, typename __void_t::type, - typename __void_t().allocate(size_t(0)))>::type + typename __void_t().allocate(size_t(0)))>::type > : true_type {}; Index: include/mutex =================================================================== --- include/mutex +++ include/mutex @@ -466,7 +466,7 @@ void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { __l0.unlock(); __l1.unlock(); - _VSTD::__unlock(__l2, __l3...); + std::__unlock(__l2, __l3...); } #endif // _LIBCPP_CXX03_LANG @@ -519,7 +519,7 @@ explicit scoped_lock(_MArgs&... __margs) : __t_(__margs...) { - _VSTD::lock(__margs...); + std::lock(__margs...); } _LIBCPP_INLINE_VISIBILITY @@ -541,7 +541,7 @@ template _LIBCPP_INLINE_VISIBILITY static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) { - _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...); + std::__unlock(std::get<_Indx>(__mt)...); } _MutexTuple __t_; @@ -619,7 +619,7 @@ _LIBCPP_INLINE_VISIBILITY void __execute(__tuple_indices<_Indices...>) { - __invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...); + __invoke(std::get<0>(std::move(__f_)), std::get<_Indices>(std::move(__f_))...); } }; @@ -662,7 +662,7 @@ if (__libcpp_acquire_load(&__flag.__state_) != ~0ul) { typedef tuple<_Callable&&, _Args&&...> _Gp; - _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...); + _Gp __f(std::forward<_Callable>(__func), std::forward<_Args>(__args)...); __call_once_param<_Gp> __p(__f); __call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>); } Index: include/new =================================================================== --- include/new +++ include/new @@ -349,7 +349,7 @@ _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY constexpr _Tp* launder(_Tp* __p) noexcept { - return _VSTD::__launder(__p); + return std::__launder(__p); } #endif Index: include/numeric =================================================================== --- include/numeric +++ include/numeric @@ -189,7 +189,7 @@ _Tp reduce(_InputIterator __first, _InputIterator __last, _Tp __init) { - return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>()); + return std::reduce(__first, __last, __init, std::plus<>()); } template @@ -197,7 +197,7 @@ typename iterator_traits<_InputIterator>::value_type reduce(_InputIterator __first, _InputIterator __last) { - return _VSTD::reduce(__first, __last, + return std::reduce(__first, __last, typename iterator_traits<_InputIterator>::value_type{}); } #endif @@ -253,8 +253,8 @@ transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) { - return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init), - _VSTD::plus<>(), _VSTD::multiplies<>()); + return std::transform_reduce(__first1, __last1, __first2, std::move(__init), + std::plus<>(), std::multiplies<>()); } #endif @@ -322,7 +322,7 @@ exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) { - return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>()); + return std::exclusive_scan(__first, __last, __result, __init, std::plus<>()); } template @@ -344,7 +344,7 @@ typename std::iterator_traits<_InputIterator>::value_type __init = *__first; *__result++ = __init; if (++__first != __last) - return _VSTD::inclusive_scan(__first, __last, __result, __b, __init); + return std::inclusive_scan(__first, __last, __result, __b, __init); } return __result; @@ -354,7 +354,7 @@ _OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { - return _VSTD::inclusive_scan(__first, __last, __result, std::plus<>()); + return std::inclusive_scan(__first, __last, __result, std::plus<>()); } template ::value_type __init = __u(*__first); *__result++ = __init; if (++__first != __last) - return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init); + return std::transform_inclusive_scan(__first, __last, __result, __b, __u, __init); } return __result; @@ -419,7 +419,7 @@ { typename iterator_traits<_InputIterator>::value_type __t2(*__first); *__result = __t2 - __t1; - __t1 = _VSTD::move(__t2); + __t1 = std::move(__t2); } } return __result; @@ -439,7 +439,7 @@ { typename iterator_traits<_InputIterator>::value_type __t2(*__first); *__result = __binary_op(__t2, __t1); - __t1 = _VSTD::move(__t2); + __t1 = std::move(__t2); } } return __result; @@ -481,7 +481,7 @@ _Tp __gcd(_Tp __m, _Tp __n) { static_assert((!is_signed<_Tp>::value), ""); - return __n == 0 ? __m : _VSTD::__gcd<_Tp>(__n, __m % __n); + return __n == 0 ? __m : std::__gcd<_Tp>(__n, __m % __n); } @@ -495,7 +495,7 @@ static_assert((!is_same::type, bool>::value), "Second argument to gcd cannot be bool" ); using _Rp = common_type_t<_Tp,_Up>; using _Wp = make_unsigned_t<_Rp>; - return static_cast<_Rp>(_VSTD::__gcd( + return static_cast<_Rp>(std::__gcd( static_cast<_Wp>(__abs<_Rp, _Tp>()(__m)), static_cast<_Wp>(__abs<_Rp, _Up>()(__n)))); } @@ -512,7 +512,7 @@ return 0; using _Rp = common_type_t<_Tp,_Up>; - _Rp __val1 = __abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n); + _Rp __val1 = __abs<_Rp, _Tp>()(__m) / std::gcd(__m, __n); _Rp __val2 = __abs<_Rp, _Up>()(__n); _LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm"); return __val1 * __val2; Index: include/optional =================================================================== --- include/optional +++ include/optional @@ -191,7 +191,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_optional_access(); #else - _VSTD::abort(); + std::abort(); #endif } @@ -234,7 +234,7 @@ template _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) - : __val_(_VSTD::forward<_Args>(__args)...), + : __val_(std::forward<_Args>(__args)...), __engaged_(true) {} _LIBCPP_INLINE_VISIBILITY @@ -269,7 +269,7 @@ template _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) - : __val_(_VSTD::forward<_Args>(__args)...), + : __val_(std::forward<_Args>(__args)...), __engaged_(true) {} _LIBCPP_INLINE_VISIBILITY @@ -308,12 +308,12 @@ _LIBCPP_INLINE_VISIBILITY constexpr value_type&& __get() && noexcept { - return _VSTD::move(this->__val_); + return std::move(this->__val_); } _LIBCPP_INLINE_VISIBILITY constexpr const value_type&& __get() const&& noexcept { - return _VSTD::move(this->__val_); + return std::move(this->__val_); } template @@ -321,7 +321,7 @@ void __construct(_Args&&... __args) { _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); - ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); + ::new((void*)std::addressof(this->__val_)) value_type(std::forward<_Args>(__args)...); this->__engaged_ = true; } @@ -330,7 +330,7 @@ void __construct_from(_That&& __opt) { if (__opt.has_value()) - __construct(_VSTD::forward<_That>(__opt).__get()); + __construct(std::forward<_That>(__opt).__get()); } template @@ -340,14 +340,14 @@ if (this->__engaged_ == __opt.has_value()) { if (this->__engaged_) - this->__val_ = _VSTD::forward<_That>(__opt).__get(); + this->__val_ = std::forward<_That>(__opt).__get(); } else { if (this->__engaged_) this->reset(); else - __construct(_VSTD::forward<_That>(__opt).__get()); + __construct(std::forward<_That>(__opt).__get()); } } }; @@ -385,7 +385,7 @@ template _LIBCPP_INLINE_VISIBILITY constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) - : __value_(_VSTD::addressof(__uarg)) + : __value_(std::addressof(__uarg)) { static_assert(__can_bind_reference<_UArg>(), "Attempted to construct a reference element in tuple from a " @@ -405,7 +405,7 @@ _LIBCPP_INLINE_VISIBILITY constexpr value_type&& __get() const&& noexcept - { return _VSTD::forward(*__value_); } + { return std::forward(*__value_); } template _LIBCPP_INLINE_VISIBILITY @@ -415,7 +415,7 @@ static_assert(__can_bind_reference<_UArg>(), "Attempted to construct a reference element in tuple from a " "possible temporary"); - __value_ = _VSTD::addressof(__val); + __value_ = std::addressof(__val); } template @@ -423,7 +423,7 @@ void __construct_from(_That&& __opt) { if (__opt.has_value()) - __construct(_VSTD::forward<_That>(__opt).__get()); + __construct(std::forward<_That>(__opt).__get()); } template @@ -433,14 +433,14 @@ if (has_value() == __opt.has_value()) { if (has_value()) - *__value_ = _VSTD::forward<_That>(__opt).__get(); + *__value_ = std::forward<_That>(__opt).__get(); } else { if (has_value()) reset(); else - __construct(_VSTD::forward<_That>(__opt).__get()); + __construct(std::forward<_That>(__opt).__get()); } } }; @@ -494,7 +494,7 @@ __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v) { - this->__construct_from(_VSTD::move(__opt)); + this->__construct_from(std::move(__opt)); } _LIBCPP_INLINE_VISIBILITY @@ -564,7 +564,7 @@ noexcept(is_nothrow_move_assignable_v && is_nothrow_move_constructible_v) { - this->__assign_from(_VSTD::move(__opt)); + this->__assign_from(std::move(__opt)); return *this; } }; @@ -693,28 +693,28 @@ > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(in_place_t, _Args&&... __args) - : __base(in_place, _VSTD::forward<_Args>(__args)...) {} + : __base(in_place, std::forward<_Args>(__args)...) {} template &, _Args...>> > _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) - : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} + : __base(in_place, __il, std::forward<_Args>(__args)...) {} template ::template __enable_implicit<_Up>() , int> = 0> _LIBCPP_INLINE_VISIBILITY constexpr optional(_Up&& __v) - : __base(in_place, _VSTD::forward<_Up>(__v)) {} + : __base(in_place, std::forward<_Up>(__v)) {} template ::template __enable_explicit<_Up>() , int> = 0> _LIBCPP_INLINE_VISIBILITY constexpr explicit optional(_Up&& __v) - : __base(in_place, _VSTD::forward<_Up>(__v)) {} + : __base(in_place, std::forward<_Up>(__v)) {} // LWG2756: conditionally explicit conversion from const optional<_Up>& template && __v) { - this->__construct_from(_VSTD::move(__v)); + this->__construct_from(std::move(__v)); } template ::template __enable_explicit<_Up>() @@ -749,7 +749,7 @@ _LIBCPP_INLINE_VISIBILITY explicit optional(optional<_Up>&& __v) { - this->__construct_from(_VSTD::move(__v)); + this->__construct_from(std::move(__v)); } _LIBCPP_INLINE_VISIBILITY @@ -779,9 +779,9 @@ operator=(_Up&& __v) { if (this->has_value()) - this->__get() = _VSTD::forward<_Up>(__v); + this->__get() = std::forward<_Up>(__v); else - this->__construct(_VSTD::forward<_Up>(__v)); + this->__construct(std::forward<_Up>(__v)); return *this; } @@ -805,7 +805,7 @@ optional& operator=(optional<_Up>&& __v) { - this->__assign_from(_VSTD::move(__v)); + this->__assign_from(std::move(__v)); return *this; } @@ -820,7 +820,7 @@ emplace(_Args&&... __args) { reset(); - this->__construct(_VSTD::forward<_Args>(__args)...); + this->__construct(std::forward<_Args>(__args)...); return this->__get(); } @@ -835,7 +835,7 @@ emplace(initializer_list<_Up> __il, _Args&&... __args) { reset(); - this->__construct(__il, _VSTD::forward<_Args>(__args)...); + this->__construct(__il, std::forward<_Args>(__args)...); return this->__get(); } @@ -846,7 +846,7 @@ { if (this->has_value() == __opt.has_value()) { - using _VSTD::swap; + using std::swap; if (this->has_value()) swap(this->__get(), __opt.__get()); } @@ -854,12 +854,12 @@ { if (this->has_value()) { - __opt.__construct(_VSTD::move(this->__get())); + __opt.__construct(std::move(this->__get())); reset(); } else { - this->__construct(_VSTD::move(__opt.__get())); + this->__construct(std::move(__opt.__get())); __opt.reset(); } } @@ -872,7 +872,7 @@ { _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF - return _VSTD::addressof(this->__get()); + return std::addressof(this->__get()); #else return __operator_arrow(__has_operator_addressof{}, this->__get()); #endif @@ -885,7 +885,7 @@ { _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value"); #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF - return _VSTD::addressof(this->__get()); + return std::addressof(this->__get()); #else return __operator_arrow(__has_operator_addressof{}, this->__get()); #endif @@ -915,7 +915,7 @@ operator*() && { _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return _VSTD::move(this->__get()); + return std::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY @@ -924,7 +924,7 @@ operator*() const&& { _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value"); - return _VSTD::move(this->__get()); + return std::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY @@ -957,7 +957,7 @@ { if (!this->has_value()) __throw_bad_optional_access(); - return _VSTD::move(this->__get()); + return std::move(this->__get()); } _LIBCPP_INLINE_VISIBILITY @@ -966,7 +966,7 @@ { if (!this->has_value()) __throw_bad_optional_access(); - return _VSTD::move(this->__get()); + return std::move(this->__get()); } template @@ -978,7 +978,7 @@ static_assert(is_convertible_v<_Up, value_type>, "optional::value_or: U must be convertible to T"); return this->has_value() ? this->__get() : - static_cast(_VSTD::forward<_Up>(__v)); + static_cast(std::forward<_Up>(__v)); } template @@ -989,8 +989,8 @@ "optional::value_or: T must be move constructible"); static_assert(is_convertible_v<_Up, value_type>, "optional::value_or: U must be convertible to T"); - return this->has_value() ? _VSTD::move(this->__get()) : - static_cast(_VSTD::forward<_Up>(__v)); + return this->has_value() ? std::move(this->__get()) : + static_cast(std::forward<_Up>(__v)); } using __base::reset; @@ -1001,7 +1001,7 @@ static _Up* __operator_arrow(true_type, _Up& __x) { - return _VSTD::addressof(__x); + return std::addressof(__x); } template @@ -1022,8 +1022,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, + is_convertible_v() == + std::declval()), bool>, bool > operator==(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1038,8 +1038,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, + is_convertible_v() != + std::declval()), bool>, bool > operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1054,8 +1054,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, + is_convertible_v() < + std::declval()), bool>, bool > operator<(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1070,8 +1070,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, + is_convertible_v() > + std::declval()), bool>, bool > operator>(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1086,8 +1086,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, + is_convertible_v() <= + std::declval()), bool>, bool > operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1102,8 +1102,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, + is_convertible_v() >= + std::declval()), bool>, bool > operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) @@ -1216,8 +1216,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, + is_convertible_v() == + std::declval()), bool>, bool > operator==(const optional<_Tp>& __x, const _Up& __v) @@ -1228,8 +1228,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() == - _VSTD::declval()), bool>, + is_convertible_v() == + std::declval()), bool>, bool > operator==(const _Tp& __v, const optional<_Up>& __x) @@ -1240,8 +1240,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, + is_convertible_v() != + std::declval()), bool>, bool > operator!=(const optional<_Tp>& __x, const _Up& __v) @@ -1252,8 +1252,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() != - _VSTD::declval()), bool>, + is_convertible_v() != + std::declval()), bool>, bool > operator!=(const _Tp& __v, const optional<_Up>& __x) @@ -1264,8 +1264,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, + is_convertible_v() < + std::declval()), bool>, bool > operator<(const optional<_Tp>& __x, const _Up& __v) @@ -1276,8 +1276,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() < - _VSTD::declval()), bool>, + is_convertible_v() < + std::declval()), bool>, bool > operator<(const _Tp& __v, const optional<_Up>& __x) @@ -1288,8 +1288,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, + is_convertible_v() <= + std::declval()), bool>, bool > operator<=(const optional<_Tp>& __x, const _Up& __v) @@ -1300,8 +1300,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() <= - _VSTD::declval()), bool>, + is_convertible_v() <= + std::declval()), bool>, bool > operator<=(const _Tp& __v, const optional<_Up>& __x) @@ -1312,8 +1312,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, + is_convertible_v() > + std::declval()), bool>, bool > operator>(const optional<_Tp>& __x, const _Up& __v) @@ -1324,8 +1324,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() > - _VSTD::declval()), bool>, + is_convertible_v() > + std::declval()), bool>, bool > operator>(const _Tp& __v, const optional<_Up>& __x) @@ -1336,8 +1336,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, + is_convertible_v() >= + std::declval()), bool>, bool > operator>=(const optional<_Tp>& __x, const _Up& __v) @@ -1348,8 +1348,8 @@ template _LIBCPP_INLINE_VISIBILITY constexpr enable_if_t< - is_convertible_v() >= - _VSTD::declval()), bool>, + is_convertible_v() >= + std::declval()), bool>, bool > operator>=(const _Tp& __v, const optional<_Up>& __x) @@ -1373,21 +1373,21 @@ _LIBCPP_INLINE_VISIBILITY constexpr optional> make_optional(_Tp&& __v) { - return optional>(_VSTD::forward<_Tp>(__v)); + return optional>(std::forward<_Tp>(__v)); } template _LIBCPP_INLINE_VISIBILITY constexpr optional<_Tp> make_optional(_Args&&... __args) { - return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); + return optional<_Tp>(in_place, std::forward<_Args>(__args)...); } template _LIBCPP_INLINE_VISIBILITY constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) { - return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); + return optional<_Tp>(in_place, __il, std::forward<_Args>(__args)...); } template Index: include/ostream =================================================================== --- include/ostream +++ include/ostream @@ -747,7 +747,7 @@ basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) { - return _VSTD::__put_character_sequence(__os, &__c, 1); + return std::__put_character_sequence(__os, &__c, 1); } template @@ -787,28 +787,28 @@ basic_ostream& operator<<(basic_ostream& __os, char __c) { - return _VSTD::__put_character_sequence(__os, &__c, 1); + return std::__put_character_sequence(__os, &__c, 1); } template basic_ostream& operator<<(basic_ostream& __os, signed char __c) { - return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); + return std::__put_character_sequence(__os, (char *) &__c, 1); } template basic_ostream& operator<<(basic_ostream& __os, unsigned char __c) { - return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); + return std::__put_character_sequence(__os, (char *) &__c, 1); } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) { - return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); + return std::__put_character_sequence(__os, __str, _Traits::length(__str)); } template @@ -861,7 +861,7 @@ basic_ostream& operator<<(basic_ostream& __os, const char* __str) { - return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); + return std::__put_character_sequence(__os, __str, _Traits::length(__str)); } template @@ -869,7 +869,7 @@ operator<<(basic_ostream& __os, const signed char* __str) { const char *__s = (const char *) __str; - return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); + return std::__put_character_sequence(__os, __s, _Traits::length(__s)); } template @@ -877,7 +877,7 @@ operator<<(basic_ostream& __os, const unsigned char* __str) { const char *__s = (const char *) __str; - return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); + return std::__put_character_sequence(__os, __s, _Traits::length(__s)); } template @@ -1034,7 +1034,7 @@ operator<<(_Stream&& __os, const _Tp& __x) { __os << __x; - return _VSTD::move(__os); + return std::move(__os); } #endif // _LIBCPP_CXX03_LANG @@ -1044,7 +1044,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) { - return _VSTD::__put_character_sequence(__os, __str.data(), __str.size()); + return std::__put_character_sequence(__os, __str.data(), __str.size()); } template @@ -1052,7 +1052,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string_view<_CharT, _Traits> __sv) { - return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size()); + return std::__put_character_sequence(__os, __sv.data(), __sv.size()); } template Index: include/queue =================================================================== --- include/queue +++ include/queue @@ -240,19 +240,19 @@ _LIBCPP_INLINE_VISIBILITY queue(queue&& __q) _NOEXCEPT_(is_nothrow_move_constructible::value) - : c(_VSTD::move(__q.c)) {} + : c(std::move(__q.c)) {} _LIBCPP_INLINE_VISIBILITY queue& operator=(queue&& __q) _NOEXCEPT_(is_nothrow_move_assignable::value) - {c = _VSTD::move(__q.c); return *this;} + {c = std::move(__q.c); return *this;} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit queue(const container_type& __c) : c(__c) {} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY - explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {} + explicit queue(container_type&& __c) : c(std::move(__c)) {} #endif // _LIBCPP_CXX03_LANG template _LIBCPP_INLINE_VISIBILITY @@ -278,13 +278,13 @@ queue(container_type&& __c, const _Alloc& __a, typename enable_if::value>::type* = 0) - : c(_VSTD::move(__c), __a) {} + : c(std::move(__c), __a) {} template _LIBCPP_INLINE_VISIBILITY queue(queue&& __q, const _Alloc& __a, typename enable_if::value>::type* = 0) - : c(_VSTD::move(__q.c), __a) {} + : c(std::move(__q.c), __a) {} #endif // _LIBCPP_CXX03_LANG @@ -306,15 +306,15 @@ void push(const value_type& __v) {c.push_back(__v);} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY - void push(value_type&& __v) {c.push_back(_VSTD::move(__v));} + void push(value_type&& __v) {c.push_back(std::move(__v));} template _LIBCPP_INLINE_VISIBILITY #if _LIBCPP_STD_VER > 14 decltype(auto) emplace(_Args&&... __args) - { return c.emplace_back(_VSTD::forward<_Args>(__args)...);} + { return c.emplace_back(std::forward<_Args>(__args)...);} #else void emplace(_Args&&... __args) - { c.emplace_back(_VSTD::forward<_Args>(__args)...);} + { c.emplace_back(std::forward<_Args>(__args)...);} #endif #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -324,7 +324,7 @@ void swap(queue& __q) _NOEXCEPT_(__is_nothrow_swappable::value) { - using _VSTD::swap; + using std::swap; swap(c, __q.c); } @@ -459,13 +459,13 @@ priority_queue(priority_queue&& __q) _NOEXCEPT_(is_nothrow_move_constructible::value && is_nothrow_move_constructible::value) - : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {} + : c(std::move(__q.c)), comp(std::move(__q.comp)) {} _LIBCPP_INLINE_VISIBILITY priority_queue& operator=(priority_queue&& __q) _NOEXCEPT_(is_nothrow_move_assignable::value && is_nothrow_move_assignable::value) - {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;} + {c = std::move(__q.c); comp = std::move(__q.comp); return *this;} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -588,7 +588,7 @@ : c(__c), comp(__comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #ifndef _LIBCPP_CXX03_LANG @@ -597,10 +597,10 @@ inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp, container_type&& __c) - : c(_VSTD::move(__c)), + : c(std::move(__c)), comp(__comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #endif // _LIBCPP_CXX03_LANG @@ -613,7 +613,7 @@ : c(__f, __l), comp(__comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } template @@ -626,7 +626,7 @@ comp(__comp) { c.insert(c.end(), __f, __l); - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #ifndef _LIBCPP_CXX03_LANG @@ -637,11 +637,11 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c) - : c(_VSTD::move(__c)), + : c(std::move(__c)), comp(__comp) { c.insert(c.end(), __f, __l); - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #endif // _LIBCPP_CXX03_LANG @@ -679,7 +679,7 @@ : c(__c, __a), comp(__comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } template @@ -692,7 +692,7 @@ : c(__q.c, __a), comp(__q.comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #ifndef _LIBCPP_CXX03_LANG @@ -705,10 +705,10 @@ const _Alloc& __a, typename enable_if::value>::type*) - : c(_VSTD::move(__c), __a), + : c(std::move(__c), __a), comp(__comp) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } template @@ -718,10 +718,10 @@ const _Alloc& __a, typename enable_if::value>::type*) - : c(_VSTD::move(__q.c), __a), - comp(_VSTD::move(__q.comp)) + : c(std::move(__q.c), __a), + comp(std::move(__q.comp)) { - _VSTD::make_heap(c.begin(), c.end(), comp); + std::make_heap(c.begin(), c.end(), comp); } #endif // _LIBCPP_CXX03_LANG @@ -732,7 +732,7 @@ priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v) { c.push_back(__v); - _VSTD::push_heap(c.begin(), c.end(), comp); + std::push_heap(c.begin(), c.end(), comp); } #ifndef _LIBCPP_CXX03_LANG @@ -742,8 +742,8 @@ void priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v) { - c.push_back(_VSTD::move(__v)); - _VSTD::push_heap(c.begin(), c.end(), comp); + c.push_back(std::move(__v)); + std::push_heap(c.begin(), c.end(), comp); } template @@ -752,8 +752,8 @@ void priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args) { - c.emplace_back(_VSTD::forward<_Args>(__args)...); - _VSTD::push_heap(c.begin(), c.end(), comp); + c.emplace_back(std::forward<_Args>(__args)...); + std::push_heap(c.begin(), c.end(), comp); } #endif // _LIBCPP_CXX03_LANG @@ -763,7 +763,7 @@ void priority_queue<_Tp, _Container, _Compare>::pop() { - _VSTD::pop_heap(c.begin(), c.end(), comp); + std::pop_heap(c.begin(), c.end(), comp); c.pop_back(); } @@ -774,7 +774,7 @@ _NOEXCEPT_(__is_nothrow_swappable::value && __is_nothrow_swappable::value) { - using _VSTD::swap; + using std::swap; swap(c, __q.c); swap(comp, __q.comp); } Index: include/random =================================================================== --- include/random +++ include/random @@ -2397,37 +2397,37 @@ _Bp, _Tp, _Cp, _Lp, _Fp>& __y) { if (__x.__i_ == __y.__i_) - return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + _Np, __y.__x_); if (__x.__i_ == 0 || __y.__i_ == 0) { - size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_); - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, + size_t __j = std::min(_Np - __x.__i_, _Np - __y.__i_); + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_)) return false; if (__x.__i_ == 0) - return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_); - return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j); + return std::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j); } if (__x.__i_ < __y.__i_) { size_t __j = _Np - __y.__i_; - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_)) return false; - if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, + if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, __y.__x_)) return false; - return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, + return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Np - (__x.__i_ + __j))); } size_t __j = _Np - __x.__i_; - if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), + if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_)) return false; - if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, + if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, __x.__x_)) return false; - return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, + return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Np - (__y.__i_ + __j))); } @@ -2723,37 +2723,37 @@ if (__x.__c_ != __y.__c_) return false; if (__x.__i_ == __y.__i_) - return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_); if (__x.__i_ == 0 || __y.__i_ == 0) { - size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_); - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, + size_t __j = std::min(_Rp - __x.__i_, _Rp - __y.__i_); + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_)) return false; if (__x.__i_ == 0) - return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_); - return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j); + return std::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_); + return std::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j); } if (__x.__i_ < __y.__i_) { size_t __j = _Rp - __y.__i_; - if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), + if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_)) return false; - if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, + if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, __y.__x_)) return false; - return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_, + return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Rp - (__x.__i_ + __j))); } size_t __j = _Rp - __x.__i_; - if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), + if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_)) return false; - if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, + if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, __x.__x_)) return false; - return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_, + return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Rp - (__y.__i_ + __j))); } @@ -2851,7 +2851,7 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit discard_block_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)), __n_(0) {} + : __e_(std::move(__e)), __n_(0) {} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {} @@ -3061,7 +3061,7 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit independent_bits_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)) {} + : __e_(std::move(__e)) {} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit independent_bits_engine(result_type __sd) : __e_(__sd) {} @@ -3291,7 +3291,7 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit shuffle_order_engine(_Engine&& __e) - : __e_(_VSTD::move(__e)) {__init();} + : __e_(std::move(__e)) {__init();} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();} @@ -3420,7 +3420,7 @@ const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y) { - return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) && + return __x._Y_ == __y._Y_ && std::equal(__x._V_, __x._V_ + _Kp, __y._V_) && __x.__e_ == __y.__e_; } @@ -3550,7 +3550,7 @@ template _LIBCPP_INLINE_VISIBILITY void param(_OutputIterator __dest) const - {_VSTD::copy(__v_.begin(), __v_.end(), __dest);} + {std::copy(__v_.begin(), __v_.end(), __dest);} private: // no copy functions @@ -3575,7 +3575,7 @@ { if (__first != __last) { - _VSTD::fill(__first, __last, 0x8b8b8b8b); + std::fill(__first, __last, 0x8b8b8b8b); const size_t __n = static_cast(__last - __first); const size_t __s = __v_.size(); const size_t __t = (__n >= 623) ? 11 @@ -3585,7 +3585,7 @@ : (__n - 1) / 2; const size_t __p = (__n - __t) / 2; const size_t __q = __p + __t; - const size_t __m = _VSTD::max(__s + 1, __n); + const size_t __m = std::max(__s + 1, __n); // __k = 0; { result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p] @@ -3775,7 +3775,7 @@ uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { return (__p.b() - __p.a()) - * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) + * std::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) + __p.a(); } @@ -4020,10 +4020,10 @@ if (0 < __p_ && __p_ < 1) { __r0_ = static_cast((__t_ + 1) * __p_); - __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) - + __pr_ = std::exp(__libcpp_lgamma(__t_ + 1.) - __libcpp_lgamma(__r0_ + 1.) - - __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) + - (__t_ - __r0_) * _VSTD::log(1 - __p_)); + __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * std::log(__p_) + + (__t_ - __r0_) * std::log(1 - __p_)); __odds_ratio_ = __p_ / (1 - __p_); } } @@ -4178,10 +4178,10 @@ _RealType exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { - return -_VSTD::log + return -std::log ( result_type(1) - - _VSTD::generate_canonical::digits>(__g) ) / __p.lambda(); @@ -4333,7 +4333,7 @@ __v = _Uni(__g); __s = __u * __u + __v * __v; } while (__s > 1 || __s == 0); - result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s); + result_type _Fp = std::sqrt(-2 * std::log(__s) / __s); _V_ = __v * _Fp; _V_hot_ = true; _Up = __u * _Fp; @@ -4450,7 +4450,7 @@ template _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p) - {return _VSTD::exp(const_cast&>(__p.__nd_)(__g));} + {return std::exp(const_cast&>(__p.__nd_)(__g));} // property functions _LIBCPP_INLINE_VISIBILITY @@ -4599,7 +4599,7 @@ { __s_ = 0; __d_ = 0; - __l_ = _VSTD::exp(-__mean_); + __l_ = std::exp(-__mean_); __omega_ = 0; __c3_ = 0; __c2_ = 0; @@ -4609,7 +4609,7 @@ } else { - __s_ = _VSTD::sqrt(__mean_); + __s_ = std::sqrt(__mean_); __d_ = 6 * __mean_ * __mean_; __l_ = static_cast(__mean_ - 1.1484); __omega_ = .3989423 / __s_; @@ -4676,20 +4676,20 @@ const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}; __px = -__pr.__mean_; - __py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x]; + __py = std::pow(__pr.__mean_, (double)__x) / __fac[__x]; } else { double __del = .8333333E-1 / __x; __del -= 4.8 * __del * __del * __del; double __v = __difmuk / __x; - if (_VSTD::abs(__v) > 0.25) - __px = __x * _VSTD::log(1 + __v) - __difmuk - __del; + if (std::abs(__v) > 0.25) + __px = __x * std::log(1 + __v) - __difmuk - __del; else __px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) * __v + .1421878) * __v + -.1661269) * __v + .2000118) * __v + -.2500068) * __v + .3333333) * __v + -.5) - __del; - __py = .3989423 / _VSTD::sqrt(__x); + __py = .3989423 / std::sqrt(__x); } double __r = (0.5 - __difmuk) / __pr.__s_; double __r2 = __r * __r; @@ -4698,13 +4698,13 @@ __r2 + __pr.__c1_) * __r2 + __pr.__c0_); if (__using_exp_dist) { - if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) - - __fy * _VSTD::exp(__fx + __e)) + if (__pr.__c_ * std::abs(__u) <= __py * std::exp(__px + __e) - + __fy * std::exp(__fx + __e)) break; } else { - if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx)) + if (__fy - __u * __fy <= __py * std::exp(__px - __fx)) break; } } @@ -4795,7 +4795,7 @@ _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p) {return __p.b() * - _VSTD::pow(exponential_distribution()(__g), 1/__p.a());} + std::pow(exponential_distribution()(__g), 1/__p.a());} // property functions _LIBCPP_INLINE_VISIBILITY @@ -4939,7 +4939,7 @@ extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { return __p.a() - __p.b() * - _VSTD::log(-_VSTD::log(1-uniform_real_distribution()(__g))); + std::log(-std::log(1-uniform_real_distribution()(__g))); } template @@ -5076,7 +5076,7 @@ const result_type __w = __u * (1 - __u); if (__w != 0) { - const result_type __y = _VSTD::sqrt(__c / __w) * + const result_type __y = std::sqrt(__c / __w) * (__u - result_type(0.5)); __x = __b + __y; if (__x >= 0) @@ -5084,7 +5084,7 @@ const result_type __z = 64 * __w * __w * __w * __v * __v; if (__z <= 1 - 2 * __y * __y / __x) break; - if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y)) + if (std::log(__z) <= 2 * (__b * std::log(__x / __b) - __y)) break; } } @@ -5098,14 +5098,14 @@ const result_type __es = __egen(__g); if (__u <= 1 - __a) { - __x = _VSTD::pow(__u, 1 / __a); + __x = std::pow(__u, 1 / __a); if (__x <= __es) break; } else { - const result_type __e = -_VSTD::log((1-__u)/__a); - __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a); + const result_type __e = -std::log((1-__u)/__a); + __x = std::pow(1 - __a + __a * __e, 1 / __a); if (__x <= __e + __es) break; } @@ -5577,7 +5577,7 @@ { uniform_real_distribution __gen; // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite - return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g)); + return __p.a() + __p.b() * std::tan(3.1415926535897932384626433832795 * __gen(__g)); } template @@ -5815,7 +5815,7 @@ student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) { gamma_distribution __gd(__p.n() * .5, 2); - return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g)); + return __nd_(__g) * std::sqrt(__p.n()/__gd(__g)); } template @@ -6000,12 +6000,12 @@ { if (__p_.size() > 1) { - double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0); - for (_VSTD::vector::iterator __i = __p_.begin(), __e = __p_.end(); + double __s = std::accumulate(__p_.begin(), __p_.end(), 0.0); + for (std::vector::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i) *__i /= __s; vector __t(__p_.size() - 1); - _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin()); + std::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin()); swap(__p_, __t); } else @@ -6021,8 +6021,8 @@ discrete_distribution<_IntType>::param_type::probabilities() const { size_t __n = __p_.size(); - _VSTD::vector __p(__n+1); - _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin()); + std::vector __p(__n+1); + std::adjacent_difference(__p_.begin(), __p_.end(), __p.begin()); if (__n > 0) __p[__n] = 1 - __p_[__n-1]; else @@ -6037,7 +6037,7 @@ { uniform_real_distribution __gen; return static_cast<_IntType>( - _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - + std::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - __p.__p_.begin()); } @@ -6237,14 +6237,14 @@ piecewise_constant_distribution<_RealType>::param_type::__init() { // __densities_ contains non-normalized areas - result_type __total_area = _VSTD::accumulate(__densities_.begin(), + result_type __total_area = std::accumulate(__densities_.begin(), __densities_.end(), result_type()); for (size_t __i = 0; __i < __densities_.size(); ++__i) __densities_[__i] /= __total_area; // __densities_ contains normalized areas __areas_.assign(__densities_.size(), result_type()); - _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1, + std::partial_sum(__densities_.begin(), __densities_.end() - 1, __areas_.begin() + 1); // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1] __densities_.back() = 1 - __areas_.back(); // correct round off error @@ -6337,7 +6337,7 @@ { typedef uniform_real_distribution _Gen; result_type __u = _Gen()(__g); - ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), + ptrdiff_t __k = std::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) - __p.__areas_.begin() - 1; return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k]; } @@ -6665,7 +6665,7 @@ { typedef uniform_real_distribution _Gen; result_type __u = _Gen()(__g); - ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), + ptrdiff_t __k = std::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) - __p.__areas_.begin() - 1; __u -= __p.__areas_[__k]; const result_type __dk = __p.__densities_[__k]; @@ -6677,7 +6677,7 @@ const result_type __bk1 = __p.__b_[__k+1]; const result_type __deltab = __bk1 - __bk; return (__bk * __dk1 - __bk1 * __dk + - _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / + std::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / __deltad; } Index: include/regex =================================================================== --- include/regex +++ include/regex @@ -975,7 +975,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw regex_error(_Ev); #else - _VSTD::abort(); + std::abort(); #endif } @@ -1344,7 +1344,7 @@ __node(const __node&); __node& operator=(const __node&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __node() {} @@ -1364,7 +1364,7 @@ : public __node<_CharT> { public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __end_state() {} @@ -1429,7 +1429,7 @@ typedef __owns_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __empty_state(__node<_CharT>* __s) @@ -1455,7 +1455,7 @@ typedef __has_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __empty_non_own_state(__node<_CharT>* __s) @@ -1481,7 +1481,7 @@ typedef __has_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __repeat_one_loop(__node<_CharT>* __s) @@ -1543,7 +1543,7 @@ bool __greedy_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __loop(unsigned __loop_id, @@ -1642,7 +1642,7 @@ typedef __owns_two_states<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __alternate(__owns_one_state<_CharT>* __s1, @@ -1681,7 +1681,7 @@ unsigned __mexp_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) @@ -1709,7 +1709,7 @@ unsigned __mexp_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s) @@ -1738,7 +1738,7 @@ unsigned __mexp_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) @@ -1758,7 +1758,7 @@ { ptrdiff_t __len = __sm.second - __sm.first; if (__s.__last_ - __s.__current_ >= __len && - _VSTD::equal(__sm.first, __sm.second, __s.__current_)) + std::equal(__sm.first, __sm.second, __s.__current_)) { __s.__do_ = __state::__accept_but_not_consume; __s.__current_ += __len; @@ -1788,7 +1788,7 @@ _Traits __traits_; unsigned __mexp_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, @@ -1843,7 +1843,7 @@ _Traits __traits_; unsigned __mexp_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, @@ -1898,7 +1898,7 @@ _Traits __traits_; bool __invert_; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY explicit __word_boundary(const _Traits& __traits, bool __invert, @@ -1966,7 +1966,7 @@ typedef __owns_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __l_anchor(__node<_CharT>* __s) @@ -2001,7 +2001,7 @@ typedef __owns_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __r_anchor(__node<_CharT>* __s) @@ -2036,7 +2036,7 @@ typedef __owns_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_any(__node<_CharT>* __s) @@ -2071,7 +2071,7 @@ typedef __owns_one_state<_CharT> base; public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_any_but_newline(__node<_CharT>* __s) @@ -2096,7 +2096,7 @@ __match_char(const __match_char&); __match_char& operator=(const __match_char&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char(_CharT __c, __node<_CharT>* __s) @@ -2136,7 +2136,7 @@ __match_char_icase(const __match_char_icase&); __match_char_icase& operator=(const __match_char_icase&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) @@ -2177,7 +2177,7 @@ __match_char_collate(const __match_char_collate&); __match_char_collate& operator=(const __match_char_collate&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s) @@ -2229,7 +2229,7 @@ __bracket_expression(const __bracket_expression&); __bracket_expression& operator=(const __bracket_expression&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, @@ -2295,7 +2295,7 @@ __b[0] = __traits_.translate_nocase(__b[0]); __e[0] = __traits_.translate_nocase(__e[0]); } - __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e))); + __ranges_.push_back(make_pair(std::move(__b), std::move(__e))); } } _LIBCPP_INLINE_VISIBILITY @@ -2332,7 +2332,7 @@ ++__consumed; if (__might_have_digraph_) { - const _CharT* __next = _VSTD::next(__s.__current_); + const _CharT* __next = std::next(__s.__current_); if (__next != __s.__last_) { pair<_CharT, _CharT> __ch2(*__s.__current_, *__next); @@ -2504,8 +2504,8 @@ shared_ptr<__empty_state<_CharT> > __start_; __owns_one_state<_CharT>* __end_; - typedef _VSTD::__state<_CharT> __state; - typedef _VSTD::__node<_CharT> __node; + typedef std::__state<_CharT> __state; + typedef std::__node<_CharT> __node; public: // constants: @@ -2585,7 +2585,7 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY basic_regex& assign(basic_regex&& __that) _NOEXCEPT - {return *this = _VSTD::move(__that);} + {return *this = std::move(__that);} #endif _LIBCPP_INLINE_VISIBILITY basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript) @@ -2959,7 +2959,7 @@ void basic_regex<_CharT, _Traits>::swap(basic_regex& __r) { - using _VSTD::swap; + using std::swap; swap(__traits_, __r.__traits_); swap(__flags_, __r.__flags_); swap(__marked_count_, __r.__marked_count_); @@ -2992,7 +2992,7 @@ __lookahead(const __lookahead&); __lookahead& operator=(const __lookahead&); public: - typedef _VSTD::__state<_CharT> __state; + typedef std::__state<_CharT> __state; _LIBCPP_INLINE_VISIBILITY __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp) @@ -3082,7 +3082,7 @@ __first = __parse_RE_expression(__first, __last); if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp == __last && *__first == '$') { __push_r_anchor(); @@ -3299,7 +3299,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\' && *__temp == '(') @@ -3317,7 +3317,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\' && *__temp == ')') @@ -3335,7 +3335,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\' && *__temp == '{') @@ -3353,7 +3353,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\' && *__temp == '}') @@ -3371,7 +3371,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\') @@ -3396,7 +3396,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp == __last && *__first == '$') return __first; // Not called inside a bracket @@ -3454,7 +3454,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\') @@ -3485,7 +3485,7 @@ { if (__first != __last) { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__first == '\\') @@ -3764,7 +3764,7 @@ { if (__first != __last && *__first != ']') { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); basic_string<_CharT> __start_range; if (__temp != __last && *__first == '[') { @@ -3793,7 +3793,7 @@ } if (__first != __last && *__first != ']') { - __temp = _VSTD::next(__first); + __temp = std::next(__first); if (__temp != __last && *__first == '-' && *__temp != ']') { // parse a range @@ -3819,7 +3819,7 @@ ++__first; } } - __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range)); + __ml->__add_range(std::move(__start_range), std::move(__end_range)); } else if (!__start_range.empty()) { @@ -3974,7 +3974,7 @@ // Found [= // This means =] must exist value_type _Equal_close[2] = {'=', ']'}; - _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close, + _ForwardIterator __temp = std::search(__first, __last, _Equal_close, _Equal_close+2); if (__temp == __last) __throw_regex_error(); @@ -4002,7 +4002,7 @@ __throw_regex_error(); } } - __first = _VSTD::next(__temp, 2); + __first = std::next(__temp, 2); return __first; } @@ -4016,7 +4016,7 @@ // Found [: // This means :] must exist value_type _Colon_close[2] = {':', ']'}; - _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close, + _ForwardIterator __temp = std::search(__first, __last, _Colon_close, _Colon_close+2); if (__temp == __last) __throw_regex_error(); @@ -4027,7 +4027,7 @@ if (__class_type == 0) __throw_regex_error(); __ml->__add_class(__class_type); - __first = _VSTD::next(__temp, 2); + __first = std::next(__temp, 2); return __first; } @@ -4041,7 +4041,7 @@ // Found [. // This means .] must exist value_type _Dot_close[2] = {'.', ']'}; - _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close, + _ForwardIterator __temp = std::search(__first, __last, _Dot_close, _Dot_close+2); if (__temp == __last) __throw_regex_error(); @@ -4055,7 +4055,7 @@ default: __throw_regex_error(); } - __first = _VSTD::next(__temp, 2); + __first = std::next(__temp, 2); return __first; } @@ -4166,7 +4166,7 @@ break; case '\\': { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last) { if (*__temp == 'b') @@ -4184,7 +4184,7 @@ break; case '(': { - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last && *__temp == '?') { if (++__temp != __last) @@ -4197,7 +4197,7 @@ __exp.__flags_ = __flags_; __temp = __exp.__parse(++__temp, __last); unsigned __mexp = __exp.__marked_count_; - __push_lookahead(_VSTD::move(__exp), false, __marked_count_); + __push_lookahead(std::move(__exp), false, __marked_count_); __marked_count_ += __mexp; if (__temp == __last || *__temp != ')') __throw_regex_error(); @@ -4210,7 +4210,7 @@ __exp.__flags_ = __flags_; __temp = __exp.__parse(++__temp, __last); unsigned __mexp = __exp.__marked_count_; - __push_lookahead(_VSTD::move(__exp), true, __marked_count_); + __push_lookahead(std::move(__exp), true, __marked_count_); __marked_count_ += __mexp; if (__temp == __last || *__temp != ')') __throw_regex_error(); @@ -4252,7 +4252,7 @@ ++__first; if (__first == __last) __throw_regex_error(); - _ForwardIterator __temp = _VSTD::next(__first); + _ForwardIterator __temp = std::next(__first); if (__temp != __last && *__first == '?' && *__temp == ':') { ++__open_count_; @@ -4298,7 +4298,7 @@ { if (__first != __last && *__first == '\\') { - _ForwardIterator __t1 = _VSTD::next(__first); + _ForwardIterator __t1 = std::next(__first); if (__t1 == __last) __throw_regex_error(); @@ -4450,7 +4450,7 @@ ++__first; break; case 'c': - if ((__t = _VSTD::next(__first)) != __last) + if ((__t = std::next(__first)) != __last) { if (('A' <= *__t && *__t <= 'Z') || ('a' <= *__t && *__t <= 'z')) @@ -4569,7 +4569,7 @@ _ForwardIterator __last) { __owns_one_state<_CharT>* __sa = __end_; - _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n')); + _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n')); if (__t1 != __first) __parse_basic_reg_exp(__first, __t1); else @@ -4579,7 +4579,7 @@ ++__first; while (__first != __last) { - __t1 = _VSTD::find(__first, __last, _CharT('\n')); + __t1 = std::find(__first, __last, _CharT('\n')); __owns_one_state<_CharT>* __sb = __end_; if (__t1 != __first) __parse_basic_reg_exp(__first, __t1); @@ -4600,7 +4600,7 @@ _ForwardIterator __last) { __owns_one_state<_CharT>* __sa = __end_; - _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n')); + _ForwardIterator __t1 = std::find(__first, __last, _CharT('\n')); if (__t1 != __first) __parse_extended_reg_exp(__first, __t1); else @@ -4610,7 +4610,7 @@ ++__first; while (__first != __last) { - __t1 = _VSTD::find(__first, __last, _CharT('\n')); + __t1 = std::find(__first, __last, _CharT('\n')); __owns_one_state<_CharT>* __sb = __end_; if (__t1 != __first) __parse_extended_reg_exp(__first, __t1); @@ -4808,7 +4808,7 @@ _LIBCPP_INLINE_VISIBILITY difference_type length() const - {return matched ? _VSTD::distance(this->first, this->second) : 0;} + {return matched ? std::distance(this->first, this->second) : 0;} _LIBCPP_INLINE_VISIBILITY string_type str() const {return matched ? string_type(this->first, this->second) : string_type();} @@ -5264,7 +5264,7 @@ {return (*this)[__sub].length();} _LIBCPP_INLINE_VISIBILITY difference_type position(size_type __sub = 0) const - {return _VSTD::distance(__position_start_, (*this)[__sub].first);} + {return std::distance(__position_start_, (*this)[__sub].first);} _LIBCPP_INLINE_VISIBILITY string_type str(size_type __sub = 0) const {return (*this)[__sub].str();} @@ -5336,18 +5336,18 @@ __matches_.resize(__m.size()); for (size_type __i = 0; __i < __matches_.size(); ++__i) { - __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first)); - __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second)); + __matches_[__i].first = std::next(__f, std::distance(__mf, __m[__i].first)); + __matches_[__i].second = std::next(__f, std::distance(__mf, __m[__i].second)); __matches_[__i].matched = __m[__i].matched; } __unmatched_.first = __l; __unmatched_.second = __l; __unmatched_.matched = false; - __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first)); - __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second)); + __prefix_.first = std::next(__f, std::distance(__mf, __m.prefix().first)); + __prefix_.second = std::next(__f, std::distance(__mf, __m.prefix().second)); __prefix_.matched = __m.prefix().matched; - __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first)); - __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second)); + __suffix_.first = std::next(__f, std::distance(__mf, __m.suffix().first)); + __suffix_.second = std::next(__f, std::distance(__mf, __m.suffix().second)); __suffix_.matched = __m.suffix().matched; if (!__no_update_pos) __position_start_ = __prefix_.first; @@ -5418,7 +5418,7 @@ for (; __fmt_first != __fmt_last; ++__fmt_first) { if (*__fmt_first == '&') - __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second, + __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter); else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) { @@ -5426,7 +5426,7 @@ if ('0' <= *__fmt_first && *__fmt_first <= '9') { size_t __i = *__fmt_first - '0'; - __output_iter = _VSTD::copy((*this)[__i].first, + __output_iter = std::copy((*this)[__i].first, (*this)[__i].second, __output_iter); } else @@ -5456,16 +5456,16 @@ break; case '&': ++__fmt_first; - __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second, + __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter); break; case '`': ++__fmt_first; - __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter); + __output_iter = std::copy(__prefix_.first, __prefix_.second, __output_iter); break; case '\'': ++__fmt_first; - __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter); + __output_iter = std::copy(__suffix_.first, __suffix_.second, __output_iter); break; default: if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') @@ -5480,7 +5480,7 @@ __throw_regex_error(); __idx = 10 * __idx + *__fmt_first - '0'; } - __output_iter = _VSTD::copy((*this)[__idx].first, + __output_iter = std::copy((*this)[__idx].first, (*this)[__idx].second, __output_iter); } else @@ -5505,7 +5505,7 @@ void match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m) { - using _VSTD::swap; + using std::swap; swap(__matches_, __m.__matches_); swap(__unmatched_, __m.__unmatched_); swap(__prefix_, __m.__prefix_); @@ -5607,7 +5607,7 @@ break; } __m.__matches_[0].first = __first; - __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first); + __m.__matches_[0].second = std::next(__first, __s.__current_ - __first); __m.__matches_[0].matched = true; for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i) __m.__matches_[__i+1] = __s.__sub_matches_[__i]; @@ -5621,7 +5621,7 @@ __state __snext = __s; __s.__node_->__exec_split(true, __s); __snext.__node_->__exec_split(false, __snext); - __states.push_back(_VSTD::move(__snext)); + __states.push_back(std::move(__snext)); } break; case __state::__reject: @@ -5647,7 +5647,7 @@ { deque<__state> __states; ptrdiff_t __highest_j = 0; - ptrdiff_t _Np = _VSTD::distance(__first, __last); + ptrdiff_t _Np = std::distance(__first, __last); __node* __st = __start_.get(); if (__st) { @@ -5698,7 +5698,7 @@ case __state::__consume_input: break; case __state::__accept_and_consume: - __states.push_front(_VSTD::move(__s)); + __states.push_front(std::move(__s)); __states.pop_back(); break; case __state::__repeat: @@ -5709,7 +5709,7 @@ __state __snext = __s; __s.__node_->__exec_split(true, __s); __snext.__node_->__exec_split(false, __snext); - __states.push_back(_VSTD::move(__snext)); + __states.push_back(std::move(__snext)); } break; case __state::__reject: @@ -5723,7 +5723,7 @@ if (__matched) { __m.__matches_[0].first = __first; - __m.__matches_[0].second = _VSTD::next(__first, __highest_j); + __m.__matches_[0].second = std::next(__first, __highest_j); __m.__matches_[0].matched = true; return true; } @@ -5743,7 +5743,7 @@ __state __best_state; ptrdiff_t __j = 0; ptrdiff_t __highest_j = 0; - ptrdiff_t _Np = _VSTD::distance(__first, __last); + ptrdiff_t _Np = std::distance(__first, __last); __node* __st = __start_.get(); if (__st) { @@ -5813,7 +5813,7 @@ __state __snext = __s; __s.__node_->__exec_split(true, __s); __snext.__node_->__exec_split(false, __snext); - __states.push_back(_VSTD::move(__snext)); + __states.push_back(std::move(__snext)); } break; case __state::__reject: @@ -5827,7 +5827,7 @@ if (__matched) { __m.__matches_[0].first = __first; - __m.__matches_[0].second = _VSTD::next(__first, __highest_j); + __m.__matches_[0].second = std::next(__first, __highest_j); __m.__matches_[0].matched = true; for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i) __m.__matches_[__i+1] = __best_state.__sub_matches_[__i]; @@ -5901,7 +5901,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0; - basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last); + basic_string<_CharT> __s(std::prev(__first, __offset), __last); match_results __mc; bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags); __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos); @@ -5974,7 +5974,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results __m; - return _VSTD::regex_search(__str, __m, __e, __flags); + return std::regex_search(__str, __m, __e, __flags); } template @@ -6020,7 +6020,7 @@ const basic_regex<_CharT, _Traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { - bool __r = _VSTD::regex_search( + bool __r = std::regex_search( __first, __last, __m, __e, __flags | regex_constants::match_continuous | regex_constants::__full_match); @@ -6041,7 +6041,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results<_BidirectionalIterator> __m; - return _VSTD::regex_match(__first, __last, __m, __e, __flags); + return std::regex_match(__first, __last, __m, __e, __flags); } template @@ -6051,7 +6051,7 @@ const basic_regex<_CharT, _Traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags); + return std::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags); } template @@ -6062,7 +6062,7 @@ const basic_regex<_CharT, _Traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags); + return std::regex_match(__s.begin(), __s.end(), __m, __e, __flags); } #if _LIBCPP_STD_VER > 11 @@ -6081,7 +6081,7 @@ regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags); + return std::regex_match(__str, __str + _Traits::length(__str), __e, __flags); } template @@ -6091,7 +6091,7 @@ const basic_regex<_CharT, _Traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags); + return std::regex_match(__s.begin(), __s.end(), __e, __flags); } // regex_iterator @@ -6163,7 +6163,7 @@ __pregex_(&__re), __flags_(__m) { - _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_); + std::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_); } template @@ -6195,7 +6195,7 @@ __match_ = value_type(); return *this; } - else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_, + else if (std::regex_search(__start, __end_, __match_, *__pregex_, __flags_ | regex_constants::match_not_null | regex_constants::match_continuous)) return *this; @@ -6203,7 +6203,7 @@ ++__start; } __flags_ |= regex_constants::match_prev_avail; - if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) + if (!std::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) __match_ = value_type(); return *this; } @@ -6481,7 +6481,7 @@ __establish_result(); else { - if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() + if (std::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() && __prev->suffix().length() != 0) { __suffix_.matched = true; @@ -6517,7 +6517,7 @@ if (__i == __eof) { if (!(__flags & regex_constants::format_no_copy)) - __output_iter = _VSTD::copy(__first, __last, __output_iter); + __output_iter = std::copy(__first, __last, __output_iter); } else { @@ -6525,14 +6525,14 @@ for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) { if (!(__flags & regex_constants::format_no_copy)) - __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter); + __output_iter = std::copy(__i->prefix().first, __i->prefix().second, __output_iter); __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags); __lm = __i->suffix(); if (__flags & regex_constants::format_first_only) break; } if (!(__flags & regex_constants::format_no_copy)) - __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter); + __output_iter = std::copy(__lm.first, __lm.second, __output_iter); } return __output_iter; } @@ -6547,7 +6547,7 @@ const basic_string<_CharT, _ST, _SA>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { - return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags); + return std::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags); } template __r; - _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, + std::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, __fmt.c_str(), __flags); return __r; } @@ -6573,7 +6573,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_CharT, _ST, _SA> __r; - _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, + std::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e, __fmt, __flags); return __r; } @@ -6587,7 +6587,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_CharT> __r; - _VSTD::regex_replace(back_inserter(__r), __s, + std::regex_replace(back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt.c_str(), __flags); return __r; @@ -6602,7 +6602,7 @@ regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_CharT> __r; - _VSTD::regex_replace(back_inserter(__r), __s, + std::regex_replace(back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt, __flags); return __r; Index: include/scoped_allocator =================================================================== --- include/scoped_allocator +++ include/scoped_allocator @@ -216,7 +216,7 @@ _LIBCPP_INLINE_VISIBILITY __scoped_allocator_storage(_OuterA2&& __outerAlloc, const _InnerAllocs& ...__innerAllocs) _NOEXCEPT - : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)), + : outer_allocator_type(std::forward<_OuterA2>(__outerAlloc)), __inner_(__innerAllocs...) {} template && __other) _NOEXCEPT - : outer_allocator_type(_VSTD::move(__other.outer_allocator())), - __inner_(_VSTD::move(__other.inner_allocator())) {} + : outer_allocator_type(std::move(__other.outer_allocator())), + __inner_(std::move(__other.inner_allocator())) {} template (__o)), + : outer_allocator_type(std::forward<_OuterA2>(__o)), __inner_(__i) { } @@ -296,7 +296,7 @@ >::type> _LIBCPP_INLINE_VISIBILITY __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT - : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {} + : outer_allocator_type(std::forward<_OuterA2>(__outerAlloc)) {} template && __other) _NOEXCEPT - : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {} + : outer_allocator_type(std::move(__other.outer_allocator())) {} _LIBCPP_INLINE_VISIBILITY inner_allocator_type& inner_allocator() _NOEXCEPT @@ -376,7 +376,7 @@ { typedef typename remove_reference < - decltype(_VSTD::declval<_Alloc>().outer_allocator()) + decltype(std::declval<_Alloc>().outer_allocator()) >::type _OuterAlloc; typedef typename __outermost<_OuterAlloc>::type type; _LIBCPP_INLINE_VISIBILITY @@ -441,7 +441,7 @@ _LIBCPP_INLINE_VISIBILITY scoped_allocator_adaptor(_OuterA2&& __outerAlloc, const _InnerAllocs& ...__innerAllocs) _NOEXCEPT - : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {} + : base(std::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {} // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default; template && __other) _NOEXCEPT - : base(_VSTD::move(__other)) {} + : base(std::move(__other)) {} // scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default; // scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default; @@ -500,7 +500,7 @@ _LIBCPP_INLINE_VISIBILITY void construct(_Tp* __p, _Args&& ...__args) {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(), - __p, _VSTD::forward<_Args>(__args)...);} + __p, std::forward<_Args>(__args)...);} template void construct(pair<_T1, _T2>* __p, piecewise_construct_t, @@ -513,14 +513,14 @@ typename __uses_alloc_ctor< _T1, inner_allocator_type&, _Args1... >::type() - , _VSTD::move(__x) + , std::move(__x) , typename __make_tuple_indices::type{} ) , __transform_tuple( typename __uses_alloc_ctor< _T2, inner_allocator_type&, _Args2... >::type() - , _VSTD::move(__y) + , std::move(__y) , typename __make_tuple_indices::type{} ) ); @@ -533,22 +533,22 @@ template void construct(pair<_T1, _T2>* __p, _Up&& __x, _Vp&& __y) { construct(__p, piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x)), - _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__y))); + std::forward_as_tuple(std::forward<_Up>(__x)), + std::forward_as_tuple(std::forward<_Vp>(__y))); } template void construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x) { construct(__p, piecewise_construct, - _VSTD::forward_as_tuple(__x.first), - _VSTD::forward_as_tuple(__x.second)); + std::forward_as_tuple(__x.first), + std::forward_as_tuple(__x.second)); } template void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) { construct(__p, piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)), - _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second))); + std::forward_as_tuple(std::forward<_Up>(__x.first)), + std::forward_as_tuple(std::forward<_Vp>(__x.second))); } template @@ -574,7 +574,7 @@ _LIBCPP_INLINE_VISIBILITY scoped_allocator_adaptor(_OuterA2&& __o, const inner_allocator_type& __i) _NOEXCEPT - : base(_VSTD::forward<_OuterA2>(__o), __i) {} + : base(std::forward<_OuterA2>(__o), __i) {} template _LIBCPP_INLINE_VISIBILITY @@ -585,7 +585,7 @@ ( _OM()(outer_allocator()), __p, - _VSTD::forward<_Args>(__args)... + std::forward<_Args>(__args)... ); } @@ -598,7 +598,7 @@ ( _OM()(outer_allocator()), __p, allocator_arg, inner_allocator(), - _VSTD::forward<_Args>(__args)... + std::forward<_Args>(__args)... ); } @@ -611,7 +611,7 @@ ( _OM()(outer_allocator()), __p, - _VSTD::forward<_Args>(__args)..., + std::forward<_Args>(__args)..., inner_allocator() ); } @@ -622,7 +622,7 @@ __transform_tuple(integral_constant, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) { - return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); + return std::forward_as_tuple(std::get<_Idx>(std::move(__t))...); } template @@ -633,7 +633,7 @@ { using _Tup = tuple; return _Tup(allocator_arg, inner_allocator(), - _VSTD::get<_Idx>(_VSTD::move(__t))...); + std::get<_Idx>(std::move(__t))...); } template @@ -643,7 +643,7 @@ __tuple_indices<_Idx...>) { using _Tup = tuple<_Args&&..., inner_allocator_type&>; - return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator()); + return _Tup(std::get<_Idx>(std::move(__t))..., inner_allocator()); } template friend class __scoped_allocator_storage; Index: include/set =================================================================== --- include/set +++ include/set @@ -463,8 +463,8 @@ typedef typename __base::difference_type difference_type; typedef typename __base::const_iterator iterator; typedef typename __base::const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; #if _LIBCPP_STD_VER > 14 typedef __set_node_handle node_type; @@ -537,7 +537,7 @@ _LIBCPP_INLINE_VISIBILITY set(set&& __s) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value) - : __tree_(_VSTD::move(__s.__tree_)) {} + : __tree_(std::move(__s.__tree_)) {} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -586,7 +586,7 @@ set& operator=(set&& __s) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) { - __tree_ = _VSTD::move(__s.__tree_); + __tree_ = std::move(__s.__tree_); return *this; } #endif // _LIBCPP_CXX03_LANG @@ -634,11 +634,11 @@ template _LIBCPP_INLINE_VISIBILITY pair emplace(_Args&&... __args) - {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);} + {return __tree_.__emplace_unique(std::forward<_Args>(__args)...);} template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&&... __args) - {return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);} + {return __tree_.__emplace_hint_unique(__p, std::forward<_Args>(__args)...);} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -659,11 +659,11 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY pair insert(value_type&& __v) - {return __tree_.__insert_unique(_VSTD::move(__v));} + {return __tree_.__insert_unique(std::move(__v));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __v) - {return __tree_.__insert_unique(__p, _VSTD::move(__v));} + {return __tree_.__insert_unique(__p, std::move(__v));} _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) @@ -688,7 +688,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to set::insert()"); return __tree_.template __node_handle_insert_unique< - node_type, insert_return_type>(_VSTD::move(__nh)); + node_type, insert_return_type>(std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -696,7 +696,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to set::insert()"); return __tree_.template __node_handle_insert_unique( - __hint, _VSTD::move(__nh)); + __hint, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -835,13 +835,13 @@ template set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a) - : __tree_(_VSTD::move(__s.__tree_), __a) + : __tree_(std::move(__s.__tree_), __a) { if (__a != __s.get_allocator()) { const_iterator __e = cend(); while (!__s.empty()) - insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_)); + insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_)); } } @@ -853,7 +853,7 @@ operator==(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) { - return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -862,7 +862,7 @@ operator< (const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template @@ -944,8 +944,8 @@ typedef typename __base::difference_type difference_type; typedef typename __base::const_iterator iterator; typedef typename __base::const_iterator const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; #if _LIBCPP_STD_VER > 14 typedef __set_node_handle node_type; @@ -1019,7 +1019,7 @@ _LIBCPP_INLINE_VISIBILITY multiset(multiset&& __s) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value) - : __tree_(_VSTD::move(__s.__tree_)) {} + : __tree_(std::move(__s.__tree_)) {} multiset(multiset&& __s, const allocator_type& __a); #endif // _LIBCPP_CXX03_LANG @@ -1066,7 +1066,7 @@ multiset& operator=(multiset&& __s) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) { - __tree_ = _VSTD::move(__s.__tree_); + __tree_ = std::move(__s.__tree_); return *this; } #endif // _LIBCPP_CXX03_LANG @@ -1114,11 +1114,11 @@ template _LIBCPP_INLINE_VISIBILITY iterator emplace(_Args&&... __args) - {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);} + {return __tree_.__emplace_multi(std::forward<_Args>(__args)...);} template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&&... __args) - {return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);} + {return __tree_.__emplace_hint_multi(__p, std::forward<_Args>(__args)...);} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -1139,11 +1139,11 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY iterator insert(value_type&& __v) - {return __tree_.__insert_multi(_VSTD::move(__v));} + {return __tree_.__insert_multi(std::move(__v));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __v) - {return __tree_.__insert_multi(__p, _VSTD::move(__v));} + {return __tree_.__insert_multi(__p, std::move(__v));} _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) @@ -1167,7 +1167,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to multiset::insert()"); return __tree_.template __node_handle_insert_multi( - _VSTD::move(__nh)); + std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1175,7 +1175,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to multiset::insert()"); return __tree_.template __node_handle_insert_multi( - __hint, _VSTD::move(__nh)); + __hint, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -1241,11 +1241,11 @@ #if _LIBCPP_STD_VER > 11 template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type + typename std::enable_if::value,iterator>::type find(const _K2& __k) {return __tree_.find(__k);} template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type + typename std::enable_if::value,const_iterator>::type find(const _K2& __k) const {return __tree_.find(__k);} #endif @@ -1268,12 +1268,12 @@ #if _LIBCPP_STD_VER > 11 template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type + typename std::enable_if::value,iterator>::type lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);} template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type + typename std::enable_if::value,const_iterator>::type lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);} #endif @@ -1286,11 +1286,11 @@ #if _LIBCPP_STD_VER > 11 template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type + typename std::enable_if::value,iterator>::type upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);} template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type + typename std::enable_if::value,const_iterator>::type upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);} #endif @@ -1303,11 +1303,11 @@ #if _LIBCPP_STD_VER > 11 template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair>::type + typename std::enable_if::value,pair>::type equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);} template _LIBCPP_INLINE_VISIBILITY - typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair>::type + typename std::enable_if::value,pair>::type equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);} #endif }; @@ -1316,13 +1316,13 @@ template multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a) - : __tree_(_VSTD::move(__s.__tree_), __a) + : __tree_(std::move(__s.__tree_), __a) { if (__a != __s.get_allocator()) { const_iterator __e = cend(); while (!__s.empty()) - insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_)); + insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_)); } } @@ -1334,7 +1334,7 @@ operator==(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) { - return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin()); + return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -1343,7 +1343,7 @@ operator< (const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template Index: include/shared_mutex =================================================================== --- include/shared_mutex +++ include/shared_mutex @@ -325,25 +325,25 @@ _LIBCPP_INLINE_VISIBILITY explicit shared_lock(mutex_type& __m) - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(true) {__m_->lock_shared();} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(false) {} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, try_to_lock_t) - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared()) {} _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, adopt_lock_t) - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(true) {} @@ -351,7 +351,7 @@ _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __abs_time) - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared_until(__abs_time)) {} @@ -359,7 +359,7 @@ _LIBCPP_INLINE_VISIBILITY shared_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __rel_time) - : __m_(_VSTD::addressof(__m)), + : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared_for(__rel_time)) {} @@ -408,8 +408,8 @@ _LIBCPP_INLINE_VISIBILITY void swap(shared_lock& __u) _NOEXCEPT { - _VSTD::swap(__m_, __u.__m_); - _VSTD::swap(__owns_, __u.__owns_); + std::swap(__m_, __u.__m_); + std::swap(__owns_, __u.__owns_); } _LIBCPP_INLINE_VISIBILITY Index: include/span =================================================================== --- include/span +++ include/span @@ -201,8 +201,8 @@ using const_reference = const _Tp &; // not in standard using iterator = __wrap_iter; using const_iterator = __wrap_iter; - using reverse_iterator = _VSTD::reverse_iterator; - using const_reverse_iterator = _VSTD::reverse_iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; static constexpr index_type extent = _Extent; static_assert (_Extent >= 0, "Can't have a span with an extent < 0"); @@ -227,15 +227,15 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr span( _Container& __c, enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr) - : __data{_VSTD::data(__c)} - { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (container)"); } + : __data{std::data(__c)} + { _LIBCPP_ASSERT(_Extent == std::size(__c), "size mismatch in span's constructor (container)"); } template inline _LIBCPP_INLINE_VISIBILITY constexpr span(const _Container& __c, enable_if_t<__is_span_compatible_container::value, nullptr_t> = nullptr) - : __data{_VSTD::data(__c)} - { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (const container)"); } + : __data{std::data(__c)} + { _LIBCPP_ASSERT(_Extent == std::size(__c), "size mismatch in span's constructor (const container)"); } template inline _LIBCPP_INLINE_VISIBILITY @@ -373,8 +373,8 @@ using const_reference = const _Tp &; // not in standard using iterator = __wrap_iter; using const_iterator = __wrap_iter; - using reverse_iterator = _VSTD::reverse_iterator; - using const_reverse_iterator = _VSTD::reverse_iterator; + using reverse_iterator = std::reverse_iterator; + using const_reverse_iterator = std::reverse_iterator; static constexpr index_type extent = dynamic_extent; @@ -403,13 +403,13 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr span( _Container& __c, enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr) - : __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {} + : __data{std::data(__c)}, __size{(index_type) std::size(__c)} {} template inline _LIBCPP_INLINE_VISIBILITY constexpr span(const _Container& __c, enable_if_t<__is_span_compatible_container::value, nullptr_t> = nullptr) - : __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {} + : __data{std::data(__c)}, __size{(index_type) std::size(__c)} {} template Index: include/sstream =================================================================== --- include/sstream +++ include/sstream @@ -281,7 +281,7 @@ __eout = __rhs.epptr() - __p; } ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p; - __str_ = _VSTD::move(__rhs.__str_); + __str_ = std::move(__rhs.__str_); __p = const_cast(__str_.data()); if (__binp != -1) this->setg(__p + __binp, __p + __ninp, __p + __einp); @@ -322,7 +322,7 @@ __eout = __rhs.epptr() - __p; } ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p; - __str_ = _VSTD::move(__rhs.__str_); + __str_ = std::move(__rhs.__str_); __p = const_cast(__str_.data()); if (__binp != -1) this->setg(__p + __binp, __p + __ninp, __p + __einp); @@ -392,7 +392,7 @@ __leout = this->epptr() - __p; } ptrdiff_t __lhm = __hm_ == nullptr ? -1 : __hm_ - __p; - _VSTD::swap(__mode_, __rhs.__mode_); + std::swap(__mode_, __rhs.__mode_); __str_.swap(__rhs.__str_); __p = const_cast(__str_.data()); if (__rbinp != -1) @@ -553,7 +553,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS } - __hm_ = _VSTD::max(this->pptr() + 1, __hm_); + __hm_ = std::max(this->pptr() + 1, __hm_); if (__mode_ & ios_base::in) { char_type* __p = const_cast(__str_.data()); @@ -688,8 +688,8 @@ template basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(basic_istringstream&& __rhs) - : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_istream<_CharT, _Traits>(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_); } @@ -698,8 +698,8 @@ basic_istringstream<_CharT, _Traits, _Allocator>& basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&& __rhs) { - basic_istream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_istream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } @@ -805,8 +805,8 @@ template basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(basic_ostringstream&& __rhs) - : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_ostream<_CharT, _Traits>(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_); } @@ -815,8 +815,8 @@ basic_ostringstream<_CharT, _Traits, _Allocator>& basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&& __rhs) { - basic_ostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_ostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } @@ -924,8 +924,8 @@ template basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(basic_stringstream&& __rhs) - : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : basic_iostream<_CharT, _Traits>(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_); } @@ -934,8 +934,8 @@ basic_stringstream<_CharT, _Traits, _Allocator>& basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&& __rhs) { - basic_iostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + basic_iostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } Index: include/stack =================================================================== --- include/stack +++ include/stack @@ -140,15 +140,15 @@ _LIBCPP_INLINE_VISIBILITY stack(stack&& __q) _NOEXCEPT_(is_nothrow_move_constructible::value) - : c(_VSTD::move(__q.c)) {} + : c(std::move(__q.c)) {} _LIBCPP_INLINE_VISIBILITY stack& operator=(stack&& __q) _NOEXCEPT_(is_nothrow_move_assignable::value) - {c = _VSTD::move(__q.c); return *this;} + {c = std::move(__q.c); return *this;} _LIBCPP_INLINE_VISIBILITY - explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {} + explicit stack(container_type&& __c) : c(std::move(__c)) {} #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -178,13 +178,13 @@ stack(container_type&& __c, const _Alloc& __a, typename enable_if::value>::type* = 0) - : c(_VSTD::move(__c), __a) {} + : c(std::move(__c), __a) {} template _LIBCPP_INLINE_VISIBILITY stack(stack&& __s, const _Alloc& __a, typename enable_if::value>::type* = 0) - : c(_VSTD::move(__s.c), __a) {} + : c(std::move(__s.c), __a) {} #endif // _LIBCPP_CXX03_LANG _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY @@ -200,16 +200,16 @@ void push(const value_type& __v) {c.push_back(__v);} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY - void push(value_type&& __v) {c.push_back(_VSTD::move(__v));} + void push(value_type&& __v) {c.push_back(std::move(__v));} template _LIBCPP_INLINE_VISIBILITY #if _LIBCPP_STD_VER > 14 decltype(auto) emplace(_Args&&... __args) - { return c.emplace_back(_VSTD::forward<_Args>(__args)...);} + { return c.emplace_back(std::forward<_Args>(__args)...);} #else void emplace(_Args&&... __args) - { c.emplace_back(_VSTD::forward<_Args>(__args)...);} + { c.emplace_back(std::forward<_Args>(__args)...);} #endif #endif // _LIBCPP_CXX03_LANG @@ -220,7 +220,7 @@ void swap(stack& __s) _NOEXCEPT_(__is_nothrow_swappable::value) { - using _VSTD::swap; + using std::swap; swap(c, __s.c); } Index: include/stdexcept =================================================================== --- include/stdexcept +++ include/stdexcept @@ -78,7 +78,7 @@ : public exception { private: - _VSTD::__libcpp_refstring __imp_; + std::__libcpp_refstring __imp_; public: explicit logic_error(const string&); explicit logic_error(const char*); @@ -95,7 +95,7 @@ : public exception { private: - _VSTD::__libcpp_refstring __imp_; + std::__libcpp_refstring __imp_; public: explicit runtime_error(const string&); explicit runtime_error(const char*); @@ -192,7 +192,7 @@ throw logic_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -203,7 +203,7 @@ throw domain_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -214,7 +214,7 @@ throw invalid_argument(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -225,7 +225,7 @@ throw length_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -236,7 +236,7 @@ throw out_of_range(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -247,7 +247,7 @@ throw range_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -258,7 +258,7 @@ throw overflow_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } @@ -269,7 +269,7 @@ throw underflow_error(__msg); #else ((void)__msg); - _VSTD::abort(); + std::abort(); #endif } Index: include/streambuf =================================================================== --- include/streambuf +++ include/streambuf @@ -348,13 +348,13 @@ void basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb) { - _VSTD::swap(__loc_, __sb.__loc_); - _VSTD::swap(__binp_, __sb.__binp_); - _VSTD::swap(__ninp_, __sb.__ninp_); - _VSTD::swap(__einp_, __sb.__einp_); - _VSTD::swap(__bout_, __sb.__bout_); - _VSTD::swap(__nout_, __sb.__nout_); - _VSTD::swap(__eout_, __sb.__eout_); + std::swap(__loc_, __sb.__loc_); + std::swap(__binp_, __sb.__binp_); + std::swap(__ninp_, __sb.__ninp_); + std::swap(__einp_, __sb.__einp_); + std::swap(__bout_, __sb.__bout_); + std::swap(__nout_, __sb.__nout_); + std::swap(__eout_, __sb.__eout_); } template @@ -410,8 +410,8 @@ { if (__ninp_ < __einp_) { - const streamsize __len = _VSTD::min(static_cast(INT_MAX), - _VSTD::min(__einp_ - __ninp_, __n - __i)); + const streamsize __len = std::min(static_cast(INT_MAX), + std::min(__einp_ - __ninp_, __n - __i)); traits_type::copy(__s, __ninp_, __len); __s += __len; __i += __len; @@ -469,7 +469,7 @@ } else { - streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i); + streamsize __chunk_size = std::min(__eout_ - __nout_, __n - __i); traits_type::copy(__nout_, __s, __chunk_size); __nout_ += __chunk_size; __s += __chunk_size; Index: include/string =================================================================== --- include/string +++ include/string @@ -602,14 +602,14 @@ void __basic_string_common<__b>::__throw_length_error() const { - _VSTD::__throw_length_error("basic_string"); + std::__throw_length_error("basic_string"); } template void __basic_string_common<__b>::__throw_out_of_range() const { - _VSTD::__throw_out_of_range("basic_string"); + std::__throw_out_of_range("basic_string"); } _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common) @@ -691,8 +691,8 @@ typedef __wrap_iter iterator; typedef __wrap_iter const_iterator; #endif // defined(_LIBCPP_RAW_ITERATORS) - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; private: @@ -1075,7 +1075,7 @@ _LIBCPP_INLINE_VISIBILITY basic_string& assign(basic_string&& __str) _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) - {*this = _VSTD::move(__str); return *this;} + {*this = std::move(__str); return *this;} #endif basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos); template @@ -1241,10 +1241,10 @@ _LIBCPP_INLINE_VISIBILITY const value_type* c_str() const _NOEXCEPT {return data();} _LIBCPP_INLINE_VISIBILITY - const value_type* data() const _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());} + const value_type* data() const _NOEXCEPT {return std::__to_raw_pointer(__get_pointer());} #if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY) _LIBCPP_INLINE_VISIBILITY - value_type* data() _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());} + value_type* data() _NOEXCEPT {return std::__to_raw_pointer(__get_pointer());} #endif _LIBCPP_INLINE_VISIBILITY @@ -1594,7 +1594,7 @@ allocator_type __a = __str.__alloc(); pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap()); __clear_and_shrink(); - __alloc() = _VSTD::move(__a); + __alloc() = std::move(__a); __set_long_pointer(__p); __set_long_cap(__str.__get_long_cap()); __set_long_size(__str.size()); @@ -1632,7 +1632,7 @@ void __move_assign_alloc(basic_string& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable::value) { - __alloc() = _VSTD::move(__c.__alloc()); + __alloc() = std::move(__c.__alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -1767,7 +1767,7 @@ __set_long_cap(__cap+1); __set_long_size(__sz); } - traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz); + traits_type::copy(std::__to_raw_pointer(__p), __s, __sz); traits_type::assign(__p[__sz], value_type()); } @@ -1791,7 +1791,7 @@ __set_long_cap(__cap+1); __set_long_size(__sz); } - traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz); + traits_type::copy(std::__to_raw_pointer(__p), __s, __sz); traits_type::assign(__p[__sz], value_type()); } @@ -1839,7 +1839,7 @@ if (!__str.__is_long()) __r_.first().__r = __str.__r_.first().__r; else - __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); + __init(std::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif @@ -1853,7 +1853,7 @@ if (!__str.__is_long()) __r_.first().__r = __str.__r_.first().__r; else - __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); + __init(std::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif @@ -1869,7 +1869,7 @@ #else _NOEXCEPT #endif - : __r_(_VSTD::move(__str.__r_)) + : __r_(std::move(__str.__r_)) { __str.__zero(); #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1885,7 +1885,7 @@ : __r_(__second_tag(), __a) { if (__str.__is_long() && __a != __str.__alloc()) // copy, not move - __init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); + __init(std::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size()); else { __r_.first().__r = __str.__r_.first().__r; @@ -1920,7 +1920,7 @@ __set_long_cap(__cap+1); __set_long_size(__n); } - traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c); + traits_type::assign(std::__to_raw_pointer(__p), __n, __c); traits_type::assign(__p[__n], value_type()); } @@ -1956,7 +1956,7 @@ size_type __str_sz = __str.size(); if (__pos > __str_sz) this->__throw_out_of_range(); - __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos)); + __init(__str.data() + __pos, std::min(__n, __str_sz - __pos)); #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif @@ -2050,7 +2050,7 @@ >::type basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) { - size_type __sz = static_cast(_VSTD::distance(__first, __last)); + size_type __sz = static_cast(std::distance(__first, __last)); if (__sz > max_size()) this->__throw_length_error(); pointer __p; @@ -2145,19 +2145,19 @@ this->__throw_length_error(); pointer __old_p = __get_pointer(); size_type __cap = __old_cap < __ms / 2 - __alignment ? - __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : + __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1; pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); __invalidate_all_iterators(); if (__n_copy != 0) - traits_type::copy(_VSTD::__to_raw_pointer(__p), - _VSTD::__to_raw_pointer(__old_p), __n_copy); + traits_type::copy(std::__to_raw_pointer(__p), + std::__to_raw_pointer(__old_p), __n_copy); if (__n_add != 0) - traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add); + traits_type::copy(std::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add); size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; if (__sec_cp_sz != 0) - traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add, - _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz); + traits_type::copy(std::__to_raw_pointer(__p) + __n_copy + __n_add, + std::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz); if (__old_cap+1 != __min_cap) __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); __set_long_pointer(__p); @@ -2177,17 +2177,17 @@ this->__throw_length_error(); pointer __old_p = __get_pointer(); size_type __cap = __old_cap < __ms / 2 - __alignment ? - __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) : + __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1; pointer __p = __alloc_traits::allocate(__alloc(), __cap+1); __invalidate_all_iterators(); if (__n_copy != 0) - traits_type::copy(_VSTD::__to_raw_pointer(__p), - _VSTD::__to_raw_pointer(__old_p), __n_copy); + traits_type::copy(std::__to_raw_pointer(__p), + std::__to_raw_pointer(__old_p), __n_copy); size_type __sec_cp_sz = __old_sz - __n_del - __n_copy; if (__sec_cp_sz != 0) - traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add, - _VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, + traits_type::copy(std::__to_raw_pointer(__p) + __n_copy + __n_add, + std::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz); if (__old_cap+1 != __min_cap) __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1); @@ -2205,7 +2205,7 @@ size_type __cap = capacity(); if (__cap >= __n) { - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); + value_type* __p = std::__to_raw_pointer(__get_pointer()); traits_type::move(__p, __s, __n); traits_type::assign(__p[__n], value_type()); __set_size(__n); @@ -2231,7 +2231,7 @@ } else __invalidate_iterators_past(__n); - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); + value_type* __p = std::__to_raw_pointer(__get_pointer()); traits_type::assign(__p, __n, __c); traits_type::assign(__p[__n], value_type()); __set_size(__n); @@ -2339,7 +2339,7 @@ >::type basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) { - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); size_type __cap = capacity(); if (__cap < __n) { @@ -2363,7 +2363,7 @@ size_type __sz = __str.size(); if (__pos > __sz) this->__throw_out_of_range(); - return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); + return assign(__str.data() + __pos, std::min(__n, __sz - __pos)); } template @@ -2379,7 +2379,7 @@ size_type __sz = __sv.size(); if (__pos > __sz) this->__throw_out_of_range(); - return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); + return assign(__sv.data() + __pos, std::min(__n, __sz - __pos)); } @@ -2404,7 +2404,7 @@ { if (__n) { - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); + value_type* __p = std::__to_raw_pointer(__get_pointer()); traits_type::copy(__p + __sz, __s, __n); __sz += __n; __set_size(__sz); @@ -2427,7 +2427,7 @@ if (__cap - __sz < __n) __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0); pointer __p = __get_pointer(); - traits_type::assign(_VSTD::__to_raw_pointer(__p) + __sz, __n, __c); + traits_type::assign(std::__to_raw_pointer(__p) + __sz, __n, __c); __sz += __n; __set_size(__sz); traits_type::assign(__p[__sz], value_type()); @@ -2511,12 +2511,12 @@ "function requires a ForwardIterator"); size_type __sz = size(); size_type __cap = capacity(); - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n) { typedef typename iterator_traits<_ForwardIterator>::reference _CharRef; _CharRef __tmp_ref = *__first; - if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size())) + if (__ptr_in_range(std::addressof(__tmp_ref), data(), data() + size())) { const basic_string __temp (__first, __last, __alloc()); append(__temp.data(), __temp.size()); @@ -2550,7 +2550,7 @@ size_type __sz = __str.size(); if (__pos > __sz) this->__throw_out_of_range(); - return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos)); + return append(__str.data() + __pos, std::min(__n, __sz - __pos)); } template @@ -2566,7 +2566,7 @@ size_type __sz = __sv.size(); if (__pos > __sz) this->__throw_out_of_range(); - return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos)); + return append(__sv.data() + __pos, std::min(__n, __sz - __pos)); } template @@ -2592,7 +2592,7 @@ { if (__n) { - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); + value_type* __p = std::__to_raw_pointer(__get_pointer()); size_type __n_move = __sz - __pos; if (__n_move != 0) { @@ -2624,7 +2624,7 @@ value_type* __p; if (__cap - __sz >= __n) { - __p = _VSTD::__to_raw_pointer(__get_pointer()); + __p = std::__to_raw_pointer(__get_pointer()); size_type __n_move = __sz - __pos; if (__n_move != 0) traits_type::move(__p + __pos + __n, __p + __pos, __n_move); @@ -2632,7 +2632,7 @@ else { __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n); - __p = _VSTD::__to_raw_pointer(__get_long_pointer()); + __p = std::__to_raw_pointer(__get_long_pointer()); } traits_type::assign(__p + __pos, __n, __c); __sz += __n; @@ -2677,12 +2677,12 @@ " referring to this string"); #endif size_type __ip = static_cast(__pos - begin()); - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n) { typedef typename iterator_traits<_ForwardIterator>::reference _CharRef; _CharRef __tmp_char = *__first; - if (__ptr_in_range(_VSTD::addressof(__tmp_char), data(), data() + size())) + if (__ptr_in_range(std::addressof(__tmp_char), data(), data() + size())) { const basic_string __temp(__first, __last, __alloc()); return insert(__pos, __temp.data(), __temp.data() + __temp.size()); @@ -2693,7 +2693,7 @@ value_type* __p; if (__cap - __sz >= __n) { - __p = _VSTD::__to_raw_pointer(__get_pointer()); + __p = std::__to_raw_pointer(__get_pointer()); size_type __n_move = __sz - __ip; if (__n_move != 0) traits_type::move(__p + __ip + __n, __p + __ip, __n_move); @@ -2701,7 +2701,7 @@ else { __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n); - __p = _VSTD::__to_raw_pointer(__get_long_pointer()); + __p = std::__to_raw_pointer(__get_long_pointer()); } __sz += __n; __set_size(__sz); @@ -2728,7 +2728,7 @@ size_type __str_sz = __str.size(); if (__pos2 > __str_sz) this->__throw_out_of_range(); - return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); + return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2)); } template @@ -2745,7 +2745,7 @@ size_type __str_sz = __sv.size(); if (__pos2 > __str_sz) this->__throw_out_of_range(); - return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2)); + return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2)); } template @@ -2767,11 +2767,11 @@ if (__cap == __sz) { __grow_by(__cap, 1, __sz, __ip, 0, 1); - __p = _VSTD::__to_raw_pointer(__get_long_pointer()); + __p = std::__to_raw_pointer(__get_long_pointer()); } else { - __p = _VSTD::__to_raw_pointer(__get_pointer()); + __p = std::__to_raw_pointer(__get_pointer()); size_type __n_move = __sz - __ip; if (__n_move != 0) traits_type::move(__p + __ip + 1, __p + __ip, __n_move); @@ -2808,11 +2808,11 @@ size_type __sz = size(); if (__pos > __sz) this->__throw_out_of_range(); - __n1 = _VSTD::min(__n1, __sz - __pos); + __n1 = std::min(__n1, __sz - __pos); size_type __cap = capacity(); if (__cap - __sz + __n1 >= __n2) { - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); + value_type* __p = std::__to_raw_pointer(__get_pointer()); if (__n1 != __n2) { size_type __n_move = __sz - __pos - __n1; @@ -2862,12 +2862,12 @@ size_type __sz = size(); if (__pos > __sz) this->__throw_out_of_range(); - __n1 = _VSTD::min(__n1, __sz - __pos); + __n1 = std::min(__n1, __sz - __pos); size_type __cap = capacity(); value_type* __p; if (__cap - __sz + __n1 >= __n2) { - __p = _VSTD::__to_raw_pointer(__get_pointer()); + __p = std::__to_raw_pointer(__get_pointer()); if (__n1 != __n2) { size_type __n_move = __sz - __pos - __n1; @@ -2878,7 +2878,7 @@ else { __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2); - __p = _VSTD::__to_raw_pointer(__get_long_pointer()); + __p = std::__to_raw_pointer(__get_long_pointer()); } traits_type::assign(__p + __pos, __n2, __c); __sz += __n2 - __n1; @@ -2918,7 +2918,7 @@ size_type __str_sz = __str.size(); if (__pos2 > __str_sz) this->__throw_out_of_range(); - return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); + return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2)); } template @@ -2935,7 +2935,7 @@ size_type __str_sz = __sv.size(); if (__pos2 > __str_sz) this->__throw_out_of_range(); - return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2)); + return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2)); } template @@ -2990,8 +2990,8 @@ this->__throw_out_of_range(); if (__n) { - value_type* __p = _VSTD::__to_raw_pointer(__get_pointer()); - __n = _VSTD::min(__n, __sz - __pos); + value_type* __p = std::__to_raw_pointer(__get_pointer()); + __n = std::min(__n, __sz - __pos); size_type __n_move = __sz - __pos - __n; if (__n_move != 0) traits_type::move(__p + __pos, __p + __pos + __n, __n_move); @@ -3139,7 +3139,7 @@ this->__throw_length_error(); size_type __cap = capacity(); size_type __sz = size(); - __res_arg = _VSTD::max(__res_arg, __sz); + __res_arg = std::max(__res_arg, __sz); __res_arg = __recommend(__res_arg); if (__res_arg != __cap) { @@ -3178,8 +3178,8 @@ __was_long = __is_long(); __p = __get_pointer(); } - traits_type::copy(_VSTD::__to_raw_pointer(__new_data), - _VSTD::__to_raw_pointer(__p), size()+1); + traits_type::copy(std::__to_raw_pointer(__new_data), + std::__to_raw_pointer(__p), size()+1); if (__was_long) __alloc_traits::deallocate(__alloc(), __p, __cap+1); if (__now_long) @@ -3273,7 +3273,7 @@ size_type __sz = size(); if (__pos > __sz) this->__throw_out_of_range(); - size_type __rlen = _VSTD::min(__n, __sz - __pos); + size_type __rlen = std::min(__n, __sz - __pos); traits_type::copy(__s, data() + __pos, __rlen); return __rlen; } @@ -3308,7 +3308,7 @@ __alloc_traits::propagate_on_container_swap::value || __alloc_traits::is_always_equal::value || __alloc() == __str.__alloc(), "swapping non-equal allocators"); - _VSTD::swap(__r_.first(), __str.__r_.first()); + std::swap(__r_.first(), __str.__r_.first()); __swap_allocator(__alloc(), __str.__alloc()); } @@ -3686,7 +3686,7 @@ size_t __lhs_sz = size(); size_t __rhs_sz = __sv.size(); int __result = traits_type::compare(data(), __sv.data(), - _VSTD::min(__lhs_sz, __rhs_sz)); + std::min(__lhs_sz, __rhs_sz)); if (__result != 0) return __result; if (__lhs_sz < __rhs_sz) @@ -3715,8 +3715,8 @@ size_type __sz = size(); if (__pos1 > __sz || __n2 == npos) this->__throw_out_of_range(); - size_type __rlen = _VSTD::min(__n1, __sz - __pos1); - int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2)); + size_type __rlen = std::min(__n1, __sz - __pos1); + int __r = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2)); if (__r == 0) { if (__rlen < __n2) @@ -4103,7 +4103,7 @@ basic_string<_CharT, _Traits, _Allocator> operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) { - return _VSTD::move(__lhs.append(__rhs)); + return std::move(__lhs.append(__rhs)); } template @@ -4111,7 +4111,7 @@ basic_string<_CharT, _Traits, _Allocator> operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) { - return _VSTD::move(__rhs.insert(0, __lhs)); + return std::move(__rhs.insert(0, __lhs)); } template @@ -4119,7 +4119,7 @@ basic_string<_CharT, _Traits, _Allocator> operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) { - return _VSTD::move(__lhs.append(__rhs)); + return std::move(__lhs.append(__rhs)); } template @@ -4127,7 +4127,7 @@ basic_string<_CharT, _Traits, _Allocator> operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs) { - return _VSTD::move(__rhs.insert(0, __lhs)); + return std::move(__rhs.insert(0, __lhs)); } template @@ -4136,7 +4136,7 @@ operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs) { __rhs.insert(__rhs.begin(), __lhs); - return _VSTD::move(__rhs); + return std::move(__rhs); } template @@ -4144,7 +4144,7 @@ basic_string<_CharT, _Traits, _Allocator> operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) { - return _VSTD::move(__lhs.append(__rhs)); + return std::move(__lhs.append(__rhs)); } template @@ -4153,7 +4153,7 @@ operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) { __lhs.push_back(__rhs); - return _VSTD::move(__lhs); + return std::move(__lhs); } #endif // _LIBCPP_CXX03_LANG @@ -4280,23 +4280,23 @@ bool basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const { - return this->data() <= _VSTD::__to_raw_pointer(__i->base()) && - _VSTD::__to_raw_pointer(__i->base()) < this->data() + this->size(); + return this->data() <= std::__to_raw_pointer(__i->base()) && + std::__to_raw_pointer(__i->base()) < this->data() + this->size(); } template bool basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const { - return this->data() < _VSTD::__to_raw_pointer(__i->base()) && - _VSTD::__to_raw_pointer(__i->base()) <= this->data() + this->size(); + return this->data() < std::__to_raw_pointer(__i->base()) && + std::__to_raw_pointer(__i->base()) <= this->data() + this->size(); } template bool basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const { - const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n; + const value_type* __p = std::__to_raw_pointer(__i->base()) + __n; return this->data() <= __p && __p <= this->data() + this->size(); } @@ -4304,7 +4304,7 @@ bool basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const { - const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n; + const value_type* __p = std::__to_raw_pointer(__i->base()) + __n; return this->data() <= __p && __p < this->data() + this->size(); } Index: include/string_view =================================================================== --- include/string_view +++ include/string_view @@ -203,7 +203,7 @@ typedef const _CharT& const_reference; typedef const_pointer const_iterator; // See [string.view.iterators] typedef const_iterator iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; typedef const_reverse_iterator reverse_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; @@ -336,7 +336,7 @@ { if (__pos > size()) __throw_out_of_range("string_view::copy"); - size_type __rlen = _VSTD::min(__n, size() - __pos); + size_type __rlen = std::min(__n, size() - __pos); _Traits::copy(__s, data() + __pos, __rlen); return __rlen; } @@ -346,12 +346,12 @@ { return __pos > size() ? (__throw_out_of_range("string_view::substr"), basic_string_view()) - : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos)); + : basic_string_view(data() + __pos, std::min(__n, size() - __pos)); } _LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT { - size_type __rlen = _VSTD::min( size(), __sv.size()); + size_type __rlen = std::min( size(), __sv.size()); int __retval = _Traits::compare(data(), __sv.data(), __rlen); if ( __retval == 0 ) // first __rlen chars matched __retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 ); Index: include/strstream =================================================================== --- include/strstream +++ include/strstream @@ -248,8 +248,8 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY istrstream(istrstream&& __rhs) - : istream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : istream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { istream::set_rdbuf(&__sb_); } @@ -257,8 +257,8 @@ _LIBCPP_INLINE_VISIBILITY istrstream& operator=(istrstream&& __rhs) { - istream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + istream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } #endif // _LIBCPP_CXX03_LANG @@ -297,8 +297,8 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY ostrstream(ostrstream&& __rhs) - : ostream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : ostream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { ostream::set_rdbuf(&__sb_); } @@ -306,8 +306,8 @@ _LIBCPP_INLINE_VISIBILITY ostrstream& operator=(ostrstream&& __rhs) { - ostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + ostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } #endif // _LIBCPP_CXX03_LANG @@ -357,8 +357,8 @@ #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY strstream(strstream&& __rhs) - : iostream(_VSTD::move(__rhs)), - __sb_(_VSTD::move(__rhs.__sb_)) + : iostream(std::move(__rhs)), + __sb_(std::move(__rhs.__sb_)) { iostream::set_rdbuf(&__sb_); } @@ -366,8 +366,8 @@ _LIBCPP_INLINE_VISIBILITY strstream& operator=(strstream&& __rhs) { - iostream::operator=(_VSTD::move(__rhs)); - __sb_ = _VSTD::move(__rhs.__sb_); + iostream::operator=(std::move(__rhs)); + __sb_ = std::move(__rhs.__sb_); return *this; } #endif // _LIBCPP_CXX03_LANG Index: include/thread =================================================================== --- include/thread +++ include/thread @@ -318,7 +318,7 @@ #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY - void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);} + void swap(thread& __t) _NOEXCEPT {std::swap(__t_, __t.__t_);} _LIBCPP_INLINE_VISIBILITY bool joinable() const _NOEXCEPT {return !__libcpp_thread_isnull(&__t_);} @@ -339,7 +339,7 @@ void __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>) { - __invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...); + __invoke(std::move(std::get<1>(__t)), std::move(std::get<_Indices>(__t))...); } template @@ -347,7 +347,7 @@ { // _Fp = std::tuple< unique_ptr<__thread_struct>, Functor, Args...> std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp)); - __thread_local_data().set_pointer(_VSTD::get<0>(*__p).release()); + __thread_local_data().set_pointer(std::get<0>(*__p).release()); typedef typename __make_tuple_indices::value, 2>::type _Index; __thread_execute(*__p, _Index()); return nullptr; @@ -361,10 +361,10 @@ typedef unique_ptr<__thread_struct> _TSPtr; _TSPtr __tsp(new __thread_struct); typedef tuple<_TSPtr, typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp; - _VSTD::unique_ptr<_Gp> __p( + std::unique_ptr<_Gp> __p( new _Gp(std::move(__tsp), - __decay_copy(_VSTD::forward<_Fp>(__f)), - __decay_copy(_VSTD::forward<_Args>(__args))...)); + __decay_copy(std::forward<_Fp>(__f)), + __decay_copy(std::forward<_Args>(__args))...)); int __ec = __libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get()); if (__ec == 0) __p.release(); Index: include/tuple =================================================================== --- include/tuple +++ include/tuple @@ -219,28 +219,28 @@ > _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) - : __value_(_VSTD::forward<_Tp>(__t)) + : __value_(std::forward<_Tp>(__t)) {static_assert(__can_bind_reference<_Tp&&>(), "Attempted construction of reference element binds to a temporary whose lifetime has ended");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc&, _Tp&& __t) - : __value_(_VSTD::forward<_Tp>(__t)) + : __value_(std::forward<_Tp>(__t)) {static_assert(__can_bind_reference<_Tp&&>(), "Attempted construction of reference element binds to a temporary whose lifetime has ended");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) - : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) + : __value_(allocator_arg_t(), __a, std::forward<_Tp>(__t)) {static_assert(!is_reference<_Hp>::value, "Attempted to uses-allocator construct a reference element in a tuple");} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) - : __value_(_VSTD::forward<_Tp>(__t), __a) + : __value_(std::forward<_Tp>(__t), __a) {static_assert(!is_reference<_Hp>::value, "Attempted to uses-allocator construct a reference element in a tuple");} @@ -252,14 +252,14 @@ __tuple_leaf& operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value)) { - __value_ = _VSTD::forward<_Tp>(__t); + __value_ = std::forward<_Tp>(__t); return *this; } _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) { - _VSTD::swap(*this, __t); + std::swap(*this, __t); return 0; } @@ -301,22 +301,22 @@ > _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value)) - : _Hp(_VSTD::forward<_Tp>(__t)) {} + : _Hp(std::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc&, _Tp&& __t) - : _Hp(_VSTD::forward<_Tp>(__t)) {} + : _Hp(std::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) - : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {} + : _Hp(allocator_arg_t(), __a, std::forward<_Tp>(__t)) {} template _LIBCPP_INLINE_VISIBILITY explicit __tuple_leaf(integral_constant, const _Alloc& __a, _Tp&& __t) - : _Hp(_VSTD::forward<_Tp>(__t), __a) {} + : _Hp(std::forward<_Tp>(__t), __a) {} __tuple_leaf(__tuple_leaf const &) = default; __tuple_leaf(__tuple_leaf &&) = default; @@ -326,7 +326,7 @@ __tuple_leaf& operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value)) { - _Hp::operator=(_VSTD::forward<_Tp>(__t)); + _Hp::operator=(std::forward<_Tp>(__t)); return *this; } @@ -334,7 +334,7 @@ int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value) { - _VSTD::swap(*this, __t); + std::swap(*this, __t); return 0; } @@ -378,7 +378,7 @@ _Up&&... __u) _NOEXCEPT_((__all::value...>::value && __all::value...>::value)) : - __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))..., + __tuple_leaf<_Uf, _Tf>(std::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>()... {} @@ -391,7 +391,7 @@ __tuple_indices<_Ul...>, __tuple_types<_Tl...>, _Up&&... __u) : __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, - _VSTD::forward<_Up>(__u))..., + std::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... {} @@ -404,8 +404,8 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all::type>::type>::value...>::value)) - : __tuple_leaf<_Indx, _Tp>(_VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))... + : __tuple_leaf<_Indx, _Tp>(std::forward::type>::type>(std::get<_Indx>(__t)))... {} template (__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(), __a, - _VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))... + std::forward::type>::type>(std::get<_Indx>(__t)))... {} template @@ -432,8 +432,8 @@ operator=(_Tuple&& __t) _NOEXCEPT_((__all::type>::type>::value...>::value)) { - __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward::type>::type>(_VSTD::get<_Indx>(__t)))...); + __swallow(__tuple_leaf<_Indx, _Tp>::operator=(std::forward::type>::type>(std::get<_Indx>(__t)))...); return *this; } @@ -452,7 +452,7 @@ __tuple_impl& operator=(__tuple_impl&& __t) _NOEXCEPT_((__all::value...>::value)) { - __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...); + __swallow(__tuple_leaf<_Indx, _Tp>::operator=(std::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...); return *this; } @@ -735,7 +735,7 @@ typename __make_tuple_types::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), - _VSTD::forward<_Up>(__u)...) {} + std::forward<_Up>(__u)...) {} template ::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), - _VSTD::forward<_Up>(__u)...) {} + std::forward<_Up>(__u)...) {} template ::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), - _VSTD::forward<_Up>(__u)...) {} + std::forward<_Up>(__u)...) {} template ::type(), typename __make_tuple_indices::type(), typename __make_tuple_types::type(), - _VSTD::forward<_Up>(__u)...) {} + std::forward<_Up>(__u)...) {} template _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value)) - : __base_(_VSTD::forward<_Tuple>(__t)) {} + : __base_(std::forward<_Tuple>(__t)) {} template ::value)) - : __base_(_VSTD::forward<_Tuple>(__t)) {} + : __base_(std::forward<_Tuple>(__t)) {} template _LIBCPP_INLINE_VISIBILITY tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t) - : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {} + : __base_(allocator_arg_t(), __a, std::forward<_Tuple>(__t)) {} template (__t)) {} + : __base_(allocator_arg_t(), __a, std::forward<_Tuple>(__t)) {} using _CanCopyAssign = __all::value...>; using _CanMoveAssign = __all::value...>; @@ -894,7 +894,7 @@ tuple& operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value)) { - __base_.operator=(_VSTD::forward<_Tuple>(__t)); + __base_.operator=(std::forward<_Tuple>(__t)); return *this; } @@ -1030,28 +1030,28 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr _T1& get(tuple<_Args...>& __tup) noexcept { - return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); + return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); } template inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept { - return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); + return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup); } template inline _LIBCPP_INLINE_VISIBILITY constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept { - return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup)); + return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup)); } template inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept { - return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup)); + return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup)); } #endif @@ -1083,7 +1083,7 @@ tuple::type...> make_tuple(_Tp&&... __t) { - return tuple::type...>(_VSTD::forward<_Tp>(__t)...); + return tuple::type...>(std::forward<_Tp>(__t)...); } template @@ -1091,7 +1091,7 @@ tuple<_Tp&&...> forward_as_tuple(_Tp&&... __t) _NOEXCEPT { - return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...); + return tuple<_Tp&&...>(std::forward<_Tp>(__t)...); } template @@ -1101,7 +1101,7 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _Tp& __x, const _Up& __y) { - return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y); + return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip-1>(__x) == std::get<_Ip-1>(__y); } }; @@ -1140,9 +1140,9 @@ bool operator()(const _Tp& __x, const _Up& __y) { const size_t __idx = tuple_size<_Tp>::value - _Ip; - if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y)) + if (std::get<__idx>(__x) < std::get<__idx>(__y)) return true; - if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x)) + if (std::get<__idx>(__y) < std::get<__idx>(__x)) return false; return __tuple_less<_Ip-1>()(__x, __y); } @@ -1293,8 +1293,8 @@ typename __tuple_cat_return_ref&&, _Tuple0&&>::type operator()(tuple<_Types...> __t, _Tuple0&& __t0) { - return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))..., - _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...); + return forward_as_tuple(std::forward<_Types>(std::get<_I0>(__t))..., + std::get<_J0>(std::forward<_Tuple0>(__t0))...); } template @@ -1309,11 +1309,11 @@ typename __make_tuple_indices::value>::type, typename __make_tuple_indices::value>::type>() (forward_as_tuple( - _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))..., - _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))... + std::forward<_Types>(std::get<_I0>(__t))..., + std::get<_J0>(std::forward<_Tuple0>(__t0))... ), - _VSTD::forward<_Tuple1>(__t1), - _VSTD::forward<_Tuples>(__tpls)...); + std::forward<_Tuple1>(__t1), + std::forward<_Tuples>(__tpls)...); } }; @@ -1325,8 +1325,8 @@ typedef typename remove_reference<_Tuple0>::type _T0; return __tuple_cat, __tuple_indices<>, typename __make_tuple_indices::value>::type>() - (tuple<>(), _VSTD::forward<_Tuple0>(__t0), - _VSTD::forward<_Tuples>(__tpls)...); + (tuple<>(), std::forward<_Tuple0>(__t0), + std::forward<_Tuples>(__tpls)...); } template @@ -1339,8 +1339,8 @@ pair<_T1, _T2>::pair(piecewise_construct_t, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, __tuple_indices<_I1...>, __tuple_indices<_I2...>) - : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...), - second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...) + : first(std::forward<_Args1>(std::get<_I1>( __first_args))...), + second(std::forward<_Args2>(std::get<_I2>(__second_args))...) { } @@ -1355,17 +1355,17 @@ constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t, __tuple_indices<_Id...>) _LIBCPP_NOEXCEPT_RETURN( - _VSTD::__invoke_constexpr( - _VSTD::forward<_Fn>(__f), - _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...) + std::__invoke_constexpr( + std::forward<_Fn>(__f), + std::get<_Id>(std::forward<_Tuple>(__t))...) ) template inline _LIBCPP_INLINE_VISIBILITY constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t) _LIBCPP_NOEXCEPT_RETURN( - _VSTD::__apply_tuple_impl( - _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t), + std::__apply_tuple_impl( + std::forward<_Fn>(__f), std::forward<_Tuple>(__t), typename __make_tuple_indices>>::type{}) ) @@ -1373,14 +1373,14 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>) _LIBCPP_NOEXCEPT_RETURN( - _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...) + _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...) ) template inline _LIBCPP_INLINE_VISIBILITY constexpr _Tp make_from_tuple(_Tuple&& __t) _LIBCPP_NOEXCEPT_RETURN( - _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t), + std::__make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), typename __make_tuple_indices>>::type{}) ) Index: include/type_traits =================================================================== --- include/type_traits +++ include/type_traits @@ -1151,7 +1151,7 @@ template _Tp __declval(long); template -decltype(_VSTD::__declval<_Tp>(0)) +decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT; #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1478,7 +1478,7 @@ template struct __is_convertible_test<_From, _To, - decltype(_VSTD::__is_convertible_imp::__test_convert<_To>(_VSTD::declval<_From>()))> : public true_type + decltype(std::__is_convertible_imp::__test_convert<_To>(std::declval<_From>()))> : public true_type {}; template ::value, @@ -2087,7 +2087,7 @@ struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, void> { typedef typename decay() : _VSTD::declval<_Up>() + true ? std::declval<_Tp>() : std::declval<_Up>() )>::type type; }; @@ -2112,11 +2112,11 @@ template struct __common_type2_imp<_Tp, _Up, typename __void_t() : _VSTD::declval<_Up>() + true ? std::declval<_Tp>() : std::declval<_Up>() )>::type> { typedef typename decay() : _VSTD::declval<_Up>() + true ? std::declval<_Tp>() : std::declval<_Up>() )>::type type; }; @@ -2173,7 +2173,7 @@ template struct __select_2nd { typedef _Tp type; }; template -typename __select_2nd() = _VSTD::declval<_Arg>())), true_type>::type +typename __select_2nd() = std::declval<_Arg>())), true_type>::type __is_assignable_test(int); template @@ -2182,7 +2182,7 @@ template ::value || is_void<_Arg>::value> struct __is_assignable_imp - : public decltype((_VSTD::__is_assignable_test<_Tp, _Arg>(0))) {}; + : public decltype((std::__is_assignable_test<_Tp, _Arg>(0))) {}; template struct __is_assignable_imp<_Tp, _Arg, true> @@ -2244,7 +2244,7 @@ struct __is_destructor_wellformed { template static char __test ( - typename __is_destructible_apply().~_Tp1())>::type + typename __is_destructible_apply().~_Tp1())>::type ); template @@ -2258,33 +2258,33 @@ template struct __destructible_imp<_Tp, false> - : public _VSTD::integral_constant::type>::value> {}; + : public std::integral_constant::type>::value> {}; template struct __destructible_imp<_Tp, true> - : public _VSTD::true_type {}; + : public std::true_type {}; template struct __destructible_false; template -struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, _VSTD::is_reference<_Tp>::value> {}; +struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, std::is_reference<_Tp>::value> {}; template -struct __destructible_false<_Tp, true> : public _VSTD::false_type {}; +struct __destructible_false<_Tp, true> : public std::false_type {}; template struct is_destructible - : public __destructible_false<_Tp, _VSTD::is_function<_Tp>::value> {}; + : public __destructible_false<_Tp, std::is_function<_Tp>::value> {}; template struct is_destructible<_Tp[]> - : public _VSTD::false_type {}; + : public std::false_type {}; template <> struct is_destructible - : public _VSTD::false_type {}; + : public std::false_type {}; #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) template @@ -2371,7 +2371,7 @@ typename decay<_Tp>::type __decay_copy(_Tp&& __t) { - return _VSTD::forward<_Tp>(__t); + return std::forward<_Tp>(__t); } #else @@ -2381,7 +2381,7 @@ typename decay<_Tp>::type __decay_copy(const _Tp& __t) { - return _VSTD::forward<_Tp>(__t); + return std::forward<_Tp>(__t); } #endif @@ -2930,7 +2930,7 @@ template struct __result_of_mdp<_Rp _Class::*, _Tp, false> { - typedef typename __apply_cv()), _Rp>::type& type; + typedef typename __apply_cv()), _Rp>::type& type; }; template @@ -3077,11 +3077,11 @@ // NOTE: The static_cast implementation below is required to support // classes with explicit conversion operators. template (_VSTD::declval<_From>()))> + class = decltype(__eat<_To>(std::declval<_From>()))> static true_type __test_cast(int); template (_VSTD::declval<_From>()))> + class = decltype(static_cast<_To>(std::declval<_From>()))> static integral_constant::value && !__is_invalid_lvalue_to_rvalue_cast<_To, _From>::value @@ -3091,12 +3091,12 @@ static false_type __test_cast(...); template ()...))> + class = decltype(_Tp(std::declval<_Args>()...))> static true_type __test_nary(int); template static false_type __test_nary(...); - template ()))> + template ()))> static is_destructible<_Tp> __test_unary(int); template static false_type __test_unary(...); @@ -3169,7 +3169,7 @@ __is_constructible0_test(__any); template -decltype((_Tp(_VSTD::declval<_A0>()), true_type())) +decltype((_Tp(std::declval<_A0>()), true_type())) __is_constructible1_test(_Tp&, _A0&); template @@ -3177,7 +3177,7 @@ __is_constructible1_test(__any, _A0&); template -decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type())) +decltype((_Tp(std::declval<_A0>(), std::declval<_A1>()), true_type())) __is_constructible2_test(_Tp&, _A0&, _A1&); template @@ -3185,7 +3185,7 @@ __is_constructible2_test(__any, _A0&, _A1&); template -decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>(), _VSTD::declval<_A2>()), true_type())) +decltype((_Tp(std::declval<_A0>(), std::declval<_A1>(), std::declval<_A2>()), true_type())) __is_constructible3_test(_Tp&, _A0&, _A1&, _A2&); template @@ -3928,7 +3928,7 @@ template struct __libcpp_is_nothrow_assignable - : public integral_constant() = _VSTD::declval<_Arg>()) > + : public integral_constant() = std::declval<_Arg>()) > { }; @@ -4031,7 +4031,7 @@ template struct __libcpp_is_nothrow_destructible - : public integral_constant().~_Tp()) > + : public integral_constant().~_Tp()) > { }; @@ -4263,42 +4263,42 @@ inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN((std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...)) template > inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN((std::forward<_A0>(__a0).*__f)(std::forward<_Args>(__args)...)) template > inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(std::forward<_Args>(__args)...)) template > inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(std::forward<_Args>(__args)...)) template > inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN(((*std::forward<_A0>(__a0)).*__f)(std::forward<_Args>(__args)...)) template > inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN(((*std::forward<_A0>(__a0)).*__f)(std::forward<_Args>(__args)...)) // bullets 4, 5 and 6 @@ -4307,14 +4307,14 @@ inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0) -_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f) +_LIBCPP_INVOKE_RETURN(std::forward<_A0>(__a0).*__f) template > inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _A0&& __a0) -_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f) +_LIBCPP_INVOKE_RETURN(std::forward<_A0>(__a0).*__f) template > @@ -4335,14 +4335,14 @@ inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _A0&& __a0) -_LIBCPP_INVOKE_RETURN((*_VSTD::forward<_A0>(__a0)).*__f) +_LIBCPP_INVOKE_RETURN((*std::forward<_A0>(__a0)).*__f) template > inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _A0&& __a0) -_LIBCPP_INVOKE_RETURN((*_VSTD::forward<_A0>(__a0)).*__f) +_LIBCPP_INVOKE_RETURN((*std::forward<_A0>(__a0)).*__f) // bullet 7 @@ -4350,13 +4350,13 @@ inline _LIBCPP_INLINE_VISIBILITY auto __invoke(_Fp&& __f, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...)) template inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR auto __invoke_constexpr(_Fp&& __f, _Args&& ...__args) -_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...)) +_LIBCPP_INVOKE_RETURN(std::forward<_Fp>(__f)(std::forward<_Args>(__args)...)) #undef _LIBCPP_INVOKE_RETURN @@ -4368,7 +4368,7 @@ // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void, // or incomplete array types as required by the standard. using _Result = decltype( - _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)); + std::__invoke(std::declval<_Fp>(), std::declval<_Args>()...)); using type = typename conditional< @@ -4400,14 +4400,14 @@ static void __test_noexcept(_Tp) noexcept; static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>( - _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...))); + std::__invoke(std::declval<_Fp>(), std::declval<_Args>()...))); }; template struct __nothrow_invokable_r_imp { static const bool value = noexcept( - _VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)); + std::__invoke(std::declval<_Fp>(), std::declval<_Args>()...)); }; template @@ -4515,9 +4515,9 @@ swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value && is_nothrow_move_assignable<_Tp>::value) { - _Tp __t(_VSTD::move(__x)); - __x = _VSTD::move(__y); - __y = _VSTD::move(__t); + _Tp __t(std::move(__x)); + __x = std::move(__y); + __y = std::move(__t); } template @@ -4532,8 +4532,8 @@ void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) // _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b))) - _NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(), - *_VSTD::declval<_ForwardIterator2>()))) + _NOEXCEPT_(_NOEXCEPT_(swap(*std::declval<_ForwardIterator1>(), + *std::declval<_ForwardIterator2>()))) { swap(*__a, *__b); } @@ -4549,7 +4549,7 @@ struct __swappable_with { template - static decltype(swap(_VSTD::declval<_LHS>(), _VSTD::declval<_RHS>())) + static decltype(swap(std::declval<_LHS>(), std::declval<_RHS>())) __test_swap(int); template static __nat __test_swap(long); @@ -4569,8 +4569,8 @@ struct __nothrow_swappable_with { static const bool value = #ifndef _LIBCPP_HAS_NO_NOEXCEPT - noexcept(swap(_VSTD::declval<_Tp>(), _VSTD::declval<_Up>())) - && noexcept(swap(_VSTD::declval<_Up>(), _VSTD::declval<_Tp>())); + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())); #else false; #endif @@ -4727,7 +4727,7 @@ { template static auto __test(int) - -> typename __select_2nd().operator&()), true_type>::type; + -> typename __select_2nd().operator&()), true_type>::type; template static auto __test(long) -> false_type; @@ -4739,7 +4739,7 @@ { template static auto __test(int) - -> typename __select_2nd())), true_type>::type; + -> typename __select_2nd())), true_type>::type; template static auto __test(long) -> false_type; Index: include/typeinfo =================================================================== --- include/typeinfo +++ include/typeinfo @@ -232,7 +232,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_cast(); #else - _VSTD::abort(); + std::abort(); #endif } _LIBCPP_END_NAMESPACE_STD Index: include/unordered_map =================================================================== --- include/unordered_map +++ include/unordered_map @@ -439,7 +439,7 @@ void swap(__unordered_map_hasher&__y) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) { - using _VSTD::swap; + using std::swap; swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y)); } }; @@ -468,7 +468,7 @@ void swap(__unordered_map_hasher&__y) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) { - using _VSTD::swap; + using std::swap; swap(__hash_, __y.__hash_); } }; @@ -511,7 +511,7 @@ void swap(__unordered_map_equal&__y) _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) { - using _VSTD::swap; + using std::swap; swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y)); } }; @@ -543,7 +543,7 @@ void swap(__unordered_map_equal&__y) _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) { - using _VSTD::swap; + using std::swap; swap(__pred_, __y.__pred_); } }; @@ -609,9 +609,9 @@ void operator()(pointer __p) _NOEXCEPT { if (__second_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().second)); if (__first_constructed) - __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first)); + __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().first)); if (__p) __alloc_traits::deallocate(__na_, __p, 1); } @@ -635,7 +635,7 @@ value_type& __get_value() { #if _LIBCPP_STD_VER > 14 - return *_VSTD::launder(_VSTD::addressof(__cc)); + return *std::launder(std::addressof(__cc)); #else return __cc; #endif @@ -645,7 +645,7 @@ const value_type& __get_value() const { #if _LIBCPP_STD_VER > 14 - return *_VSTD::launder(_VSTD::addressof(__cc)); + return *std::launder(std::addressof(__cc)); #else return __cc; #endif @@ -663,8 +663,8 @@ { value_type& __v = __get_value(); return __nc_rref_pair_type( - _VSTD::move(const_cast(__v.first)), - _VSTD::move(__v.second)); + std::move(const_cast(__v.first)), + std::move(__v.second)); } _LIBCPP_INLINE_VISIBILITY @@ -689,7 +689,7 @@ _LIBCPP_INLINE_VISIBILITY __hash_value_type& operator=(_ValueTp&& __v) { - __ref() = _VSTD::forward<_ValueTp>(__v); + __ref() = std::forward<_ValueTp>(__v); return *this; } @@ -1034,7 +1034,7 @@ _LIBCPP_INLINE_VISIBILITY pair insert(value_type&& __x) - {return __table_.__insert_unique(_VSTD::move(__x));} + {return __table_.__insert_unique(std::move(__x));} iterator insert(const_iterator __p, value_type&& __x) { #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -1044,14 +1044,14 @@ #else ((void)__p); #endif - return __table_.__insert_unique(_VSTD::move(__x)).first; + return __table_.__insert_unique(std::move(__x)).first; } template ::value>::type> _LIBCPP_INLINE_VISIBILITY pair insert(_Pp&& __x) - {return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));} + {return __table_.__insert_unique(std::forward<_Pp>(__x));} template ::value>::type> @@ -1065,13 +1065,13 @@ #else ((void)__p); #endif - return insert(_VSTD::forward<_Pp>(__x)).first; + return insert(std::forward<_Pp>(__x)).first; } template _LIBCPP_INLINE_VISIBILITY pair emplace(_Args&&... __args) { - return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...); + return __table_.__emplace_unique(std::forward<_Args>(__args)...); } template @@ -1084,7 +1084,7 @@ #else ((void)__p); #endif - return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; + return __table_.__emplace_unique(std::forward<_Args>(__args)...).first; } #endif // _LIBCPP_CXX03_LANG @@ -1094,18 +1094,18 @@ _LIBCPP_INLINE_VISIBILITY pair try_emplace(const key_type& __k, _Args&&... __args) { - return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(__k), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + return __table_.__emplace_unique_key_args(__k, std::piecewise_construct, + std::forward_as_tuple(__k), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template _LIBCPP_INLINE_VISIBILITY pair try_emplace(key_type&& __k, _Args&&... __args) { - return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct, - _VSTD::forward_as_tuple(_VSTD::move(__k)), - _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); + return __table_.__emplace_unique_key_args(__k, std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::forward_as_tuple(std::forward<_Args>(__args)...)); } template @@ -1119,7 +1119,7 @@ #else ((void)__h); #endif - return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first; + return try_emplace(__k, std::forward<_Args>(__args)...).first; } template @@ -1133,7 +1133,7 @@ #else ((void)__h); #endif - return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first; + return try_emplace(std::move(__k), std::forward<_Args>(__args)...).first; } template @@ -1141,9 +1141,9 @@ pair insert_or_assign(const key_type& __k, _Vp&& __v) { pair __res = __table_.__emplace_unique_key_args(__k, - __k, _VSTD::forward<_Vp>(__v)); + __k, std::forward<_Vp>(__v)); if (!__res.second) { - __res.first->second = _VSTD::forward<_Vp>(__v); + __res.first->second = std::forward<_Vp>(__v); } return __res; } @@ -1153,9 +1153,9 @@ pair insert_or_assign(key_type&& __k, _Vp&& __v) { pair __res = __table_.__emplace_unique_key_args(__k, - _VSTD::move(__k), _VSTD::forward<_Vp>(__v)); + std::move(__k), std::forward<_Vp>(__v)); if (!__res.second) { - __res.first->second = _VSTD::forward<_Vp>(__v); + __res.first->second = std::forward<_Vp>(__v); } return __res; } @@ -1165,7 +1165,7 @@ iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v) { // FIXME: Add debug mode checking for the iterator input - return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first; + return insert_or_assign(__k, std::forward<_Vp>(__v)).first; } template @@ -1173,7 +1173,7 @@ iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v) { // FIXME: Add debug mode checking for the iterator input - return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first; + return insert_or_assign(std::move(__k), std::forward<_Vp>(__v)).first; } #endif // _LIBCPP_STD_VER > 14 @@ -1196,7 +1196,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_map::insert()"); return __table_.template __node_handle_insert_unique< - node_type, insert_return_type>(_VSTD::move(__nh)); + node_type, insert_return_type>(std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1204,7 +1204,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_map::insert()"); return __table_.template __node_handle_insert_unique( - __hint.__i_, _VSTD::move(__nh)); + __hint.__i_, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -1444,7 +1444,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) - : __table_(_VSTD::move(__u.__table_)) + : __table_(std::move(__u.__table_)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1455,7 +1455,7 @@ template unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map( unordered_map&& __u, const allocator_type& __a) - : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a)) + : __table_(std::move(__u.__table_), typename __table::allocator_type(__a)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1516,7 +1516,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) { - __table_ = _VSTD::move(__u.__table_); + __table_ = std::move(__u.__table_); return *this; } @@ -1570,9 +1570,9 @@ { __node_allocator& __na = __table_.__node_alloc(); __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na)); - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k); + __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().first), __k); __h.get_deleter().__first_constructed = true; - __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second)); + __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().second)); __h.get_deleter().__second_constructed = true; return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03 } @@ -1845,32 +1845,32 @@ void insert(initializer_list __il) {insert(__il.begin(), __il.end());} _LIBCPP_INLINE_VISIBILITY - iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));} + iterator insert(value_type&& __x) {return __table_.__insert_multi(std::move(__x));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __x) - {return __table_.__insert_multi(__p.__i_, _VSTD::move(__x));} + {return __table_.__insert_multi(__p.__i_, std::move(__x));} template ::value>::type> _LIBCPP_INLINE_VISIBILITY iterator insert(_Pp&& __x) - {return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));} + {return __table_.__insert_multi(std::forward<_Pp>(__x));} template ::value>::type> _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, _Pp&& __x) - {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));} + {return __table_.__insert_multi(__p.__i_, std::forward<_Pp>(__x));} template iterator emplace(_Args&&... __args) { - return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...); + return __table_.__emplace_multi(std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __p, _Args&&... __args) { - return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...); + return __table_.__emplace_hint_multi(__p.__i_, std::forward<_Args>(__args)...); } #endif // _LIBCPP_CXX03_LANG @@ -1894,7 +1894,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_multimap::insert()"); return __table_.template __node_handle_insert_multi( - _VSTD::move(__nh)); + std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1902,7 +1902,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_multimap::insert()"); return __table_.template __node_handle_insert_multi( - __hint.__i_, _VSTD::move(__nh)); + __hint.__i_, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -2131,7 +2131,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( unordered_multimap&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) - : __table_(_VSTD::move(__u.__table_)) + : __table_(std::move(__u.__table_)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -2142,7 +2142,7 @@ template unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap( unordered_multimap&& __u, const allocator_type& __a) - : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a)) + : __table_(std::move(__u.__table_), typename __table::allocator_type(__a)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -2204,7 +2204,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) { - __table_ = _VSTD::move(__u.__table_); + __table_ = std::move(__u.__table_); return *this; } @@ -2257,9 +2257,9 @@ { _EqRng __xeq = __x.equal_range(__i->first); _EqRng __yeq = __y.equal_range(__i->first); - if (_VSTD::distance(__xeq.first, __xeq.second) != - _VSTD::distance(__yeq.first, __yeq.second) || - !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) + if (std::distance(__xeq.first, __xeq.second) != + std::distance(__yeq.first, __yeq.second) || + !std::is_permutation(__xeq.first, __xeq.second, __yeq.first)) return false; __i = __xeq.second; } Index: include/unordered_set =================================================================== --- include/unordered_set +++ include/unordered_set @@ -523,7 +523,7 @@ template _LIBCPP_INLINE_VISIBILITY pair emplace(_Args&&... __args) - {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);} + {return __table_.__emplace_unique(std::forward<_Args>(__args)...);} template _LIBCPP_INLINE_VISIBILITY #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -532,16 +532,16 @@ _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, "unordered_set::emplace_hint(const_iterator, args...) called with an iterator not" " referring to this unordered_set"); - return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; + return __table_.__emplace_unique(std::forward<_Args>(__args)...).first; } #else iterator emplace_hint(const_iterator, _Args&&... __args) - {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;} + {return __table_.__emplace_unique(std::forward<_Args>(__args)...).first;} #endif _LIBCPP_INLINE_VISIBILITY pair insert(value_type&& __x) - {return __table_.__insert_unique(_VSTD::move(__x));} + {return __table_.__insert_unique(std::move(__x));} _LIBCPP_INLINE_VISIBILITY #if _LIBCPP_DEBUG_LEVEL >= 2 iterator insert(const_iterator __p, value_type&& __x) @@ -549,11 +549,11 @@ _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, "unordered_set::insert(const_iterator, value_type&&) called with an iterator not" " referring to this unordered_set"); - return insert(_VSTD::move(__x)).first; + return insert(std::move(__x)).first; } #else iterator insert(const_iterator, value_type&& __x) - {return insert(_VSTD::move(__x)).first;} + {return insert(std::move(__x)).first;} #endif _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) @@ -597,7 +597,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_set::insert()"); return __table_.template __node_handle_insert_unique< - node_type, insert_return_type>(_VSTD::move(__nh)); + node_type, insert_return_type>(std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __h, node_type&& __nh) @@ -605,7 +605,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_set::insert()"); return __table_.template __node_handle_insert_unique( - __h, _VSTD::move(__nh)); + __h, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(key_type const& __key) @@ -827,7 +827,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) - : __table_(_VSTD::move(__u.__table_)) + : __table_(std::move(__u.__table_)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -838,7 +838,7 @@ template unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( unordered_set&& __u, const allocator_type& __a) - : __table_(_VSTD::move(__u.__table_), __a) + : __table_(std::move(__u.__table_), __a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -847,7 +847,7 @@ { iterator __i = __u.begin(); while (__u.size() != 0) - __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_)); + __table_.__insert_unique(std::move(__u.__table_.remove(__i++)->__value_)); } #if _LIBCPP_DEBUG_LEVEL >= 2 else @@ -897,7 +897,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) { - __table_ = _VSTD::move(__u.__table_); + __table_ = std::move(__u.__table_); return *this; } @@ -1113,17 +1113,17 @@ template _LIBCPP_INLINE_VISIBILITY iterator emplace(_Args&&... __args) - {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);} + {return __table_.__emplace_multi(std::forward<_Args>(__args)...);} template _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&&... __args) - {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);} + {return __table_.__emplace_hint_multi(__p, std::forward<_Args>(__args)...);} _LIBCPP_INLINE_VISIBILITY - iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));} + iterator insert(value_type&& __x) {return __table_.__insert_multi(std::move(__x));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __x) - {return __table_.__insert_multi(__p, _VSTD::move(__x));} + {return __table_.__insert_multi(__p, std::move(__x));} _LIBCPP_INLINE_VISIBILITY void insert(initializer_list __il) {insert(__il.begin(), __il.end());} @@ -1147,7 +1147,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_multiset::insert()"); return __table_.template __node_handle_insert_multi( - _VSTD::move(__nh)); + std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __hint, node_type&& __nh) @@ -1155,7 +1155,7 @@ _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), "node_type with incompatible allocator passed to unordered_multiset::insert()"); return __table_.template __node_handle_insert_multi( - __hint, _VSTD::move(__nh)); + __hint, std::move(__nh)); } _LIBCPP_INLINE_VISIBILITY node_type extract(const_iterator __position) @@ -1389,7 +1389,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) - : __table_(_VSTD::move(__u.__table_)) + : __table_(std::move(__u.__table_)) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1400,7 +1400,7 @@ template unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( unordered_multiset&& __u, const allocator_type& __a) - : __table_(_VSTD::move(__u.__table_), __a) + : __table_(std::move(__u.__table_), __a) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1409,7 +1409,7 @@ { iterator __i = __u.begin(); while (__u.size() != 0) - __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_)); + __table_.__insert_multi(std::move(__u.__table_.remove(__i++)->__value_)); } #if _LIBCPP_DEBUG_LEVEL >= 2 else @@ -1460,7 +1460,7 @@ unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) { - __table_ = _VSTD::move(__u.__table_); + __table_ = std::move(__u.__table_); return *this; } @@ -1511,9 +1511,9 @@ { _EqRng __xeq = __x.equal_range(*__i); _EqRng __yeq = __y.equal_range(*__i); - if (_VSTD::distance(__xeq.first, __xeq.second) != - _VSTD::distance(__yeq.first, __yeq.second) || - !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) + if (std::distance(__xeq.first, __xeq.second) != + std::distance(__yeq.first, __yeq.second) || + !std::is_permutation(__xeq.first, __xeq.second, __yeq.first)) return false; __i = __xeq.second; } Index: include/utility =================================================================== --- include/utility +++ include/utility @@ -270,7 +270,7 @@ >::type swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) { - _VSTD::swap_ranges(__a, __a + _Np, __b); + std::swap_ranges(__a, __a + _Np, __b); } template @@ -287,7 +287,7 @@ #endif move_if_noexcept(_Tp& __x) _NOEXCEPT { - return _VSTD::move(__x); + return std::move(__x); } #if _LIBCPP_STD_VER > 14 @@ -430,14 +430,14 @@ > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(_U1&& __u1, _U2&& __u2) - : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} + : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {} template() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(_U1&& __u1, _U2&& __u2) - : first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {} + : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {} template() @@ -458,30 +458,30 @@ > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(pair<_U1, _U2>&&__p) - : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} + : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {} template() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(pair<_U1, _U2>&& __p) - : first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {} + : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {} template::template __enable_explicit<_Tuple>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit pair(_Tuple&& __p) - : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), - second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} + : first(std::get<0>(std::forward<_Tuple>(__p))), + second(std::get<1>(std::forward<_Tuple>(__p))) {} template::template __enable_implicit<_Tuple>() > = false> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 pair(_Tuple&& __p) - : first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))), - second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {} + : first(std::get<0>(std::forward<_Tuple>(__p))), + second(std::get<1>(std::forward<_Tuple>(__p))) {} template _LIBCPP_INLINE_VISIBILITY @@ -512,8 +512,8 @@ _NOEXCEPT_(is_nothrow_move_assignable::value && is_nothrow_move_assignable::value) { - first = _VSTD::forward(__p.first); - second = _VSTD::forward(__p.second); + first = std::forward(__p.first); + second = std::forward(__p.second); return *this; } @@ -522,8 +522,8 @@ > = false> _LIBCPP_INLINE_VISIBILITY pair& operator=(_Tuple&& __p) { - first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p)); - second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p)); + first = std::get<0>(std::forward<_Tuple>(__p)); + second = std::get<1>(std::forward<_Tuple>(__p)); return *this; } #endif @@ -533,7 +533,7 @@ swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable::value && __is_nothrow_swappable::value) { - using _VSTD::swap; + using std::swap; swap(first, __p.first); swap(second, __p.second); } @@ -647,7 +647,7 @@ make_pair(_T1&& __t1, _T2&& __t2) { return pair::type, typename __unwrap_ref_decay<_T2>::type> - (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); + (std::forward<_T1>(__t1), std::forward<_T2>(__t2)); } #else // _LIBCPP_CXX03_LANG @@ -708,13 +708,13 @@ static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T1&& - get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);} + get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T1>(__p.first);} template static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T1&& - get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward(__p.first);} + get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward(__p.first);} #endif // _LIBCPP_CXX03_LANG }; @@ -738,13 +738,13 @@ static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _T2&& - get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);} + get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T2>(__p.second);} template static _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _T2&& - get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward(__p.second);} + get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward(__p.second);} #endif // _LIBCPP_CXX03_LANG }; @@ -770,7 +770,7 @@ typename tuple_element<_Ip, pair<_T1, _T2> >::type&& get(pair<_T1, _T2>&& __p) _NOEXCEPT { - return __get_pair<_Ip>::get(_VSTD::move(__p)); + return __get_pair<_Ip>::get(std::move(__p)); } template @@ -778,7 +778,7 @@ const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT { - return __get_pair<_Ip>::get(_VSTD::move(__p)); + return __get_pair<_Ip>::get(std::move(__p)); } #endif // _LIBCPP_CXX03_LANG @@ -801,14 +801,14 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT { - return __get_pair<0>::get(_VSTD::move(__p)); + return __get_pair<0>::get(std::move(__p)); } template inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT { - return __get_pair<0>::get(_VSTD::move(__p)); + return __get_pair<0>::get(std::move(__p)); } template @@ -829,14 +829,14 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT { - return __get_pair<1>::get(_VSTD::move(__p)); + return __get_pair<1>::get(std::move(__p)); } template inline _LIBCPP_INLINE_VISIBILITY constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT { - return __get_pair<1>::get(_VSTD::move(__p)); + return __get_pair<1>::get(std::move(__p)); } #endif @@ -901,8 +901,8 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _T1 exchange(_T1& __obj, _T2 && __new_value) { - _T1 __old_value = _VSTD::move(__obj); - __obj = _VSTD::forward<_T2>(__new_value); + _T1 __old_value = std::move(__obj); + __obj = std::forward<_T2>(__new_value); return __old_value; } #endif // _LIBCPP_STD_VER > 11 Index: include/valarray =================================================================== --- include/valarray +++ include/valarray @@ -2740,7 +2740,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type))); + std::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type))); for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) ::new (__r.__end_) result_type(__expr_[__i]); } @@ -2758,7 +2758,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2793,7 +2793,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2819,7 +2819,7 @@ if (__v.size()) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2857,7 +2857,7 @@ if (__n) { __begin_ = __end_ = static_cast( -_VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); +std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2887,7 +2887,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2915,7 +2915,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2945,7 +2945,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -2975,7 +2975,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { @@ -3012,11 +3012,11 @@ { __clear(size()); __begin_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); __end_ = __begin_ + __n; - _VSTD::uninitialized_copy(__f, __l, __begin_); + std::uninitialized_copy(__f, __l, __begin_); } else { - _VSTD::copy(__f, __l, __begin_); + std::copy(__f, __l, __begin_); } return *this; } @@ -3060,7 +3060,7 @@ valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) { - _VSTD::fill(__begin_, __end_, __x); + std::fill(__begin_, __end_, __x); return *this; } @@ -3268,7 +3268,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(+*__p); } @@ -3286,7 +3286,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(-*__p); } @@ -3304,7 +3304,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(~*__p); } @@ -3321,7 +3321,7 @@ { __r.__begin_ = __r.__end_ = - static_cast(_VSTD::__libcpp_allocate(__n * sizeof(bool), __alignof(bool))); + static_cast(std::__libcpp_allocate(__n * sizeof(bool), __alignof(bool))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) bool(!*__p); } @@ -3593,8 +3593,8 @@ void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT { - _VSTD::swap(__begin_, __v.__begin_); - _VSTD::swap(__end_, __v.__end_); + std::swap(__begin_, __v.__begin_); + std::swap(__end_, __v.__end_); } template @@ -3618,7 +3618,7 @@ { if (__begin_ == __end_) return value_type(); - return *_VSTD::min_element(__begin_, __end_); + return *std::min_element(__begin_, __end_); } template @@ -3628,7 +3628,7 @@ { if (__begin_ == __end_) return value_type(); - return *_VSTD::max_element(__begin_, __end_); + return *std::max_element(__begin_, __end_); } template @@ -3642,20 +3642,20 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); const value_type* __sb; value_type* __tb; value_type* __te; if (__i >= 0) { - __i = _VSTD::min(__i, static_cast(__n)); + __i = std::min(__i, static_cast(__n)); __sb = __begin_ + __i; __tb = __r.__begin_; __te = __r.__begin_ + (__n - __i); } else { - __i = _VSTD::min(-__i, static_cast(__n)); + __i = std::min(-__i, static_cast(__n)); __sb = __begin_; __tb = __r.__begin_ + __i; __te = __r.__begin_ + __n; @@ -3681,7 +3681,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); __i %= static_cast(__n); const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) @@ -3703,7 +3703,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } @@ -3721,7 +3721,7 @@ __r.__begin_ = __r.__end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new (__r.__end_) value_type(__f(*__p)); } @@ -3736,7 +3736,7 @@ { while (__end_ != __begin_) (--__end_)->~value_type(); - _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type)); + std::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), __alignof(value_type)); __begin_ = __end_ = nullptr; } } @@ -3749,7 +3749,7 @@ if (__n) { __begin_ = __end_ = static_cast( - _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); + std::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type))); #ifndef _LIBCPP_NO_EXCEPTIONS try { Index: include/variant =================================================================== --- include/variant +++ include/variant @@ -237,7 +237,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_variant_access(); #else - _VSTD::abort(); + std::abort(); #endif } @@ -401,13 +401,13 @@ template inline _LIBCPP_INLINE_VISIBILITY static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) { - return _VSTD::forward<_Vp>(__v).__head; + return std::forward<_Vp>(__v).__head; } template inline _LIBCPP_INLINE_VISIBILITY static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) { - return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>); + return __get_alt(std::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>); } }; @@ -415,7 +415,7 @@ template inline _LIBCPP_INLINE_VISIBILITY static constexpr auto&& __get_alt(_Vp&& __v) { - return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data, + return __union::__get_alt(std::forward<_Vp>(__v).__data, in_place_index<_Ip>); } }; @@ -424,7 +424,7 @@ template inline _LIBCPP_INLINE_VISIBILITY static constexpr auto&& __get_alt(_Vp&& __v) { - return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl); + return __base::__get_alt<_Ip>(std::forward<_Vp>(__v).__impl); } }; @@ -439,9 +439,9 @@ __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { constexpr auto __fdiagonal = __make_fdiagonal<_Visitor&&, - decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); - return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__as_base()...); + decltype(std::forward<_Vs>(__vs).__as_base())...>(); + return __fdiagonal[__index](std::forward<_Visitor>(__visitor), + std::forward<_Vs>(__vs).__as_base()...); } template @@ -450,10 +450,10 @@ _Vs&&... __vs) { constexpr auto __fmatrix = __make_fmatrix<_Visitor&&, - decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); + decltype(std::forward<_Vs>(__vs).__as_base())...>(); return __at(__fmatrix, __vs.index()...)( - _VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__as_base()...); + std::forward<_Visitor>(__visitor), + std::forward<_Vs>(__vs).__as_base()...); } private: @@ -480,7 +480,7 @@ static constexpr auto __make_farray(_Fs&&... __fs) { __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>(); using __result = array...>, sizeof...(_Fs)>; - return __result{{_VSTD::forward<_Fs>(__fs)...}}; + return __result{{std::forward<_Fs>(__fs)...}}; } template @@ -550,16 +550,16 @@ static constexpr decltype(auto) __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { return __base::__visit_alt_at(__index, - _VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__impl...); + std::forward<_Visitor>(__visitor), + std::forward<_Vs>(__vs).__impl...); } template inline _LIBCPP_INLINE_VISIBILITY static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, _Vs&&... __vs) { - return __base::__visit_alt(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__impl...); + return __base::__visit_alt(std::forward<_Visitor>(__visitor), + std::forward<_Vs>(__vs).__impl...); } template @@ -568,8 +568,8 @@ __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { return __visit_alt_at( __index, - __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), - _VSTD::forward<_Vs>(__vs)...); + __make_value_visitor(std::forward<_Visitor>(__visitor)), + std::forward<_Vs>(__vs)...); } template @@ -577,8 +577,8 @@ static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, _Vs&&... __vs) { return __visit_alt( - __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), - _VSTD::forward<_Vs>(__vs)...); + __make_value_visitor(std::forward<_Visitor>(__visitor)), + std::forward<_Vs>(__vs)...); } private: @@ -595,9 +595,9 @@ constexpr decltype(auto) operator()(_Alts&&... __alts) const { __std_visit_exhaustive_visitor_check< _Visitor, - decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); - return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Alts>(__alts).__value...); + decltype((std::forward<_Alts>(__alts).__value))...>(); + return __invoke_constexpr(std::forward<_Visitor>(__visitor), + std::forward<_Alts>(__alts).__value...); } _Visitor&& __visitor; }; @@ -605,7 +605,7 @@ template inline _LIBCPP_INLINE_VISIBILITY static constexpr auto __make_value_visitor(_Visitor&& __visitor) { - return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)}; + return __value_visitor<_Visitor>{std::forward<_Visitor>(__visitor)}; } }; @@ -618,7 +618,7 @@ template inline _LIBCPP_INLINE_VISIBILITY explicit constexpr __alt(in_place_t, _Args&&... __args) - : __value(_VSTD::forward<_Args>(__args)...) {} + : __value(std::forward<_Args>(__args)...) {} __value_type __value; }; @@ -642,12 +642,12 @@ template \ inline _LIBCPP_INLINE_VISIBILITY \ explicit constexpr __union(in_place_index_t<0>, _Args&&... __args) \ - : __head(in_place, _VSTD::forward<_Args>(__args)...) {} \ + : __head(in_place, std::forward<_Args>(__args)...) {} \ \ template \ inline _LIBCPP_INLINE_VISIBILITY \ explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \ - : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \ + : __tail(in_place_index<_Ip - 1>, std::forward<_Args>(__args)...) {} \ \ __union(const __union&) = default; \ __union(__union&&) = default; \ @@ -684,7 +684,7 @@ inline _LIBCPP_INLINE_VISIBILITY explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args) : - __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...), + __data(in_place_index<_Ip>, std::forward<_Args>(__args)...), __index(_Ip) {} inline _LIBCPP_INLINE_VISIBILITY @@ -702,13 +702,13 @@ constexpr auto&& __as_base() & { return *this; } inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() && { return _VSTD::move(*this); } + constexpr auto&& __as_base() && { return std::move(*this); } inline _LIBCPP_INLINE_VISIBILITY constexpr auto&& __as_base() const & { return *this; } inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() const && { return _VSTD::move(*this); } + constexpr auto&& __as_base() const && { return std::move(*this); } inline _LIBCPP_INLINE_VISIBILITY static constexpr size_t __size() { return sizeof...(_Types); } @@ -785,8 +785,8 @@ template inline _LIBCPP_INLINE_VISIBILITY static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) { - ::new ((void*)_VSTD::addressof(__a)) - __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...); + ::new ((void*)std::addressof(__a)) + __alt<_Ip, _Tp>(in_place, std::forward<_Args>(__args)...); return __a.__value; } @@ -800,9 +800,9 @@ [](auto& __lhs_alt, auto&& __rhs_alt) { __construct_alt( __lhs_alt, - _VSTD::forward(__rhs_alt).__value); + std::forward(__rhs_alt).__value); }, - __lhs, _VSTD::forward<_Rhs>(__rhs)); + __lhs, std::forward<_Rhs>(__rhs)); __lhs.__index = __rhs.index(); } } @@ -839,7 +839,7 @@ __move_constructor(__move_constructor&& __that) noexcept( __all...>::value) : __move_constructor(__valueless_t{}) { - this->__generic_construct(*this, _VSTD::move(__that)); + this->__generic_construct(*this, std::move(__that)); }); _LIBCPP_VARIANT_MOVE_CONSTRUCTOR( @@ -900,7 +900,7 @@ auto& __emplace(_Args&&... __args) { this->__destroy(); auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this), - _VSTD::forward<_Args>(__args)...); + std::forward<_Args>(__args)...); this->__index = _Ip; return __res; } @@ -910,18 +910,18 @@ inline _LIBCPP_INLINE_VISIBILITY void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) { if (this->index() == _Ip) { - __a.__value = _VSTD::forward<_Arg>(__arg); + __a.__value = std::forward<_Arg>(__arg); } else { struct { void operator()(true_type) const { - __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg)); + __this->__emplace<_Ip>(std::forward<_Arg>(__arg)); } void operator()(false_type) const { - __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg))); + __this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg))); } __assignment* __this; _Arg&& __arg; - } __impl{this, _VSTD::forward<_Arg>(__arg)}; + } __impl{this, std::forward<_Arg>(__arg)}; __impl(bool_constant || !is_nothrow_move_constructible_v<_Tp>>{}); } @@ -940,9 +940,9 @@ [this](auto& __this_alt, auto&& __that_alt) { this->__assign_alt( __this_alt, - _VSTD::forward(__that_alt).__value); + std::forward(__that_alt).__value); }, - *this, _VSTD::forward<_That>(__that)); + *this, std::forward<_That>(__that)); } } }; @@ -978,7 +978,7 @@ __move_assignment& operator=(__move_assignment&& __that) noexcept( __all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_move_assignable_v<_Types>)...>::value) { - this->__generic_assign(_VSTD::move(__that)); + this->__generic_assign(std::move(__that)); return *this; }); @@ -1040,7 +1040,7 @@ inline _LIBCPP_INLINE_VISIBILITY void __assign(_Arg&& __arg) { this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), - _VSTD::forward<_Arg>(__arg)); + std::forward<_Arg>(__arg)); } inline _LIBCPP_INLINE_VISIBILITY @@ -1051,34 +1051,34 @@ __visitation::__base::__visit_alt_at( this->index(), [](auto& __this_alt, auto& __that_alt) { - using _VSTD::swap; + using std::swap; swap(__this_alt.__value, __that_alt.__value); }, *this, __that); } else { __impl* __lhs = this; - __impl* __rhs = _VSTD::addressof(__that); + __impl* __rhs = std::addressof(__that); if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) { - _VSTD::swap(__lhs, __rhs); + std::swap(__lhs, __rhs); } - __impl __tmp(_VSTD::move(*__rhs)); + __impl __tmp(std::move(*__rhs)); #ifndef _LIBCPP_NO_EXCEPTIONS // EXTENSION: When the move construction of `__lhs` into `__rhs` throws // and `__tmp` is nothrow move constructible then we move `__tmp` back // into `__rhs` and provide the strong exception safety guarentee. try { - this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); + this->__generic_construct(*__rhs, std::move(*__lhs)); } catch (...) { if (__tmp.__move_nothrow()) { - this->__generic_construct(*__rhs, _VSTD::move(__tmp)); + this->__generic_construct(*__rhs, std::move(__tmp)); } throw; } #else - this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); + this->__generic_construct(*__rhs, std::move(*__lhs)); #endif - this->__generic_construct(*__lhs, _VSTD::move(__tmp)); + this->__generic_construct(*__lhs, std::move(__tmp)); } } @@ -1155,7 +1155,7 @@ inline _LIBCPP_INLINE_VISIBILITY constexpr variant(_Arg&& __arg) noexcept( is_nothrow_constructible_v<_Tp, _Arg>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {} + : __impl(in_place_index<_Ip>, std::forward<_Arg>(__arg)) {} template , @@ -1165,7 +1165,7 @@ explicit constexpr variant( in_place_index_t<_Ip>, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} + : __impl(in_place_index<_Ip>, std::forward<_Args>(__args)...) {} template < size_t _Ip, @@ -1181,7 +1181,7 @@ initializer_list<_Up> __il, _Args&&... __args) noexcept( is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) - : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} + : __impl(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {} template < class _Tp, @@ -1192,7 +1192,7 @@ inline _LIBCPP_INLINE_VISIBILITY explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept( is_nothrow_constructible_v<_Tp, _Args...>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} + : __impl(in_place_index<_Ip>, std::forward<_Args>(__args)...) {} template < class _Tp, @@ -1208,7 +1208,7 @@ initializer_list<_Up> __il, _Args&&... __args) noexcept( is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>) - : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} + : __impl(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {} ~variant() = default; @@ -1227,7 +1227,7 @@ variant& operator=(_Arg&& __arg) noexcept( is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_constructible_v<_Tp, _Arg>) { - __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg)); + __impl.template __assign<_Ip>(std::forward<_Arg>(__arg)); return *this; } @@ -1239,7 +1239,7 @@ enable_if_t, int> = 0> inline _LIBCPP_INLINE_VISIBILITY _Tp& emplace(_Args&&... __args) { - return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); + return __impl.template __emplace<_Ip>(std::forward<_Args>(__args)...); } template < @@ -1252,7 +1252,7 @@ int> = 0> inline _LIBCPP_INLINE_VISIBILITY _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { - return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); + return __impl.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...); } template < @@ -1263,7 +1263,7 @@ enable_if_t, int> = 0> inline _LIBCPP_INLINE_VISIBILITY _Tp& emplace(_Args&&... __args) { - return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); + return __impl.template __emplace<_Ip>(std::forward<_Args>(__args)...); } template < @@ -1276,7 +1276,7 @@ int> = 0> inline _LIBCPP_INLINE_VISIBILITY _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { - return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); + return __impl.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...); } inline _LIBCPP_INLINE_VISIBILITY @@ -1328,7 +1328,7 @@ if (!__holds_alternative<_Ip>(__v)) { __throw_bad_variant_access(); } - return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value; + return __variant::__get_alt<_Ip>(std::forward<_Vp>(__v)).__value; } template @@ -1348,7 +1348,7 @@ variant<_Types...>&& __v) { static_assert(_Ip < sizeof...(_Types)); static_assert(!is_void_v>>); - return __generic_get<_Ip>(_VSTD::move(__v)); + return __generic_get<_Ip>(std::move(__v)); } template @@ -1368,7 +1368,7 @@ const variant<_Types...>&& __v) { static_assert(_Ip < sizeof...(_Types)); static_assert(!is_void_v>>); - return __generic_get<_Ip>(_VSTD::move(__v)); + return __generic_get<_Ip>(std::move(__v)); } template @@ -1376,7 +1376,7 @@ _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Tp& get(variant<_Types...>& __v) { static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); + return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); } template @@ -1384,8 +1384,8 @@ _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Tp&& get(variant<_Types...>&& __v) { static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( - _VSTD::move(__v)); + return std::get<__find_exactly_one_t<_Tp, _Types...>::value>( + std::move(__v)); } template @@ -1393,7 +1393,7 @@ _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const _Tp& get(const variant<_Types...>& __v) { static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); + return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); } template @@ -1401,8 +1401,8 @@ _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const _Tp&& get(const variant<_Types...>&& __v) { static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( - _VSTD::move(__v)); + return std::get<__find_exactly_one_t<_Tp, _Types...>::value>( + std::move(__v)); } template @@ -1410,7 +1410,7 @@ constexpr auto* __generic_get_if(_Vp* __v) noexcept { using __variant_detail::__access::__variant; return __v && __holds_alternative<_Ip>(*__v) - ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value) + ? std::addressof(__variant::__get_alt<_Ip>(*__v).__value) : nullptr; } @@ -1437,7 +1437,7 @@ constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __v) noexcept { static_assert(!is_void_v<_Tp>); - return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); + return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); } template @@ -1445,16 +1445,16 @@ constexpr add_pointer_t get_if(const variant<_Types...>* __v) noexcept { static_assert(!is_void_v<_Tp>); - return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); + return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); } template struct __convert_to_bool { template _LIBCPP_INLINE_VISIBILITY constexpr bool operator()(_T1 && __t1, _T2&& __t2) const { - static_assert(std::is_convertible(__t1), _VSTD::forward<_T2>(__t2))), bool>::value, + static_assert(std::is_convertible(__t1), std::forward<_T2>(__t2))), bool>::value, "the relational operator does not return a type which is implicitly convertible to bool"); - return _Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); + return _Operator{}(std::forward<_T1>(__t1), std::forward<_T2>(__t2)); } }; @@ -1540,8 +1540,8 @@ __throw_bad_variant_access(); } } - return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs)...); + return __variant::__visit_value(std::forward<_Visitor>(__visitor), + std::forward<_Vs>(__vs)...); } struct _LIBCPP_TEMPLATE_VIS monostate {}; Index: include/vector =================================================================== --- include/vector +++ include/vector @@ -305,14 +305,14 @@ void __vector_base_common<__b>::__throw_length_error() const { - _VSTD::__throw_length_error("vector"); + std::__throw_length_error("vector"); } template void __vector_base_common<__b>::__throw_out_of_range() const { - _VSTD::__throw_out_of_range("vector"); + std::__throw_out_of_range("vector"); } _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __vector_base_common) @@ -403,7 +403,7 @@ void __move_assign_alloc(__vector_base& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable::value) { - __alloc() = _VSTD::move(__c.__alloc()); + __alloc() = std::move(__c.__alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -419,7 +419,7 @@ { pointer __soon_to_be_end = __end_; while (__new_last != __soon_to_be_end) - __alloc_traits::destroy(__alloc(), _VSTD::__to_raw_pointer(--__soon_to_be_end)); + __alloc_traits::destroy(__alloc(), std::__to_raw_pointer(--__soon_to_be_end)); __end_ = __new_last; } @@ -481,8 +481,8 @@ typedef typename __base::const_pointer const_pointer; typedef __wrap_iter iterator; typedef __wrap_iter const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; static_assert((is_same::value), "Allocator::value_type must be same type as value_type"); @@ -688,10 +688,10 @@ _LIBCPP_INLINE_VISIBILITY value_type* data() _NOEXCEPT - {return _VSTD::__to_raw_pointer(this->__begin_);} + {return std::__to_raw_pointer(this->__begin_);} _LIBCPP_INLINE_VISIBILITY const value_type* data() const _NOEXCEPT - {return _VSTD::__to_raw_pointer(this->__begin_);} + {return std::__to_raw_pointer(this->__begin_);} #ifdef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY @@ -700,7 +700,7 @@ template _LIBCPP_INLINE_VISIBILITY void __emplace_back(_Arg&& __arg) { - emplace_back(_VSTD::forward<_Arg>(__arg)); + emplace_back(std::forward<_Arg>(__arg)); } #endif @@ -931,9 +931,9 @@ { __annotate_delete(); __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()); + std::swap(this->__begin_, __v.__begin_); + std::swap(this->__end_, __v.__end_); + std::swap(this->__end_cap(), __v.__end_cap()); __v.__first_ = __v.__begin_; __annotate_new(size()); __invalidate_all_iterators(); @@ -947,9 +947,9 @@ 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()); + std::swap(this->__begin_, __v.__begin_); + std::swap(this->__end_, __v.__end_); + std::swap(this->__end_cap(), __v.__end_cap()); __v.__first_ = __v.__begin_; __annotate_new(size()); __invalidate_all_iterators(); @@ -990,7 +990,7 @@ typename vector<_Tp, _Allocator>::size_type vector<_Tp, _Allocator>::max_size() const _NOEXCEPT { - return _VSTD::min(__alloc_traits::max_size(this->__alloc()), + return std::min(__alloc_traits::max_size(this->__alloc()), numeric_limits::max()); } @@ -1006,7 +1006,7 @@ const size_type __cap = capacity(); if (__cap >= __ms / 2) return __ms; - return _VSTD::max(2*__cap, __new_size); + return std::max(2*__cap, __new_size); } // Default constructs __n objects starting at __end_ @@ -1022,7 +1022,7 @@ do { __RAII_IncreaseAnnotator __annotator(*this); - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_)); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_)); ++this->__end_; --__n; __annotator.__done(); @@ -1044,7 +1044,7 @@ do { __RAII_IncreaseAnnotator __annotator(*this); - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x); + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_), __x); ++this->__end_; --__n; __annotator.__done(); @@ -1206,7 +1206,7 @@ #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n > 0) { __vallocate(__n); @@ -1226,7 +1226,7 @@ #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); #endif - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n > 0) { __vallocate(__n); @@ -1274,7 +1274,7 @@ #else _NOEXCEPT_(is_nothrow_move_constructible::value) #endif - : __base(_VSTD::move(__x.__alloc())) + : __base(std::move(__x.__alloc())) { #if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); @@ -1426,7 +1426,7 @@ >::type vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) { - size_type __new_size = static_cast(_VSTD::distance(__first, __last)); + size_type __new_size = static_cast(std::distance(__first, __last)); if (__new_size <= capacity()) { _ForwardIterator __mid = __last; @@ -1435,9 +1435,9 @@ { __growing = true; __mid = __first; - _VSTD::advance(__mid, size()); + std::advance(__mid, size()); } - pointer __m = _VSTD::copy(__first, __mid, this->__begin_); + pointer __m = std::copy(__first, __mid, this->__begin_); if (__growing) __construct_at_end(__mid, __last, __new_size - size()); else @@ -1459,7 +1459,7 @@ if (__n <= capacity()) { size_type __s = size(); - _VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u); + std::fill_n(this->__begin_, std::min(__n, __s), __u); if (__n > __s) __construct_at_end(__n - __s, __u); else @@ -1611,8 +1611,8 @@ { allocator_type& __a = this->__alloc(); __split_buffer __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.push_back(std::forward<_Up>(__x)); + __alloc_traits::construct(__a, std::__to_raw_pointer(__v.__end_), std::forward<_Up>(__x)); __v.__end_++; __swap_out_circular_buffer(__v); } @@ -1626,7 +1626,7 @@ { __RAII_IncreaseAnnotator __annotator(*this); __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), __x); + std::__to_raw_pointer(this->__end_), __x); __annotator.__done(); ++this->__end_; } @@ -1645,13 +1645,13 @@ { __RAII_IncreaseAnnotator __annotator(*this); __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), - _VSTD::move(__x)); + std::__to_raw_pointer(this->__end_), + std::move(__x)); __annotator.__done(); ++this->__end_; } else - __push_back_slow_path(_VSTD::move(__x)); + __push_back_slow_path(std::move(__x)); } template @@ -1661,8 +1661,8 @@ { allocator_type& __a = this->__alloc(); __split_buffer __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.emplace_back(std::forward<_Args>(__args)...); + __alloc_traits::construct(__a, std::__to_raw_pointer(__v.__end_), std::forward<_Args>(__args)...); __v.__end_++; __swap_out_circular_buffer(__v); } @@ -1681,13 +1681,13 @@ { __RAII_IncreaseAnnotator __annotator(*this); __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), - _VSTD::forward<_Args>(__args)...); + std::__to_raw_pointer(this->__end_), + std::forward<_Args>(__args)...); __annotator.__done(); ++this->__end_; } else - __emplace_back_slow_path(_VSTD::forward<_Args>(__args)...); + __emplace_back_slow_path(std::forward<_Args>(__args)...); #if _LIBCPP_STD_VER > 14 return this->back(); #endif @@ -1718,7 +1718,7 @@ "vector::erase(iterator) called with a non-dereferenceable iterator"); difference_type __ps = __position - cbegin(); pointer __p = this->__begin_ + __ps; - this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p)); + this->__destruct_at_end(std::move(__p + 1, this->__end_, __p)); this->__invalidate_iterators_past(__p-1); iterator __r = __make_iter(__p); return __r; @@ -1739,7 +1739,7 @@ _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range"); pointer __p = this->__begin_ + (__first - begin()); if (__first != __last) { - this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p)); + this->__destruct_at_end(std::move(__p + (__last - __first), this->__end_, __p)); this->__invalidate_iterators_past(__p - 1); } iterator __r = __make_iter(__p); @@ -1754,9 +1754,9 @@ 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); + std::__to_raw_pointer(this->__end_), + std::move(*__i)); + std::move_backward(__from_s, __from_s + __n, __old_last); } template @@ -1775,7 +1775,7 @@ if (__p == this->__end_) { __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), __x); + std::__to_raw_pointer(this->__end_), __x); ++this->__end_; } else @@ -1816,14 +1816,14 @@ if (__p == this->__end_) { __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), - _VSTD::move(__x)); + std::__to_raw_pointer(this->__end_), + std::move(__x)); ++this->__end_; } else { __move_range(__p, this->__end_, __p + 1); - *__p = _VSTD::move(__x); + *__p = std::move(__x); } __annotator.__done(); } @@ -1831,7 +1831,7 @@ { allocator_type& __a = this->__alloc(); __split_buffer __v(__recommend(size() + 1), __p - this->__begin_, __a); - __v.push_back(_VSTD::move(__x)); + __v.push_back(std::move(__x)); __p = __swap_out_circular_buffer(__v, __p); } return __make_iter(__p); @@ -1854,15 +1854,15 @@ if (__p == this->__end_) { __alloc_traits::construct(this->__alloc(), - _VSTD::__to_raw_pointer(this->__end_), - _VSTD::forward<_Args>(__args)...); + std::__to_raw_pointer(this->__end_), + std::forward<_Args>(__args)...); ++this->__end_; } else { - __temp_value __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...); + __temp_value __tmp(this->__alloc(), std::forward<_Args>(__args)...); __move_range(__p, this->__end_, __p + 1); - *__p = _VSTD::move(__tmp.get()); + *__p = std::move(__tmp.get()); } __annotator.__done(); } @@ -1870,7 +1870,7 @@ { allocator_type& __a = this->__alloc(); __split_buffer __v(__recommend(size() + 1), __p - this->__begin_, __a); - __v.emplace_back(_VSTD::forward<_Args>(__args)...); + __v.emplace_back(std::forward<_Args>(__args)...); __p = __swap_out_circular_buffer(__v, __p); } return __make_iter(__p); @@ -1908,7 +1908,7 @@ const_pointer __xr = pointer_traits::pointer_to(__x); if (__p <= __xr && __xr < this->__end_) __xr += __old_n; - _VSTD::fill_n(__p, __n, *__xr); + std::fill_n(__p, __n, *__xr); } } else @@ -1947,7 +1947,7 @@ for (; this->__end_ != this->__end_cap() && __first != __last; ++__first) { __RAII_IncreaseAnnotator __annotator(*this); - __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), + __alloc_traits::construct(__a, std::__to_raw_pointer(this->__end_), *__first); ++this->__end_; __annotator.__done(); @@ -1974,7 +1974,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS } - __p = _VSTD::rotate(__p, __old_last, this->__end_); + __p = std::rotate(__p, __old_last, this->__end_); insert(__make_iter(__p), make_move_iterator(__v.begin()), make_move_iterator(__v.end())); return begin() + __off; @@ -1998,7 +1998,7 @@ " referring to this vector"); #endif pointer __p = this->__begin_ + (__position - begin()); - difference_type __n = _VSTD::distance(__first, __last); + difference_type __n = std::distance(__first, __last); if (__n > 0) { if (__n <= this->__end_cap() - this->__end_) @@ -2011,7 +2011,7 @@ { __m = __first; difference_type __diff = this->__end_ - __p; - _VSTD::advance(__m, __diff); + std::advance(__m, __diff); __construct_at_end(__m, __last, __n - __diff); __n = __dx; } @@ -2020,7 +2020,7 @@ __RAII_IncreaseAnnotator __annotator(*this, __n); __move_range(__p, __old_last, __p + __old_n); __annotator.__done(); - _VSTD::copy(__first, __m, __p); + std::copy(__first, __m, __p); } } else @@ -2070,9 +2070,9 @@ 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()); + std::swap(this->__begin_, __x.__begin_); + std::swap(this->__end_, __x.__end_); + std::swap(this->__end_cap(), __x.__end_cap()); __swap_allocator(this->__alloc(), __x.__alloc(), integral_constant()); #if _LIBCPP_DEBUG_LEVEL >= 2 @@ -2195,8 +2195,8 @@ typedef __bit_iterator const_pointer; typedef pointer iterator; typedef const_pointer const_iterator; - typedef _VSTD::reverse_iterator reverse_iterator; - typedef _VSTD::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; private: typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator; @@ -2389,7 +2389,7 @@ _LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args) #endif { - push_back ( value_type ( _VSTD::forward<_Args>(__args)... )); + push_back ( value_type ( std::forward<_Args>(__args)... )); #if _LIBCPP_STD_VER > 14 return this->back(); #endif @@ -2401,7 +2401,7 @@ #if _LIBCPP_STD_VER > 11 template _LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args) - { return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); } + { return insert ( position, value_type ( std::forward<_Args>(__args)... )); } #endif iterator insert(const_iterator __position, const value_type& __x); @@ -2442,7 +2442,7 @@ _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable::value); #endif - static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); } + static void swap(reference __x, reference __y) _NOEXCEPT { std::swap(__x, __y); } void resize(size_type __sz, value_type __x = false); void flip() _NOEXCEPT; @@ -2512,7 +2512,7 @@ void __move_assign_alloc(vector& __c, true_type) _NOEXCEPT_(is_nothrow_move_assignable::value) { - __alloc() = _VSTD::move(__c.__alloc()); + __alloc() = std::move(__c.__alloc()); } _LIBCPP_INLINE_VISIBILITY @@ -2592,7 +2592,7 @@ const size_type __cap = capacity(); if (__cap >= __ms / 2) return __ms; - return _VSTD::max(2*__cap, __align_it(__new_size)); + return std::max(2*__cap, __align_it(__new_size)); } // Default constructs __n objects starting at __end_ @@ -2613,7 +2613,7 @@ else this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0); } - _VSTD::fill_n(__make_iter(__old_size), __n, __x); + std::fill_n(__make_iter(__old_size), __n, __x); } template @@ -2626,7 +2626,7 @@ vector::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) { size_type __old_size = this->__size_; - this->__size_ += _VSTD::distance(__first, __last); + this->__size_ += std::distance(__first, __last); if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word)) { if (this->__size_ <= __bits_per_word) @@ -2634,7 +2634,7 @@ else this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0); } - _VSTD::copy(__first, __last, __make_iter(__old_size)); + std::copy(__first, __last, __make_iter(__old_size)); } template @@ -2777,7 +2777,7 @@ __size_(0), __cap_alloc_(0) { - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n > 0) { __vallocate(__n); @@ -2793,7 +2793,7 @@ __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) { - size_type __n = static_cast(_VSTD::distance(__first, __last)); + size_type __n = static_cast(std::distance(__first, __last)); if (__n > 0) { __vallocate(__n); @@ -2881,7 +2881,7 @@ __vdeallocate(); __vallocate(__v.__size_); } - _VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_); + std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_); } __size_ = __v.__size_; } @@ -2980,7 +2980,7 @@ __v.__size_ = __n; swap(__v); } - _VSTD::fill_n(begin(), __n, __x); + std::fill_n(begin(), __n, __x); } __invalidate_all_iterators(); } @@ -3010,7 +3010,7 @@ vector::assign(_ForwardIterator __first, _ForwardIterator __last) { clear(); - difference_type __ns = _VSTD::distance(__first, __last); + difference_type __ns = std::distance(__first, __last); _LIBCPP_ASSERT(__ns >= 0, "invalid range specified"); const size_t __n = static_cast(__ns); if (__n) @@ -3095,7 +3095,7 @@ { const_iterator __old_end = end(); ++__size_; - _VSTD::copy_backward(__position, __old_end, end()); + std::copy_backward(__position, __old_end, end()); __r = __const_iterator_cast(__position); } else @@ -3103,8 +3103,8 @@ 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()); + __r = std::copy(cbegin(), __position, __v.begin()); + std::copy_backward(__position, cend(), __v.end()); swap(__v); } *__r = __x; @@ -3121,7 +3121,7 @@ { const_iterator __old_end = end(); __size_ += __n; - _VSTD::copy_backward(__position, __old_end, end()); + std::copy_backward(__position, __old_end, end()); __r = __const_iterator_cast(__position); } else @@ -3129,11 +3129,11 @@ 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()); + __r = std::copy(cbegin(), __position, __v.begin()); + std::copy_backward(__position, cend(), __v.end()); swap(__v); } - _VSTD::fill_n(__r, __n, __x); + std::fill_n(__r, __n, __x); return __r; } @@ -3177,7 +3177,7 @@ } #endif // _LIBCPP_NO_EXCEPTIONS } - __p = _VSTD::rotate(__p, __old_end, end()); + __p = std::rotate(__p, __old_end, end()); insert(__p, __v.begin(), __v.end()); return begin() + __off; } @@ -3191,7 +3191,7 @@ >::type vector::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) { - const difference_type __n_signed = _VSTD::distance(__first, __last); + const difference_type __n_signed = std::distance(__first, __last); _LIBCPP_ASSERT(__n_signed >= 0, "invalid range specified"); const size_type __n = static_cast(__n_signed); iterator __r; @@ -3200,7 +3200,7 @@ { const_iterator __old_end = end(); __size_ += __n; - _VSTD::copy_backward(__position, __old_end, end()); + std::copy_backward(__position, __old_end, end()); __r = __const_iterator_cast(__position); } else @@ -3208,11 +3208,11 @@ 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()); + __r = std::copy(cbegin(), __position, __v.begin()); + std::copy_backward(__position, cend(), __v.end()); swap(__v); } - _VSTD::copy(__first, __last, __r); + std::copy(__first, __last, __r); return __r; } @@ -3222,7 +3222,7 @@ vector::erase(const_iterator __position) { iterator __r = __const_iterator_cast(__position); - _VSTD::copy(__position + 1, this->cend(), __r); + std::copy(__position + 1, this->cend(), __r); --__size_; return __r; } @@ -3233,7 +3233,7 @@ { iterator __r = __const_iterator_cast(__first); difference_type __d = __last - __first; - _VSTD::copy(__last, this->cend(), __r); + std::copy(__last, this->cend(), __r); __size_ -= __d; return __r; } @@ -3248,9 +3248,9 @@ __is_nothrow_swappable::value) #endif { - _VSTD::swap(this->__begin_, __x.__begin_); - _VSTD::swap(this->__size_, __x.__size_); - _VSTD::swap(this->__cap(), __x.__cap()); + std::swap(this->__begin_, __x.__begin_); + std::swap(this->__size_, __x.__size_); + std::swap(this->__cap(), __x.__cap()); __swap_allocator(this->__alloc(), __x.__alloc(), integral_constant()); } @@ -3275,10 +3275,10 @@ vector __v(__alloc()); __v.reserve(__recommend(__size_ + __n)); __v.__size_ = __size_ + __n; - __r = _VSTD::copy(cbegin(), cend(), __v.begin()); + __r = std::copy(cbegin(), cend(), __v.begin()); swap(__v); } - _VSTD::fill_n(__r, __n, __x); + std::fill_n(__r, __n, __x); } else __size_ = __sz; @@ -3356,7 +3356,7 @@ 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()); + return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } template @@ -3372,7 +3372,7 @@ bool operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) { - return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); + return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end()); } template Index: src/chrono.cpp =================================================================== --- src/chrono.cpp +++ src/chrono.cpp @@ -53,8 +53,8 @@ #if defined(_LIBCPP_WIN32API) // FILETIME is in 100ns units using filetime_duration = - _VSTD::chrono::duration<__int64, - _VSTD::ratio_multiply<_VSTD::ratio<100, 1>, + std::chrono::duration<__int64, + std::ratio_multiply, nanoseconds::period>>; // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970. Index: src/experimental/memory_resource.cpp =================================================================== --- src/experimental/memory_resource.cpp +++ src/experimental/memory_resource.cpp @@ -31,10 +31,10 @@ protected: virtual void* do_allocate(size_t __size, size_t __align) - { return _VSTD::__libcpp_allocate(__size, __align); /* FIXME */} + { return std::__libcpp_allocate(__size, __align); /* FIXME */} virtual void do_deallocate(void* __p, size_t __n, size_t __align) { - _VSTD::__libcpp_deallocate(__p, __n, __align); /* FIXME */ + std::__libcpp_deallocate(__p, __n, __align); /* FIXME */ } virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT @@ -109,11 +109,11 @@ if (set) { new_res = new_res ? new_res : new_delete_resource(); // TODO: Can a weaker ordering be used? - return _VSTD::atomic_exchange_explicit( + return std::atomic_exchange_explicit( &__res, new_res, memory_order::memory_order_acq_rel); } else { - return _VSTD::atomic_load_explicit( + return std::atomic_load_explicit( &__res, memory_order::memory_order_acquire); } #elif !defined(_LIBCPP_HAS_NO_THREADS) Index: src/ios.cpp =================================================================== --- src/ios.cpp +++ src/ios.cpp @@ -164,7 +164,7 @@ { // Precondition: __req_size > __current_cap const size_t mx = std::numeric_limits::max() / sizeof(_Tp); if (__req_size < mx/2) - return _VSTD::max(2 * __current_cap, __req_size); + return std::max(2 * __current_cap, __req_size); else return mx; } @@ -415,24 +415,24 @@ void ios_base::swap(ios_base& rhs) _NOEXCEPT { - _VSTD::swap(__fmtflags_, rhs.__fmtflags_); - _VSTD::swap(__precision_, rhs.__precision_); - _VSTD::swap(__width_, rhs.__width_); - _VSTD::swap(__rdstate_, rhs.__rdstate_); - _VSTD::swap(__exceptions_, rhs.__exceptions_); + std::swap(__fmtflags_, rhs.__fmtflags_); + std::swap(__precision_, rhs.__precision_); + std::swap(__width_, rhs.__width_); + std::swap(__rdstate_, rhs.__rdstate_); + std::swap(__exceptions_, rhs.__exceptions_); locale& lhs_loc = *reinterpret_cast(&__loc_); locale& rhs_loc = *reinterpret_cast(&rhs.__loc_); - _VSTD::swap(lhs_loc, rhs_loc); - _VSTD::swap(__fn_, rhs.__fn_); - _VSTD::swap(__index_, rhs.__index_); - _VSTD::swap(__event_size_, rhs.__event_size_); - _VSTD::swap(__event_cap_, rhs.__event_cap_); - _VSTD::swap(__iarray_, rhs.__iarray_); - _VSTD::swap(__iarray_size_, rhs.__iarray_size_); - _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_); - _VSTD::swap(__parray_, rhs.__parray_); - _VSTD::swap(__parray_size_, rhs.__parray_size_); - _VSTD::swap(__parray_cap_, rhs.__parray_cap_); + std::swap(lhs_loc, rhs_loc); + std::swap(__fn_, rhs.__fn_); + std::swap(__index_, rhs.__index_); + std::swap(__event_size_, rhs.__event_size_); + std::swap(__event_cap_, rhs.__event_cap_); + std::swap(__iarray_, rhs.__iarray_); + std::swap(__iarray_size_, rhs.__iarray_size_); + std::swap(__iarray_cap_, rhs.__iarray_cap_); + std::swap(__parray_, rhs.__parray_); + std::swap(__parray_size_, rhs.__parray_size_); + std::swap(__parray_cap_, rhs.__parray_cap_); } void Index: src/iostream.cpp =================================================================== --- src/iostream.cpp +++ src/iostream.cpp @@ -98,8 +98,8 @@ cin_ptr->tie(cout_ptr); wcin_ptr->tie(wcout_ptr); #endif - _VSTD::unitbuf(*cerr_ptr); - _VSTD::unitbuf(*wcerr_ptr); + std::unitbuf(*cerr_ptr); + std::unitbuf(*wcerr_ptr); #ifndef _LIBCPP_HAS_NO_STDOUT cerr_ptr->tie(cout_ptr); wcerr_ptr->tie(wcout_ptr); Index: src/locale.cpp =================================================================== --- src/locale.cpp +++ src/locale.cpp @@ -136,7 +136,7 @@ throw runtime_error(msg); #else (void)msg; - _VSTD::abort(); + std::abort(); #endif } @@ -197,10 +197,10 @@ name_("C") { facets_.clear(); - install(&make<_VSTD::collate >(1u)); - install(&make<_VSTD::collate >(1u)); - install(&make<_VSTD::ctype >(nullptr, false, 1u)); - install(&make<_VSTD::ctype >(1u)); + install(&make >(1u)); + install(&make >(1u)); + install(&make >(nullptr, false, 1u)); + install(&make >(1u)); install(&make >(1u)); install(&make >(1u)); install(&make >(1u)); @@ -223,8 +223,8 @@ install(&make >(1u)); install(&make >(1u)); install(&make >(1u)); - install(&make<_VSTD::messages >(1u)); - install(&make<_VSTD::messages >(1u)); + install(&make >(1u)); + install(&make >(1u)); } locale::__imp::__imp(const string& name, size_t refs) @@ -378,17 +378,17 @@ #endif // _LIBCPP_NO_EXCEPTIONS if (c & locale::collate) { - install_from<_VSTD::collate >(one); - install_from<_VSTD::collate >(one); + install_from >(one); + install_from >(one); } if (c & locale::ctype) { - install_from<_VSTD::ctype >(one); - install_from<_VSTD::ctype >(one); - install_from<_VSTD::codecvt >(one); - install_from<_VSTD::codecvt >(one); - install_from<_VSTD::codecvt >(one); - install_from<_VSTD::codecvt >(one); + install_from >(one); + install_from >(one); + install_from >(one); + install_from >(one); + install_from >(one); + install_from >(one); } if (c & locale::monetary) { @@ -419,8 +419,8 @@ } if (c & locale::messages) { - install_from<_VSTD::messages >(one); - install_from<_VSTD::messages >(one); + install_from >(one); + install_from >(one); } #ifndef _LIBCPP_NO_EXCEPTIONS } @@ -6096,7 +6096,7 @@ throw runtime_error(msg); #else (void)msg; - _VSTD::abort(); + std::abort(); #endif } Index: src/new.cpp =================================================================== --- src/new.cpp +++ src/new.cpp @@ -46,7 +46,7 @@ #ifndef _LIBCPP_NO_EXCEPTIONS throw bad_alloc(); #else - _VSTD::abort(); + std::abort(); #endif } Index: src/regex.cpp =================================================================== --- src/regex.cpp +++ src/regex.cpp @@ -229,7 +229,7 @@ __get_collation_name(const char* s) { const collationnames* i = - _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp()); + std::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp()); string r; if (i != end(collatenames) && strcmp(s, i->elem_) == 0) r = char(i->char_); @@ -240,7 +240,7 @@ __get_classname(const char* s, bool __icase) { const classnames* i = - _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp()); + std::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp()); regex_traits::char_class_type r = 0; if (i != end(ClassNames) && strcmp(s, i->elem_) == 0) { Index: src/string.cpp =================================================================== --- src/string.cpp +++ src/string.cpp @@ -37,7 +37,7 @@ throw T( msg ); #else fprintf(stderr, "%s\n", msg.c_str()); - _VSTD::abort(); + std::abort(); #endif } Index: src/strstream.cpp =================================================================== --- src/strstream.cpp +++ src/strstream.cpp @@ -118,10 +118,10 @@ strstreambuf::swap(strstreambuf& __rhs) { streambuf::swap(__rhs); - _VSTD::swap(__strmode_, __rhs.__strmode_); - _VSTD::swap(__alsize_, __rhs.__alsize_); - _VSTD::swap(__palloc_, __rhs.__palloc_); - _VSTD::swap(__pfree_, __rhs.__pfree_); + std::swap(__strmode_, __rhs.__strmode_); + std::swap(__alsize_, __rhs.__alsize_); + std::swap(__palloc_, __rhs.__palloc_); + std::swap(__pfree_, __rhs.__pfree_); } void @@ -276,7 +276,7 @@ { char* newpos = eback() + newoff; if (pos_in) - setg(eback(), newpos, _VSTD::max(newpos, egptr())); + setg(eback(), newpos, std::max(newpos, egptr())); if (pos_out) { // min(pbase, newpos), newpos, epptr() @@ -306,7 +306,7 @@ { char* newpos = eback() + newoff; if (pos_in) - setg(eback(), newpos, _VSTD::max(newpos, egptr())); + setg(eback(), newpos, std::max(newpos, egptr())); if (pos_out) { // min(pbase, newpos), newpos, epptr() Index: src/support/win32/thread_win32.cpp =================================================================== --- src/support/win32/thread_win32.cpp +++ src/support/win32/thread_win32.cpp @@ -113,7 +113,7 @@ int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m, timespec *__ts) { - using namespace _VSTD::chrono; + using namespace std::chrono; auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec); auto abstime = Index: src/system_error.cpp =================================================================== --- src/system_error.cpp +++ src/system_error.cpp @@ -289,7 +289,7 @@ #else (void)ev; (void)what_arg; - _VSTD::abort(); + std::abort(); #endif } Index: test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp =================================================================== --- test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp +++ test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp @@ -564,7 +564,7 @@ using T = NoExceptCallable; T value(true); auto ret = std::not_fn(value); - LIBCPP_STATIC_ASSERT(noexcept(!_VSTD::__invoke(value)), ""); + LIBCPP_STATIC_ASSERT(noexcept(!std::__invoke(value)), ""); #if TEST_STD_VER > 14 static_assert(noexcept(!std::invoke(value)), ""); #endif