stl_bvector.h

来自「symbian上STL模板库的实现」· C头文件 代码 · 共 877 行 · 第 1/3 页

                const_reference at(size_type __n) const
                { _M_range_check(__n); return (*this)[__n]; }

                explicit vector(const allocator_type& __a = allocator_type())
                    : _Bvector_base<_Alloc>(__a) { }

                vector(size_type __n, bool __value, 
                        const allocator_type& __a = allocator_type())
                    : _Bvector_base<_Alloc>(__a)
                {
                    _M_initialize(__n);
                    std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, 
                            __value ? ~0 : 0);
                }

                explicit vector(size_type __n)
                    : _Bvector_base<_Alloc>(allocator_type())
                {
                    _M_initialize(__n);
                    std::fill(this->_M_impl._M_start._M_p, 
                            this->_M_impl._M_end_of_storage, 0);
                }

                vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
            {
                _M_initialize(__x.size());
                std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
            }

                // Check whether it's an integral type.  If so, it's not an iterator.
                template<class _Integer>
                    void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
                    {
                        _M_initialize(__n);
                        std::fill(this->_M_impl._M_start._M_p, 
                                this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
                    }

                template<class _InputIterator>
                    void 
                    _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
                            __false_type)
                    { _M_initialize_range(__first, __last, 
                            std::__iterator_category(__first)); }

                template<class _InputIterator>
                    vector(_InputIterator __first, _InputIterator __last,
                            const allocator_type& __a = allocator_type())
                    : _Bvector_base<_Alloc>(__a)
                    {
                        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
                        _M_initialize_dispatch(__first, __last, _Integral());
                    }

                ~vector() { }

                vector& operator=(const vector& __x)
                {
                    if (&__x == this)
                        return *this;
                    if (__x.size() > capacity())
                    {
                        this->_M_deallocate();
                        _M_initialize(__x.size());
                    }
                    std::copy(__x.begin(), __x.end(), begin());
                    this->_M_impl._M_finish = begin() + difference_type(__x.size());
                    return *this;
                }

                // assign(), a generalized assignment member function.  Two
                // versions: one that takes a count, and one that takes a range.
                // The range version is a member template, so we dispatch on whether
                // or not the type is an integer.

                void _M_fill_assign(size_t __n, bool __x)
                {
                    if (__n > size())
                    {
                        std::fill(this->_M_impl._M_start._M_p, 
                                this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
                        insert(end(), __n - size(), __x);
                    }
                    else
                    {
                        erase(begin() + __n, end());
                        std::fill(this->_M_impl._M_start._M_p, 
                                this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
                    }
                }

                void assign(size_t __n, bool __x)
                { _M_fill_assign(__n, __x); }

                template<class _InputIterator>
                    void assign(_InputIterator __first, _InputIterator __last)
                    {
                        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
                        _M_assign_dispatch(__first, __last, _Integral());
                    }

                template<class _Integer>
                    void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
                    { _M_fill_assign((size_t) __n, (bool) __val); }

                template<class _InputIterator>
                    void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
                            __false_type)
                    { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }

                template<class _InputIterator>
                    void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                            input_iterator_tag)
                    {
                        iterator __cur = begin();
                        for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
                            *__cur = *__first;
                        if (__first == __last)
                            erase(__cur, end());
                        else
                            insert(end(), __first, __last);
                    }

                template<class _ForwardIterator>
                    void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                            forward_iterator_tag)
                    {
                        const size_type __len = std::distance(__first, __last);
                        if (__len < size())
                            erase(std::copy(__first, __last, begin()), end());
                        else
                        {
                            _ForwardIterator __mid = __first;
                            std::advance(__mid, size());
                            std::copy(__first, __mid, begin());
                            insert(end(), __mid, __last);
                        }
                    }

                void reserve(size_type __n)
                {
                    if (__n > this->max_size())
                        __throw_length_error(__N("vector::reserve"));
                    if (this->capacity() < __n)
                    {
                        _Bit_type* __q = this->_M_allocate(__n);
                        this->_M_impl._M_finish = std::copy(begin(), end(), 
                                iterator(__q, 0));
                        this->_M_deallocate();
                        this->_M_impl._M_start = iterator(__q, 0);
                        this->_M_impl._M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
                    }
                }

                reference front()
                { return *begin(); }

                const_reference front() const
                { return *begin(); }

                reference back()
                { return *(end() - 1); }

                const_reference back() const
                { return *(end() - 1); }

                void push_back(bool __x)
                {
                    if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
                        *this->_M_impl._M_finish++ = __x;
                    else
                        _M_insert_aux(end(), __x);
                }

                void swap(vector<bool, _Alloc>& __x)
                {
                    std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
                    std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
                    std::swap(this->_M_impl._M_end_of_storage, 
                            __x._M_impl._M_end_of_storage);
                }

                // [23.2.5]/1, third-to-last entry in synopsis listing
                static void swap(reference __x, reference __y)
                {
                    bool __tmp = __x;
                    __x = __y;
                    __y = __tmp;
                }

                iterator insert(iterator __position, bool __x = bool())
                {
                    const difference_type __n = __position - begin();
                    if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
                            && __position == end())
                        *this->_M_impl._M_finish++ = __x;
                    else
                        _M_insert_aux(__position, __x);
                    return begin() + __n;
                }

                // Check whether it's an integral type.  If so, it's not an iterator.

                template<class _Integer>
                    void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                            __true_type)
                    { _M_fill_insert(__pos, __n, __x); }

                template<class _InputIterator>
                    void _M_insert_dispatch(iterator __pos,
                            _InputIterator __first, _InputIterator __last,
                            __false_type)
                    { _M_insert_range(__pos, __first, __last,
                            std::__iterator_category(__first)); }

                template<class _InputIterator>
                    void insert(iterator __position,
                            _InputIterator __first, _InputIterator __last)
                    {
                        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
                        _M_insert_dispatch(__position, __first, __last, _Integral());
                    }

                void _M_fill_insert(iterator __position, size_type __n, bool __x)
                {
                    if (__n == 0)
                        return;
                    if (capacity() - size() >= __n)
                    {
                        std::copy_backward(__position, end(),
                                this->_M_impl._M_finish + difference_type(__n));
                        std::fill(__position, __position + difference_type(__n), __x);
                        this->_M_impl._M_finish += difference_type(__n);
                    }
                    else
                    {
                        const size_type __len = size() + std::max(size(), __n);
                        _Bit_type * __q = this->_M_allocate(__len);
                        iterator __i = std::copy(begin(), __position, iterator(__q, 0));
                        std::fill_n(__i, __n, __x);
                        this->_M_impl._M_finish = std::copy(__position, end(),
                                __i + difference_type(__n));
                        this->_M_deallocate();
                        this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
                            / _S_word_bit;
                        this->_M_impl._M_start = iterator(__q, 0);
                    }
                }

                void insert(iterator __position, size_type __n, bool __x)
                { _M_fill_insert(__position, __n, __x); }

                void pop_back()
                { --this->_M_impl._M_finish; }

                iterator erase(iterator __position)
                {
                    if (__position + 1 != end())
                        std::copy(__position + 1, end(), __position);
                    --this->_M_impl._M_finish;
                    return __position;
                }

                iterator erase(iterator __first, iterator __last)
                {
                    this->_M_impl._M_finish = std::copy(__last, end(), __first);
                    return __first;
                }

                void resize(size_type __new_size, bool __x = bool())
                {
                    if (__new_size < size())
                        erase(begin() + difference_type(__new_size), end());
                    else
                        insert(end(), __new_size - size(), __x);
                }

                void flip()
                {
                    for (_Bit_type * __p = this->_M_impl._M_start._M_p;
                            __p != this->_M_impl._M_end_of_storage; ++__p)
                        *__p = ~*__p;
                }

                void clear()
                { erase(begin(), end()); }
        };
} // namespace std

#endif