__BVECTOR_QUALIFIED Class Reference

#include <_bvector.h>

Inheritance diagram for __BVECTOR_QUALIFIED:

Collaboration diagram for __BVECTOR_QUALIFIED:

Public Types
typedef bool	value_type
typedef size_t	size_type
typedef ptrdiff_t	difference_type
typedef _STLP_PRIV _Bit_reference	reference
typedef bool	const_reference
typedef _STLP_PRIV _Bit_reference *	pointer
typedef const bool *	const_pointer
typedef random_access_iterator_tag	_Iterator_category
typedef _STLP_PRIV _Bit_iterator	iterator
typedef _STLP_PRIV _Bit_const_iterator	const_iterator
typedef _STLP_PRIV _Bvector_base< _Alloc >::allocator_type	allocator_type
typedef _STLP_PRIV _Bvector_base< _Alloc >::__chunk_type	__chunk_type

Public Member Functions
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
size_type	size () const
size_type	max_size () const
size_type	capacity () const
bool	empty () const
reference	operator[] (size_type __n)
const_reference	operator[] (size_type __n) const
void	_M_range_check (size_type __n) const
reference	at (size_type __n)
const_reference	at (size_type __n) const
	__BVECTOR (const allocator_type &__a=allocator_type())
	__BVECTOR (size_type __n, bool __val, const allocator_type &__a=allocator_type())
	__BVECTOR (size_type __n)
	__BVECTOR (const _Self &__x)
	__BVECTOR (const_iterator __first, const_iterator __last, const allocator_type &__a=allocator_type())
	__BVECTOR (const bool *__first, const bool *__last, const allocator_type &__a=allocator_type())
	__BVECTOR (__move_source< _Self > src)
	~__BVECTOR ()
__BVECTOR_QUALIFIED &	operator= (const __BVECTOR_QUALIFIED &__x)
void	_M_fill_assign (size_t __n, bool __x)
void	assign (size_t __n, bool __x)
void	reserve (size_type __n)
reference	front ()
const_reference	front () const
reference	back ()
const_reference	back () const
void	push_back (bool __x)
void	swap (__BVECTOR_QUALIFIED &__x)
iterator	insert (iterator __position, bool __x=bool())
void	insert (iterator __position, const_iterator __first, const_iterator __last)
void	insert (iterator __position, const bool *__first, const bool *__last)
void	_M_fill_insert (iterator __position, size_type __n, bool __x)
void	insert (iterator __position, size_type __n, bool __x)
void	pop_back ()
iterator	erase (iterator __position)
iterator	erase (iterator __first, iterator __last)
void	resize (size_type __new_size, bool __x=bool())
void	flip ()
void	clear ()

Public Attributes
	_STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS

Protected Member Functions
void	_M_initialize (size_type __n)
void	_M_insert_aux (iterator __position, bool __x)

Private Types
typedef _STLP_PRIV _Bvector_base< _Alloc >	_Base
typedef __BVECTOR_QUALIFIED	_Self

Detailed Description

Definition at line 358 of file _bvector.h.

Member Typedef Documentation

__chunk_type

typedef _STLP_PRIV _Bvector_base<_Alloc>::__chunk_type __BVECTOR_QUALIFIED::__chunk_type

Definition at line 385 of file _bvector.h.

_Base

typedef _STLP_PRIV _Bvector_base<_Alloc > __BVECTOR_QUALIFIED::_Base

private

Definition at line 363 of file _bvector.h.

_Iterator_category

typedef random_access_iterator_tag __BVECTOR_QUALIFIED::_Iterator_category

Definition at line 373 of file _bvector.h.

_Self

typedef __BVECTOR_QUALIFIED __BVECTOR_QUALIFIED::_Self

private

Definition at line 364 of file _bvector.h.

allocator_type

typedef _STLP_PRIV _Bvector_base<_Alloc>::allocator_type __BVECTOR_QUALIFIED::allocator_type

Definition at line 384 of file _bvector.h.

const_iterator

