Lines Matching refs:__base
1292 typedef __deque_base<value_type, allocator_type> __base;
1294 typedef typename __base::__alloc_traits __alloc_traits;
1295 typedef typename __base::reference reference;
1296 typedef typename __base::const_reference const_reference;
1297 typedef typename __base::iterator iterator;
1298 typedef typename __base::const_iterator const_iterator;
1299 typedef typename __base::size_type size_type;
1300 typedef typename __base::difference_type difference_type;
1302 typedef typename __base::pointer pointer;
1303 typedef typename __base::const_pointer const_pointer;
1307 using typename __base::__deque_range;
1308 using typename __base::__deque_block_range;
1309 using typename __base::_ConstructTransaction;
1316 _LIBCPP_INLINE_VISIBILITY explicit deque(const allocator_type& __a) : __base(__a) {}
1324 deque(size_type __n, const value_type& __v, const allocator_type& __a) : __base(__a)
1349 deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
1376 iterator begin() _NOEXCEPT {return __base::begin();}
1378 const_iterator begin() const _NOEXCEPT {return __base::begin();}
1380 iterator end() _NOEXCEPT {return __base::end();}
1382 const_iterator end() const _NOEXCEPT {return __base::end();}
1386 {return reverse_iterator(__base::end());}
1389 {return const_reverse_iterator(__base::end());}
1392 {return reverse_iterator(__base::begin());}
1395 {return const_reverse_iterator(__base::begin());}
1399 {return __base::begin();}
1402 {return __base::end();}
1405 {return const_reverse_iterator(__base::end());}
1408 {return const_reverse_iterator(__base::begin());}
1412 size_type size() const _NOEXCEPT {return __base::size();}
1416 __alloc_traits::max_size(__base::__alloc()),
1422 bool empty() const _NOEXCEPT {return __base::size() == 0;}
1492 bool __invariants() const {return __base::__invariants();}
1494 typedef typename __base::__map_const_pointer __map_const_pointer;
1499 return __n / __base::__block_size + (__n % __base::__block_size != 0);
1504 return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
1509 return __base::__map_.size();
1515 return __base::__start_;
1519 return __front_spare() / __base::__block_size;
1524 return __capacity() - (__base::__start_ + __base::size());
1528 return __back_spare() / __base::__block_size;
1535 __alloc_traits::deallocate(__base::__alloc(), __base::__map_.front(),
1536 __base::__block_size);
1537 __base::__map_.pop_front();
1538 __base::__start_ -= __base::__block_size;
1547 __alloc_traits::deallocate(__base::__alloc(), __base::__map_.back(),
1548 __base::__block_size);
1549 __base::__map_.pop_back();
1585 if (__base::__alloc() != __c.__alloc())
1590 __base::__alloc() = __c.__alloc();
1591 __base::__map_.__alloc() = __c.__map_.__alloc();
1631 : __base(__a)
1657 : __base(__a)
1664 : __base(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))
1671 : __base(__a)
1698 : __base(__a)
1706 _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
1707 : __base(_VSTD::move(__c))
1714 : __base(_VSTD::move(__c), __a)
1739 if (__base::__alloc() != __c.__alloc())
1755 __base::__move_assign(__c);
1767 iterator __i = __base::begin();
1768 iterator __e = __base::end();
1783 if (static_cast<size_type>(__l - __f) > __base::size())
1785 _RAIter __m = __f + __base::size();
1786 _VSTD::copy(__f, __m, __base::begin());
1790 __erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
1797 if (__n > __base::size())
1799 _VSTD::fill_n(__base::begin(), __base::size(), __v);
1800 __n -= __base::size();
1804 __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
1812 return __base::__alloc();
1819 if (__n > __base::size())
1820 __append(__n - __base::size());
1821 else if (__n < __base::size())
1822 __erase_to_end(__base::begin() + __n);
1829 if (__n > __base::size())
1830 __append(__n - __base::size(), __v);
1831 else if (__n < __base::size())
1832 __erase_to_end(__base::begin() + __n);
1839 allocator_type& __a = __base::__alloc();
1842 while (__base::__map_.size() > 0)
1844 __alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
1845 __base::__map_.pop_back();
1847 __base::__start_ = 0;
1854 __base::__map_.shrink_to_fit();
1862 size_type __p = __base::__start_ + __i;
1863 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1871 size_type __p = __base::__start_ + __i;
1872 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1880 if (__i >= __base::size())
1882 size_type __p = __base::__start_ + __i;
1883 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1891 if (__i >= __base::size())
1893 size_type __p = __base::__start_ + __i;
1894 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1902 return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
1903 + __base::__start_ % __base::__block_size);
1911 return *(*(__base::__map_.begin() + __base::__start_ / __base::__block_size)
1912 + __base::__start_ % __base::__block_size);
1920 size_type __p = __base::size() + __base::__start_ - 1;
1921 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1929 size_type __p = __base::size() + __base::__start_ - 1;
1930 return *(*(__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
1937 allocator_type& __a = __base::__alloc();
1941 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
1942 ++__base::size();
1949 allocator_type& __a = __base::__alloc();
1953 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
1954 --__base::__start_;
1955 ++__base::size();
1963 allocator_type& __a = __base::__alloc();
1967 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
1968 ++__base::size();
1980 allocator_type& __a = __base::__alloc();
1984 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()),
1986 ++__base::size();
1988 return *--__base::end();
1996 allocator_type& __a = __base::__alloc();
2000 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
2001 --__base::__start_;
2002 ++__base::size();
2015 allocator_type& __a = __base::__alloc();
2019 …__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)…
2020 --__base::__start_;
2021 ++__base::size();
2023 return *__base::begin();
2031 size_type __pos = __p - __base::begin();
2032 size_type __to_end = __base::size() - __pos;
2033 allocator_type& __a = __base::__alloc();
2041 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
2042 --__base::__start_;
2043 ++__base::size();
2047 iterator __b = __base::begin();
2050 --__base::__start_;
2051 ++__base::size();
2062 size_type __de = __base::size() - __pos;
2065 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
2066 ++__base::size();
2070 iterator __e = __base::end();
2073 ++__base::size();
2079 return __base::begin() + __pos;
2087 size_type __pos = __p - __base::begin();
2088 size_type __to_end = __base::size() - __pos;
2089 allocator_type& __a = __base::__alloc();
2097 …__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)…
2098 --__base::__start_;
2099 ++__base::size();
2104 iterator __b = __base::begin();
2107 --__base::__start_;
2108 ++__base::size();
2119 size_type __de = __base::size() - __pos;
2122 …__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
2123 ++__base::size();
2128 iterator __e = __base::end();
2131 ++__base::size();
2137 return __base::begin() + __pos;
2147 size_type __pos = __p - __base::begin();
2148 size_type __to_end = __base::size() - __pos;
2149 allocator_type& __a = __base::__alloc();
2157 __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
2158 --__base::__start_;
2159 ++__base::size();
2164 iterator __b = __base::begin();
2169 --__base::__start_;
2170 ++__base::size();
2181 size_type __de = __base::size() - __pos;
2184 __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
2185 ++__base::size();
2190 iterator __e = __base::end();
2195 ++__base::size();
2201 return __base::begin() + __pos;
2208 size_type __pos = __p - __base::begin();
2209 size_type __to_end = __base::size() - __pos;
2210 allocator_type& __a = __base::__alloc();
2216 iterator __old_begin = __base::begin();
2220 for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
2240 iterator __old_end = __base::end();
2242 size_type __de = __base::size() - __pos;
2245 for (size_type __m = __n - __de; __m; --__m, (void) ++__i, ++__base::size())
2259 return __base::begin() + __pos;
2268 __split_buffer<value_type, allocator_type&> __buf(__base::__alloc());
2281 __split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());
2294 size_type __pos = __p - __base::begin();
2295 size_type __to_end = __base::size() - __pos;
2296 allocator_type& __a = __base::__alloc();
2302 iterator __old_begin = __base::begin();
2308 for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
2318 --__base::__start_;
2319 ++__base::size();
2332 iterator __old_end = __base::end();
2335 size_type __de = __base::size() - __pos;
2339 for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size())
2346 for (iterator __j = __oen; __j != __old_end; ++__i, (void) ++__j, ++__base::size())
2353 return __base::begin() + __pos;
2377 allocator_type& __a = __base::__alloc();
2382 for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2394 allocator_type& __a = __base::__alloc();
2399 for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2411 allocator_type& __a = __base::__alloc();
2416 for (__deque_block_range __br : __deque_range(__base::end(), __base::end() + __n)) {
2431 allocator_type& __a = __base::__alloc();
2432 if (__back_spare() >= __base::__block_size)
2434 __base::__start_ += __base::__block_size;
2435 pointer __pt = __base::__map_.back();
2436 __base::__map_.pop_back();
2437 __base::__map_.push_front(__pt);
2439 // Else if __base::__map_.size() < __base::__map_.capacity() then we need to allocate 1 buffer
2440 else if (__base::__map_.size() < __base::__map_.capacity())
2444 if (__base::__map_.__front_spare() > 0)
2445 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2448 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2450 pointer __pt = __base::__map_.back();
2451 __base::__map_.pop_back();
2452 __base::__map_.push_front(__pt);
2454 __base::__start_ = __base::__map_.size() == 1 ?
2455 __base::__block_size / 2 :
2456 __base::__start_ + __base::__block_size;
2461 __split_buffer<pointer, typename __base::__pointer_allocator&>
2462 __buf(max<size_type>(2 * __base::__map_.capacity(), 1),
2463 0, __base::__map_.__alloc());
2467 __alloc_traits::allocate(__a, __base::__block_size),
2468 _Dp(__a, __base::__block_size));
2472 for (typename __base::__map_pointer __i = __base::__map_.begin();
2473 __i != __base::__map_.end(); ++__i)
2475 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2476 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2477 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2478 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2479 __base::__start_ = __base::__map_.size() == 1 ?
2480 __base::__block_size / 2 :
2481 __base::__start_ + __base::__block_size;
2491 allocator_type& __a = __base::__alloc();
2492 size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
2494 size_type __back_capacity = __back_spare() / __base::__block_size;
2500 __base::__start_ += __base::__block_size * __back_capacity;
2503 pointer __pt = __base::__map_.back();
2504 __base::__map_.pop_back();
2505 __base::__map_.push_front(__pt);
2509 else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
2513 … for (; __nb > 0; --__nb, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1))
2515 if (__base::__map_.__front_spare() == 0)
2517 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2520 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2522 __base::__start_ += __back_capacity * __base::__block_size;
2525 pointer __pt = __base::__map_.back();
2526 __base::__map_.pop_back();
2527 __base::__map_.push_front(__pt);
2533 size_type __ds = (__nb + __back_capacity) * __base::__block_size - __base::__map_.empty();
2534 __split_buffer<pointer, typename __base::__pointer_allocator&>
2535 __buf(max<size_type>(2* __base::__map_.capacity(),
2536 __nb + __base::__map_.size()),
2537 0, __base::__map_.__alloc());
2543 __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2548 for (typename __base::__map_pointer __i = __buf.begin();
2550 __alloc_traits::deallocate(__a, *__i, __base::__block_size);
2556 __buf.push_back(__base::__map_.back());
2557 __base::__map_.pop_back();
2559 for (typename __base::__map_pointer __i = __base::__map_.begin();
2560 __i != __base::__map_.end(); ++__i)
2562 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2563 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2564 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2565 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2566 __base::__start_ += __ds;
2576 allocator_type& __a = __base::__alloc();
2577 if (__front_spare() >= __base::__block_size)
2579 __base::__start_ -= __base::__block_size;
2580 pointer __pt = __base::__map_.front();
2581 __base::__map_.pop_front();
2582 __base::__map_.push_back(__pt);
2585 else if (__base::__map_.size() < __base::__map_.capacity())
2589 if (__base::__map_.__back_spare() != 0)
2590 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2593 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2595 pointer __pt = __base::__map_.front();
2596 __base::__map_.pop_front();
2597 __base::__map_.push_back(__pt);
2603 __split_buffer<pointer, typename __base::__pointer_allocator&>
2604 __buf(max<size_type>(2* __base::__map_.capacity(), 1),
2605 __base::__map_.size(),
2606 __base::__map_.__alloc());
2610 __alloc_traits::allocate(__a, __base::__block_size),
2611 _Dp(__a, __base::__block_size));
2615 for (typename __base::__map_pointer __i = __base::__map_.end();
2616 __i != __base::__map_.begin();)
2618 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2619 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2620 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2621 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2631 allocator_type& __a = __base::__alloc();
2632 size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
2634 size_type __front_capacity = __front_spare() / __base::__block_size;
2640 __base::__start_ -= __base::__block_size * __front_capacity;
2643 pointer __pt = __base::__map_.front();
2644 __base::__map_.pop_front();
2645 __base::__map_.push_back(__pt);
2649 else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
2655 if (__base::__map_.__back_spare() == 0)
2657 __base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2659 for (; __nb > 0; --__nb, ++__front_capacity, __base::__start_ +=
2660 __base::__block_size - (__base::__map_.size() == 1))
2661 __base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
2663 __base::__start_ -= __base::__block_size * __front_capacity;
2666 pointer __pt = __base::__map_.front();
2667 __base::__map_.pop_front();
2668 __base::__map_.push_back(__pt);
2674 size_type __ds = __front_capacity * __base::__block_size;
2675 __split_buffer<pointer, typename __base::__pointer_allocator&>
2676 __buf(max<size_type>(2* __base::__map_.capacity(),
2677 __nb + __base::__map_.size()),
2678 __base::__map_.size() - __front_capacity,
2679 __base::__map_.__alloc());
2685 __buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
2690 for (typename __base::__map_pointer __i = __buf.begin();
2692 __alloc_traits::deallocate(__a, *__i, __base::__block_size);
2698 __buf.push_back(__base::__map_.front());
2699 __base::__map_.pop_front();
2701 for (typename __base::__map_pointer __i = __base::__map_.end();
2702 __i != __base::__map_.begin();)
2704 _VSTD::swap(__base::__map_.__first_, __buf.__first_);
2705 _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
2706 _VSTD::swap(__base::__map_.__end_, __buf.__end_);
2707 _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
2708 __base::__start_ -= __ds;
2716 allocator_type& __a = __base::__alloc();
2717 __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
2718 __base::__start_ / __base::__block_size) +
2719 __base::__start_ % __base::__block_size));
2720 --__base::size();
2721 ++__base::__start_;
2730 allocator_type& __a = __base::__alloc();
2731 size_type __p = __base::size() + __base::__start_ - 1;
2732 __alloc_traits::destroy(__a, _VSTD::__to_address(*(__base::__map_.begin() +
2733 __p / __base::__block_size) +
2734 __p % __base::__block_size));
2735 --__base::size();
2753 pointer __fe = *__f.__m_iter_ + __base::__block_size;
2807 allocator_type& __a = __base::__alloc();
2809 // for (; __f != __l; ++__r, ++__f, ++__base::size())
2815 pointer __fe = *__f.__m_iter_ + __base::__block_size;
2824 for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
2838 allocator_type& __a = __base::__alloc();
2843 // --__base::__start_;
2844 // ++__base::size();
2863 --__base::__start_;
2864 ++__base::size();
2875 iterator __b = __base::begin();
2878 allocator_type& __a = __base::__alloc();
2879 if (static_cast<size_t>(__pos) <= (__base::size() - 1) / 2)
2883 --__base::size();
2884 ++__base::__start_;
2889 iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
2891 --__base::size();
2894 return __base::begin() + __pos;
2902 iterator __b = __base::begin();
2907 allocator_type& __a = __base::__alloc();
2908 if (static_cast<size_t>(__pos) <= (__base::size() - __n) / 2)
2913 __base::size() -= __n;
2914 __base::__start_ += __n;
2920 iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
2921 for (iterator __e = __base::end(); __i != __e; ++__i)
2923 __base::size() -= __n;
2928 return __base::begin() + __pos;
2935 iterator __e = __base::end();
2939 allocator_type& __a = __base::__alloc();
2940 iterator __b = __base::begin();
2944 __base::size() -= __n;
2961 __base::swap(__c);
2969 __base::clear();