Lines Matching full:__base
1167 typedef __deque_base<value_type, allocator_type> __base;
1169 typedef typename __base::__alloc_traits __alloc_traits;
1170 typedef typename __base::reference reference;
1171 typedef typename __base::const_reference const_reference;
1172 typedef typename __base::iterator iterator;
1173 typedef typename __base::const_iterator const_iterator;
1174 typedef typename __base::size_type size_type;
1175 typedef typename __base::difference_type difference_type;
1177 typedef typename __base::pointer pointer;
1178 typedef typename __base::const_pointer const_pointer;
1187 _LIBCPP_INLINE_VISIBILITY explicit deque(const allocator_type& __a) : __base(__a) {}
1214 deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
1239 iterator begin() _NOEXCEPT {return __base::begin();}
1241 const_iterator begin() const _NOEXCEPT {return __base::begin();}
1243 iterator end() _NOEXCEPT {return __base::end();}
1245 const_iterator end() const _NOEXCEPT {return __base::end();}
1249 {return reverse_iterator(__base::end());}
1252 {return const_reverse_iterator(__base::end());}
1255 {return reverse_iterator(__base::begin());}
1258 {return const_reverse_iterator(__base::begin());}
1262 {return __base::begin();}
1265 {return __base::end();}
1268 {return const_reverse_iterator(__base::end());}
1271 {return const_reverse_iterator(__base::begin());}
1275 size_type size() const _NOEXCEPT {return __base::size();}
1278 {return __alloc_traits::max_size(__base::__alloc());}
1283 bool empty() const _NOEXCEPT {return __base::size() == 0;}
1341 bool __invariants() const {return __base::__invariants();}
1343 typedef typename __base::__map_const_pointer __map_const_pointer;
1348 return __n / __base::__block_size + (__n % __base::__block_size != 0);
1353 return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
1358 return __base::__start_;
1363 return __capacity() - (__base::__start_ + __base::size());
1397 if (__base::__alloc() != __c.__alloc())
1402 __base::__alloc() = __c.__alloc();
1403 __base::__map_.__alloc() = __c.__map_.__alloc();
1425 : __base(__a)
1441 : __base(__a)
1459 : __base(__a)
1466 : __base(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))
1473 : __base(__a)
1488 : __base(__a)
1512 _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
1513 : __base(_VSTD::move(__c))
1520 : __base(_VSTD::move(__c), __a)
1545 if (__base::__alloc() != __c.__alloc())
1561 __base::__move_assign(__c);
1573 iterator __i = __base::begin();
1574 iterator __e = __base::end();
1589 if (static_cast<size_type>(__l - __f) > __base::size())
1591 _RAIter __m = __f + __base::size();
1592 _VSTD::copy(__f, __m, __base::begin());
1596 __erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
1603 if (__n > __base::size())
1605 _VSTD::fill_n(__base::begin(), __base::size(), __v);
1606 __n -= __base::size();
1610 __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
1618 return __base::__alloc();
1625 if (__n > __base::size())
1626 __append(__n - __base::size());
1627 else if (__n < __base::size())
1628 __erase_to_end(__base::begin() + __n);
1635 if (__n > __base::size())
1636 __append(__n - __base::size(), __v);
1637 else if (__n < __base::size())
1638 __erase_to_end(__base::begin() + __n);
1645 allocator_type& __a = __base::__alloc();
1648 while (__base::__map_.size() > 0)
1650 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
1651 __base::__map_.pop_back();
1653 __base::__start_ = 0;
1657 if (__front_spare() >= __base::__block_size)
1659 __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
1660 __base::__map_.pop_front();
1661 __base::__start_ -= __base::__block_size;
1663 if (__back_spare() >= __base::__block_size)
1665 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
1666 __base::__map_.pop_back();
1669 __base::__map_.shrink_to_fit();
1677 size_type __p = __base::__start_ + __i;
1678 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1686 size_type __p = __base::__start_ + __i;
1687 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1695 if (__i >= __base::size())
1696 __base::__throw_out_of_range();
1697 size_type __p = __base::__start_ + __i;
1698 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1706 if (__i >= __base::size())
1707 __base::__throw_out_of_range();
1708 size_type __p = __base::__start_ + __i;
1709 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1717 return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
1718 + __base::__start_ % __base::__block_size);
1726 return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
1727 + __base::__start_ % __base::__block_size);
1735 size_type __p = __base::size() + __base::__start_ - 1;
1736 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1744 size_type __p = __base::size() + __base::__start_ - 1;
1745 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1752 allocator_type& __a = __base::__alloc();
1756 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
1757 ++__base::size();
1766 allocator_type& __a = __base::__alloc();
1770 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
1771 ++__base::size();
1781 allocator_type& __a = __base::__alloc();
1785 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
1786 ++__base::size();
1796 allocator_type& __a = __base::__alloc();
1800 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
1801 --__base::__start_;
1802 ++__base::size();
1811 allocator_type& __a = __base::__alloc();
1815 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
1816 --__base::__start_;
1817 ++__base::size();
1827 allocator_type& __a = __base::__alloc();
1831 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
1832 --__base::__start_;
1833 ++__base::size();
1843 size_type __pos = __p - __base::begin();
1844 size_type __to_end = __base::size() - __pos;
1845 allocator_type& __a = __base::__alloc();
1853 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
1854 --__base::__start_;
1855 ++__base::size();
1860 iterator __b = __base::begin();
1865 --__base::__start_;
1866 ++__base::size();
1877 size_type __de = __base::size() - __pos;
1880 __base::end()), __v);
1881 ++__base::size();
1886 iterator __e = __base::end();
1891 ++__base::size();
1897 return __base::begin() + __pos;
1906 size_type __pos = __p - __base::begin();
1907 size_type __to_end = __base::size() - __pos;
1908 allocator_type& __a = __base::__alloc();
1916 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
1917 --__base::__start_;
1918 ++__base::size();
1922 iterator __b = __base::begin();
1925 --__base::__start_;
1926 ++__base::size();
1937 size_type __de = __base::size() - __pos;
1940 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
1941 ++__base::size();
1945 iterator __e = __base::end();
1948 ++__base::size();
1954 return __base::begin() + __pos;
1964 size_type __pos = __p - __base::begin();
1965 size_type __to_end = __base::size() - __pos;
1966 allocator_type& __a = __base::__alloc();
1974 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
1975 --__base::__start_;
1976 ++__base::size();
1981 iterator __b = __base::begin();
1984 --__base::__start_;
1985 ++__base::size();
1996 size_type __de = __base::size() - __pos;
1999 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
2000 ++__base::size();
2005 iterator __e = __base::end();
2008 ++__base::size();
2014 return __base::begin() + __pos;
2024 size_type __pos = __p - __base::begin();
2025 size_type __to_end = __base::size() - __pos;
2026 allocator_type& __a = __base::__alloc();
2032 iterator __old_begin = __base::begin();
2036 for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
2056 iterator __old_end = __base::end();
2058 size_type __de = __base::size() - __pos;
2061 for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
2075 return __base::begin() + __pos;
2085 __split_buffer<value_type, allocator_type&> __buf(__base::__alloc());
2099 __split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());
2112 size_type __pos = __p - __base::begin();
2113 size_type __to_end = __base::size() - __pos;
2114 allocator_type& __a = __base::__alloc();
2120 iterator __old_begin = __base::begin();
2126 for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
2136 --__base::__start_;
2137 ++__base::size();
2150 iterator __old_end = __base::end();
2153 size_type __de = __base::size() - __pos;
2157 for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size())
2164 for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
2171 return __base::begin() + __pos;
2192 allocator_type& __a = __base::__alloc();
2197 for (iterator __i = __base::end(); __f != __l; ++__i, (void) ++__f, ++__base::size())
2205 allocator_type& __a = __base::__alloc();
2210 for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
2218 allocator_type& __a = __base::__alloc();
2223 for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
2233 allocator_type& __a = __base::__alloc();
2234 if (__back_spare() >= __base::__block_size)
2236 __base::__start_ += __base::__block_size;
2237 pointer __pt = __base::__map_.back();
2238 __base::__map_.pop_back();
2239 __base::__map_.push_front(__pt);
2241 // Else if __base::__map_.size() < __base::__map_.capacity() then we need to allocate 1 buffer
2242 else if (__base::__map_.size() < __base::__map_.capacity())
2246 if (__base::__map_.__front_spare() > 0)
2247 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2250 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2252 pointer __pt = __base::__map_.back();
2253 __base::__map_.pop_back();
2254 __base::__map_.push_front(__pt);
2256 __base::__start_ = __base::__map_.size() == 1 ?
2257 __base::__block_size / 2 :
2258 __base::__start_ + __base::__block_size;
2263 __split_buffer<pointer, typename __base::__pointer_allocator&>
2264 __buf(max<size_type>(2 * __base::__map_.capacity(), 1),
2265 0, __base::__map_.__alloc());
2269 __alloc_traits::allocate(__a, __base::__block_size),
2270 _Dp(__a, __base::__block_size));
2274 for (typename __base::__map_pointer __i = __base::__map_.begin();
2275 __i != __base::__map_.end(); ++__i)
2277 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2278 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2279 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2280 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2281 __base::__start_ = __base::__map_.size() == 1 ?
2282 __base::__block_size / 2 :
2283 __base::__start_ + __base::__block_size;
2293 allocator_type& __a = __base::__alloc();
2294 size_type __nb = __recommend_blocks(__n + __base
2296 size_type __back_capacity = __back_spare() / __base::__block_size;
2302 __base::__start_ += __base::__block_size * __back_capacity;
2305 pointer __pt = __base::__map_.back();
2306 __base::__map_.pop_back();
2307 __base::__map_.push_front(__pt);
2311 else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
2315 for (; __nb > 0; --__nb, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1))
2317 if (__base::__map_.__front_spare() == 0)
2319 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2322 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2324 __base::__start_ += __back_capacity * __base::__block_size;
2327 pointer __pt = __base::__map_.back();
2328 __base::__map_.pop_back();
2329 __base::__map_.push_front(__pt);
2335 size_type __ds = (__nb + __back_capacity) * __base::__block_size - __base::__map_.empty();
2336 __split_buffer<pointer, typename __base::__pointer_allocator&>
2337 __buf(max<size_type>(2* __base::__map_.capacity(),
2338 __nb + __base::__map_.size()),
2339 0, __base::__map_.__alloc());
2345 __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2350 for (typename __base::__map_pointer __i = __buf.begin();
2352 __alloc_traits::deallocate(__a, *__i, __base::__block_size);
2358 __buf.push_back(__base::__map_.back());
2359 __base::__map_.pop_back();
2361 for (typename __base::__map_pointer __i = __base::__map_.begin();
2362 __i != __base::__map_.end(); ++__i)
2364 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2365 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2366 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2367 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2368 __base::__start_ += __ds;
2378 allocator_type& __a = __base::__alloc();
2379 if (__front_spare() >= __base::__block_size)
2381 __base::__start_ -= __base::__block_size;
2382 pointer __pt = __base::__map_.front();
2383 __base::__map_.pop_front();
2384 __base::__map_.push_back(__pt);
2387 else if (__base::__map_.size() < __base::__map_.capacity())
2391 if (__base::__map_.__back_spare() != 0)
2392 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2395 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2397 pointer __pt = __base::__map_.front();
2398 __base::__map_.pop_front();
2399 __base::__map_.push_back(__pt);
2405 __split_buffer<pointer, typename __base::__pointer_allocator&>
2406 __buf(max<size_type>(2* __base::__map_.capacity(), 1),
2407 __base::__map_.size(),
2408 __base::__map_.__alloc());
2412 __alloc_traits::allocate(__a, __base::__block_size),
2413 _Dp(__a, __base::__block_size));
2417 for (typename __base::__map_pointer __i = __base::__map_.end();
2418 __i != __base::__map_.begin();)
2420 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2421 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2422 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2423 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2433 allocator_type& __a = __base::__alloc();
2434 size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
2436 size_type __front_capacity = __front_spare() / __base::__block_size;
2442 __base::__start_ -= __base::__block_size * __front_capacity;
2445 pointer __pt = __base::__map_.front();
2446 __base::__map_.pop_front();
2447 __base::__map_.push_back(__pt);
2451 else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
2457 if (__base::__map_.__back_spare() == 0)
2459 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2461 for (; __nb > 0; --__nb, ++__front_capacity, __base::__start_ +=
2462 __base::__block_size - (__base::__map_.size() == 1))
2463 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2465 __base::__start_ -= __base::__block_size * __front_capacity;
2468 pointer __pt = __base::__map_.front();
2469 __base::__map_.pop_front();
2470 __base::__map_.push_back(__pt);
2476 size_type __ds = __front_capacity * __base::__block_size;
2477 __split_buffer<pointer, typename __base::__pointer_allocator&>
2478 __buf(max<size_type>(2* __base::__map_.capacity(),
2479 __nb + __base::__map_.size()),
2480 __base::__map_.size() - __front_capacity,
2481 __base::__map_.__alloc());
2487 __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2492 for (typename __base::__map_pointer __i = __buf.begin();
2494 __alloc_traits::deallocate(__a, *__i, __base::__block_size);
2500 __buf.push_back(__base::__map_.front());
2501 __base::__map_.pop_front();
2503 for (typename __base::__map_pointer __i = __base::__map_.end();
2504 __i != __base::__map_.begin();)
2506 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2507 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2508 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2509 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2510 __base::__start_ -= __ds;
2518 allocator_type& __a = __base::__alloc();
2519 __alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
2520 __base::__start_ / __base::__block_size) +
2521 __base::__start_ % __base::__block_size));
2522 --__base::size();
2523 if (++__base::__start_ >= 2 * __base::__block_size)
2525 __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2526 __base::__map_.pop_front();
2527 __base::__start_ -= __base::__block_size;
2535 allocator_type& __a = __base::__alloc();
2536 size_type __p = __base::size() + __base::__start_ - 1;
2537 __alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
2538 __p / __base::__block_size) +
2539 __p % __base::__block_size));
2540 --__base::size();
2541 if (__back_spare() >= 2 * __base::__block_size)
2543 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2544 __base::__map_.pop_back();
2562 pointer __fe = *__f.__m_iter_ + __base::__block_size;
2616 allocator_type& __a = __base::__alloc();
2618 // for (; __f != __l; ++__r, ++__f, ++__base::size())
2624 pointer __fe = *__f.__m_iter_ + __base::__block_size;
2633 for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
2647 allocator_type& __a = __base::__alloc();
2652 // --__base::__start_;
2653 // ++__base::size();
2672 --__base::__start_;
2673 ++__base::size();
2684 iterator __b = __base::begin();
2687 allocator_type& __a = __base::__alloc();
2688 if (__pos <= (__base::size() - 1) / 2)
2692 --__base::size();
2693 ++__base::__start_;
2694 if (__front_spare() >= 2 * __base::__block_size)
2696 __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2697 __base::__map_.pop_front();
2698 __base::__start_ -= __base::__block_size;
2703 iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
2705 --__base::size();
2706 __base::__block_size)
2708 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2709 __base::__map_.pop_back();
2712 return __base::begin() + __pos;
2720 iterator __b = __base::begin();
2725 allocator_type& __a = __base::__alloc();
2726 if (__pos <= (__base::size() - __n) / 2)
2731 __base::size() -= __n;
2732 __base::__start_ += __n;
2733 while (__front_spare() >= 2 * __base::__block_size)
2735 __alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
2736 __base::__map_.pop_front();
2737 __base::__start_ -= __base::__block_size;
2742 iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
2743 for (iterator __e = __base::end(); __i != __e; ++__i)
2745 __base::size() -= __n;
2746 while (__back_spare() >= 2 * __base::__block_size)
2748 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2749 __base::__map_.pop_back();
2753 return __base::begin() + __pos;
2760 iterator __e = __base::end();
2764 allocator_type& __a = __base::__alloc();
2765 iterator __b = __base::begin();
2769 __base::size() -= __n;
2770 while (__back_spare() >= 2 * __base::__block_size)
2772 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
2773 __base::__map_.pop_back();
2789 __base::swap(__c);
2797 __base::clear();