typedef _STLP_PRIV _Bit_const_iterator __BVECTOR_QUALIFIED::const_iterator

Definition at line 376 of file _bvector.h.

const_pointer

typedef const bool* __BVECTOR_QUALIFIED::const_pointer

Definition at line 372 of file _bvector.h.

const_reference

typedef bool __BVECTOR_QUALIFIED::const_reference

Definition at line 370 of file _bvector.h.

difference_type

typedef ptrdiff_t __BVECTOR_QUALIFIED::difference_type

Definition at line 368 of file _bvector.h.

iterator

typedef _STLP_PRIV _Bit_iterator __BVECTOR_QUALIFIED::iterator

Definition at line 375 of file _bvector.h.

pointer

typedef _STLP_PRIV _Bit_reference* __BVECTOR_QUALIFIED::pointer

Definition at line 371 of file _bvector.h.

reference

typedef _STLP_PRIV _Bit_reference __BVECTOR_QUALIFIED::reference

Definition at line 369 of file _bvector.h.

size_type

typedef size_t __BVECTOR_QUALIFIED::size_type

Definition at line 367 of file _bvector.h.

value_type

typedef bool __BVECTOR_QUALIFIED::value_type

Definition at line 366 of file _bvector.h.

Constructor & Destructor Documentation

~__BVECTOR()

__BVECTOR_QUALIFIED::~__BVECTOR ( )

inline

Definition at line 579 of file _bvector.h.

{}

Member Function Documentation

__BVECTOR() [1/7]

__BVECTOR_QUALIFIED::__BVECTOR ( __move_source< _Self >  src )

inline

Definition at line 575 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__move_source<_Base>(src.get())) {}

__BVECTOR() [2/7]

__BVECTOR_QUALIFIED::__BVECTOR ( const _Self &  __x )

inline

Definition at line 523 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__x.get_allocator()) {
    _M_initialize(__x.size());
    _STLP_STD::copy(__x.begin(), __x.end(), this->_M_start);
  }

__BVECTOR() [3/7]

__BVECTOR_QUALIFIED::__BVECTOR ( const allocator_type &  __a = allocator_type() )

inlineexplicit

Definition at line 507 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__a) {}

__BVECTOR() [4/7]

__BVECTOR_QUALIFIED::__BVECTOR ( const bool *  __first, const bool *  __last, const allocator_type &  __a = allocator_type()  )

inline

Definition at line 565 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
    size_type __n = _STLP_STD::distance(__first, __last);
    _M_initialize(__n);
    _STLP_STD::copy(__first, __last, this->_M_start);
  }

__BVECTOR() [5/7]

__BVECTOR_QUALIFIED::__BVECTOR ( const_iterator  __first, const_iterator  __last, const allocator_type &  __a = allocator_type()  )

inline

Definition at line 558 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
    size_type __n = _STLP_STD::distance(__first, __last);
    _M_initialize(__n);
    _STLP_STD::copy(__first, __last, this->_M_start);
  }

__BVECTOR() [6/7]

__BVECTOR_QUALIFIED::__BVECTOR ( size_type  __n )

inlineexplicit

Definition at line 517 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(allocator_type()) {
    _M_initialize(__n);
    fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), 0);
  }

__BVECTOR() [7/7]

__BVECTOR_QUALIFIED::__BVECTOR ( size_type  __n, bool  __val, const allocator_type &  __a = allocator_type()  )

inline

Definition at line 510 of file _bvector.h.

    : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
    _M_initialize(__n);
    fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __val ? ~0 : 0);
  }

_M_fill_assign()

void __BVECTOR_QUALIFIED::_M_fill_assign ( size_t  __n, bool  __x  )

inline

Definition at line 597 of file _bvector.h.

                                            {
    if (__n > size()) {
      fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
      insert(end(), __n - size(), __x);
    }
    else {
      erase(begin() + __n, end());
      fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
    }
  }

Referenced by assign().

_M_fill_insert()

void __BVECTOR_QUALIFIED::_M_fill_insert ( iterator  __position, size_type  __n, bool  __x  )

inline

Definition at line 763 of file _bvector.h.

                                                                    {
    if (__n == 0) return;
    if (capacity() - size() >= __n) {
      _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + difference_type(__n),
                                 random_access_iterator_tag(), (difference_type*)0 );
      fill(__position, __position + difference_type(__n), __x);
      this->_M_finish += difference_type(__n);
    }
    else {
      size_type __len = size() + (max)(size(), __n);
      __chunk_type* __q = this->_M_bit_alloc(__len);
      iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
      fill_n(__i, __n, __x);
      this->_M_finish = _STLP_STD::copy(__position, end(), __i + difference_type(__n));
      this->_M_deallocate();
      this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
      this->_M_start = iterator(__q, 0);
    }
  }

Referenced by insert().

_M_initialize()

void __BVECTOR_QUALIFIED::_M_initialize ( size_type  __n )

inlineprotected

Definition at line 390 of file _bvector.h.

                                    {
    __chunk_type* __q = this->_M_bit_alloc(__n);
    this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__n);
    this->_M_start = iterator(__q, 0);
    this->_M_finish = this->_M_start + difference_type(__n);
  }

Referenced by __BVECTOR(), and operator=().

_M_insert_aux()

void __BVECTOR_QUALIFIED::_M_insert_aux ( iterator  __position, bool  __x  )

inlineprotected

Definition at line 396 of file _bvector.h.

                                                    {
    if (this->_M_finish._M_p != this->_M_end_of_storage._M_data) {
      _STLP_PRIV __copy_backward(__position, this->_M_finish, this->_M_finish + 1,
                                 random_access_iterator_tag(), (difference_type*)0 );
      *__position = __x;
      ++this->_M_finish;
    }
    else {
      size_type __len = size() ? 2 * size() : _STLP_WORD_BIT;
      __chunk_type* __q = this->_M_bit_alloc(__len);
      iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
      *__i++ = __x;
      this->_M_finish = _STLP_STD::copy(__position, end(), __i);
      this->_M_deallocate();
      this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
      this->_M_start = iterator(__q, 0);
    }
  }

Referenced by insert(), and push_back().

_M_range_check()

void __BVECTOR_QUALIFIED::_M_range_check ( size_type  __n ) const

inline

Definition at line 497 of file _bvector.h.

                                           {
    if (__n >= this->size())
      __stl_throw_range_error("vector<bool>");
  }

Referenced by at().

assign()

void __BVECTOR_QUALIFIED::assign ( size_t  __n, bool  __x  )

inline

Definition at line 607 of file _bvector.h.

{ _M_fill_assign(__n, __x); }

at() [1/2]

reference __BVECTOR_QUALIFIED::at ( size_type  __n )

inline

Definition at line 502 of file _bvector.h.

    { _M_range_check(__n); return (*this)[__n]; }

at() [2/2]

const_reference __BVECTOR_QUALIFIED::at ( size_type  __n ) const

inline

Definition at line 504 of file _bvector.h.

    { _M_range_check(__n); return (*this)[__n]; }

back() [1/2]

reference __BVECTOR_QUALIFIED::back ( )

inline

Definition at line 666 of file _bvector.h.

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

back() [2/2]

const_reference __BVECTOR_QUALIFIED::back ( ) const

inline

Definition at line 667 of file _bvector.h.

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

begin() [1/2]

iterator __BVECTOR_QUALIFIED::begin ( )

inline

Definition at line 472 of file _bvector.h.

{ return this->_M_start; }

Referenced by __BVECTOR(), and operator=().

begin() [2/2]

const_iterator __BVECTOR_QUALIFIED::begin ( ) const

inline

Definition at line 473 of file _bvector.h.

{ return this->_M_start; }

capacity()

size_type __BVECTOR_QUALIFIED::capacity ( ) const

inline

Definition at line 488 of file _bvector.h.

                             {
    return size_type(const_iterator(this->_M_end_of_storage._M_data, 0) - begin());
  }

Referenced by _M_fill_insert(), insert(), operator=(), and reserve().

clear()

void __BVECTOR_QUALIFIED::clear ( )

inline

Definition at line 811 of file _bvector.h.

{ erase(begin(), end()); }

empty()

bool __BVECTOR_QUALIFIED::empty ( ) const

inline

Definition at line 491 of file _bvector.h.

{ return begin() == end(); }

end() [1/2]

iterator __BVECTOR_QUALIFIED::end ( )

inline

Definition at line 474 of file _bvector.h.

{ return this->_M_finish; }

Referenced by __BVECTOR(), and operator=().

end() [2/2]

const_iterator __BVECTOR_QUALIFIED::end ( ) const

inline

Definition at line 475 of file _bvector.h.

{ return this->_M_finish; }

erase() [1/2]

iterator __BVECTOR_QUALIFIED::erase ( iterator  __first, iterator  __last  )

inline

Definition at line 796 of file _bvector.h.

                                                    {
    this->_M_finish = _STLP_STD::copy(__last, end(), __first);
    return __first;
  }

erase() [2/2]

iterator __BVECTOR_QUALIFIED::erase ( iterator  __position )

inline

Definition at line 790 of file _bvector.h.

                                      {
    if (__position + 1 != end())
      _STLP_STD::copy(__position + 1, end(), __position);
      --this->_M_finish;
    return __position;
  }

Referenced by _M_fill_assign(), clear(), and resize().

flip()

void __BVECTOR_QUALIFIED::flip ( )

inline

Definition at line 806 of file _bvector.h.

              {
    for (__chunk_type* __p = this->_M_start._M_p; __p != this->_M_end_of_storage._M_data; ++__p)
      *__p = ~*__p;
  }

front() [1/2]

reference __BVECTOR_QUALIFIED::front ( )

inline

Definition at line 664 of file _bvector.h.

{ return *begin(); }

front() [2/2]

const_reference __BVECTOR_QUALIFIED::front ( ) const

inline

Definition at line 665 of file _bvector.h.

{ return *begin(); }

insert() [1/4]

iterator __BVECTOR_QUALIFIED::insert ( iterator  __position, bool  __x = bool()  )

inline

Definition at line 685 of file _bvector.h.

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

insert() [2/4]

void __BVECTOR_QUALIFIED::insert ( iterator  __position, const bool *  __first, const bool *  __last  )

inline

Definition at line 741 of file _bvector.h.

                                                                            {
    if (__first == __last) return;
    size_type __n = _STLP_STD::distance(__first, __last);
    if (capacity() - size() >= __n) {
      _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + __n,
                                 random_access_iterator_tag(), (difference_type*)0 );
      _STLP_STD::copy(__first, __last, __position);
      this->_M_finish += __n;
    }
    else {
      size_type __len = size() + (max)(size(), __n);
      __chunk_type* __q = this->_M_bit_alloc(__len);
      iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
      __i = _STLP_STD::copy(__first, __last, __i);
      this->_M_finish = _STLP_STD::copy(__position, end(), __i);
      this->_M_deallocate();
      this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
      this->_M_start = iterator(__q, 0);
    }
  }

insert() [3/4]

void __BVECTOR_QUALIFIED::insert ( iterator  __position, const_iterator  __first, const_iterator  __last  )

inline

Definition at line 719 of file _bvector.h.

                                                             {
    if (__first == __last) return;
    size_type __n = _STLP_STD::distance(__first, __last);
    if (capacity() - size() >= __n) {
      _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + __n,
                                 random_access_iterator_tag(), (difference_type*)0 );
      _STLP_STD::copy(__first, __last, __position);
      this->_M_finish += __n;
    }
    else {
      size_type __len = size() + (max)(size(), __n);
      __chunk_type* __q = this->_M_bit_alloc(__len);
      iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
      __i = _STLP_STD::copy(__first, __last, __i);
      this->_M_finish = _STLP_STD::copy(__position, end(), __i);
      this->_M_deallocate();
      this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
      this->_M_start = iterator(__q, 0);
    }
  }

insert() [4/4]

void __BVECTOR_QUALIFIED::insert ( iterator  __position, size_type  __n, bool  __x  )

inline

Definition at line 783 of file _bvector.h.

                                                            {
    _M_fill_insert(__position, __n, __x);
  }

max_size()

size_type __BVECTOR_QUALIFIED::max_size ( ) const

inline

Definition at line 487 of file _bvector.h.

{ return size_type(-1); }

operator=()

__BVECTOR_QUALIFIED & __BVECTOR_QUALIFIED::operator= ( const __BVECTOR_QUALIFIED &  __x )

inline

Definition at line 581 of file _bvector.h.

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

operator[]() [1/2]

reference __BVECTOR_QUALIFIED::operator[] ( size_type  __n )

inline

Definition at line 492 of file _bvector.h.

  { return *(begin() + difference_type(__n)); }

operator[]() [2/2]

const_reference __BVECTOR_QUALIFIED::operator[] ( size_type  __n ) const

inline

Definition at line 494 of file _bvector.h.

  { return *(begin() + difference_type(__n)); }

pop_back()

void __BVECTOR_QUALIFIED::pop_back ( )

inline

Definition at line 787 of file _bvector.h.

                  {
    --this->_M_finish;
  }

push_back()

void __BVECTOR_QUALIFIED::push_back ( bool  __x )

inline

Definition at line 668 of file _bvector.h.

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

rbegin() [1/2]

reverse_iterator __BVECTOR_QUALIFIED::rbegin ( )

inline

Definition at line 477 of file _bvector.h.

{ return reverse_iterator(end()); }

rbegin() [2/2]

const_reverse_iterator __BVECTOR_QUALIFIED::rbegin ( ) const

inline

Definition at line 478 of file _bvector.h.

                                        {
    return const_reverse_iterator(end());
  }

rend() [1/2]

reverse_iterator __BVECTOR_QUALIFIED::rend ( )

inline

Definition at line 481 of file _bvector.h.

{ return reverse_iterator(begin()); }

rend() [2/2]

const_reverse_iterator __BVECTOR_QUALIFIED::rend ( ) const

inline

Definition at line 482 of file _bvector.h.

                                      {
    return const_reverse_iterator(begin());
  }

reserve()

void __BVECTOR_QUALIFIED::reserve ( size_type  __n )

inline

Definition at line 651 of file _bvector.h.

                              {
    if (capacity() < __n) {
      if (max_size() < __n)
        __stl_throw_length_error("vector<bool>");
      __chunk_type* __q = this->_M_bit_alloc(__n);
      _STLP_PRIV _Bit_iterator __z(__q, 0);
      this->_M_finish = _STLP_STD::copy(begin(), end(), __z);
      this->_M_deallocate();
      this->_M_start = iterator(__q, 0);
      this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__n);
    }
  }

resize()

void __BVECTOR_QUALIFIED::resize ( size_type  __new_size, bool  __x = bool()  )

inline

Definition at line 800 of file _bvector.h.

                                                       {
    if (__new_size < size())
      erase(begin() + difference_type(__new_size), end());
    else
      insert(end(), __new_size - size(), __x);
  }

size()

size_type __BVECTOR_QUALIFIED::size ( ) const

inline

Definition at line 486 of file _bvector.h.

{ return size_type(end() - begin()); }

Referenced by __BVECTOR(), and operator=().

swap()

void __BVECTOR_QUALIFIED::swap ( __BVECTOR_QUALIFIED &  __x )

inline

Definition at line 676 of file _bvector.h.

                                      {
    _STLP_STD::swap(this->_M_start, __x._M_start);
    _STLP_STD::swap(this->_M_finish, __x._M_finish);
    this->_M_end_of_storage.swap(__x._M_end_of_storage);
  }

Member Data Documentation

_STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS

__BVECTOR_QUALIFIED::_STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS

Definition at line 378 of file _bvector.h.

---

The documentation for this class was generated from the following file:

• sdk/include/c++/stlport/stl/_bvector.h