1.1 --- a/epoc32/include/stdapis/stlport/stl/_bvector.h Tue Mar 16 16:12:26 2010 +0000
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,831 +0,0 @@
1.4 -/*
1.5 - *
1.6 - * Copyright (c) 1994
1.7 - * Hewlett-Packard Company
1.8 - *
1.9 - * Copyright (c) 1996,1997
1.10 - * Silicon Graphics Computer Systems, Inc.
1.11 - *
1.12 - * Copyright (c) 1997
1.13 - * Moscow Center for SPARC Technology
1.14 - *
1.15 - * Copyright (c) 1999
1.16 - * Boris Fomitchev
1.17 - *
1.18 - * This material is provided "as is", with absolutely no warranty expressed
1.19 - * or implied. Any use is at your own risk.
1.20 - *
1.21 - * Permission to use or copy this software for any purpose is hereby granted
1.22 - * without fee, provided the above notices are retained on all copies.
1.23 - * Permission to modify the code and to distribute modified code is granted,
1.24 - * provided the above notices are retained, and a notice that the code was
1.25 - * modified is included with the above copyright notice.
1.26 - *
1.27 - */
1.28 -
1.29 -/* NOTE: This is an internal header file, included by other STL headers.
1.30 - * You should not attempt to use it directly.
1.31 - */
1.32 -
1.33 -#ifndef _STLP_INTERNAL_BVECTOR_H
1.34 -#define _STLP_INTERNAL_BVECTOR_H
1.35 -
1.36 -#ifndef _STLP_INTERNAL_VECTOR_H
1.37 -# include <stl/_vector.h>
1.38 -# endif
1.39 -
1.40 -#ifndef __WORD_BIT
1.41 -#define __WORD_BIT (int(CHAR_BIT*sizeof(unsigned int)))
1.42 -#endif
1.43 -
1.44 -_STLP_BEGIN_NAMESPACE
1.45 -
1.46 -struct _Bit_reference {
1.47 - unsigned int* _M_p;
1.48 - unsigned int _M_mask;
1.49 - _Bit_reference(unsigned int* __x, unsigned int __y)
1.50 - : _M_p(__x), _M_mask(__y) {}
1.51 -
1.52 -public:
1.53 - _Bit_reference() : _M_p(0), _M_mask(0) {}
1.54 -
1.55 - operator bool() const {
1.56 - return !(!(*_M_p & _M_mask));
1.57 - }
1.58 - _Bit_reference& operator=(bool __x) {
1.59 - if (__x) *_M_p |= _M_mask;
1.60 - else *_M_p &= ~_M_mask;
1.61 - return *this;
1.62 - }
1.63 - _Bit_reference& operator=(const _Bit_reference& __x) {
1.64 - return *this = bool(__x);
1.65 - }
1.66 - bool operator==(const _Bit_reference& __x) const {
1.67 - return bool(*this) == bool(__x);
1.68 - }
1.69 - bool operator<(const _Bit_reference& __x) const {
1.70 - return !bool(*this) && bool(__x);
1.71 - }
1.72 -
1.73 - _Bit_reference& operator |= (bool __x) {
1.74 - if (__x)
1.75 - *_M_p |= _M_mask;
1.76 - return *this;
1.77 - }
1.78 - _Bit_reference& operator &= (bool __x) {
1.79 - if (!__x)
1.80 - *_M_p &= ~_M_mask;
1.81 - return *this;
1.82 - }
1.83 - void flip() { *_M_p ^= _M_mask; }
1.84 -};
1.85 -
1.86 -
1.87 -inline void swap(_Bit_reference& __x, _Bit_reference& __y)
1.88 -{
1.89 - bool __tmp = (bool)__x;
1.90 - __x = __y;
1.91 - __y = __tmp;
1.92 -}
1.93 -
1.94 -struct _Bit_iterator_base;
1.95 -
1.96 -struct _Bit_iterator_base
1.97 -{
1.98 - typedef ptrdiff_t difference_type;
1.99 -
1.100 - unsigned int* _M_p;
1.101 - unsigned int _M_offset;
1.102 -
1.103 - void _M_bump_up() {
1.104 - if (_M_offset++ == __WORD_BIT - 1) {
1.105 - _M_offset = 0;
1.106 - ++_M_p;
1.107 - }
1.108 - }
1.109 -
1.110 - void _M_bump_down() {
1.111 - if (_M_offset-- == 0) {
1.112 - _M_offset = __WORD_BIT - 1;
1.113 - --_M_p;
1.114 - }
1.115 - }
1.116 -
1.117 - _Bit_iterator_base() : _M_p(0), _M_offset(0) {}
1.118 - _Bit_iterator_base(unsigned int* __x, unsigned int __y) : _M_p(__x), _M_offset(__y) {}
1.119 - // _Bit_iterator_base( const _Bit_iterator_base& __x) : _M_p(__x._M_p), _M_offset(__x._M_offset) {}
1.120 - // _Bit_iterator_base& operator = ( const _Bit_iterator_base& __x) { _M_p = __x._M_p ; _M_offset = __x._M_offset ; return *this; }
1.121 -
1.122 - void _M_advance (difference_type __i) {
1.123 - difference_type __n = __i + _M_offset;
1.124 - _M_p += __n / __WORD_BIT;
1.125 - __n = __n % __WORD_BIT;
1.126 - if (__n < 0) {
1.127 - _M_offset = (unsigned int) __n + __WORD_BIT;
1.128 - --_M_p;
1.129 - } else
1.130 - _M_offset = (unsigned int) __n;
1.131 - }
1.132 -
1.133 - difference_type _M_subtract(const _Bit_iterator_base& __x) const {
1.134 - return __WORD_BIT * (_M_p - __x._M_p) + _M_offset - __x._M_offset;
1.135 - }
1.136 -};
1.137 -
1.138 -inline bool _STLP_CALL operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.139 - return __y._M_p == __x._M_p && __y._M_offset == __x._M_offset;
1.140 -}
1.141 -inline bool _STLP_CALL operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.142 - return __y._M_p != __x._M_p || __y._M_offset != __x._M_offset;
1.143 -}
1.144 -
1.145 -inline bool _STLP_CALL operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.146 - return __x._M_p < __y._M_p || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
1.147 -}
1.148 -
1.149 -inline bool _STLP_CALL operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.150 - return operator <(__y , __x);
1.151 -}
1.152 -inline bool _STLP_CALL operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.153 - return !(__y < __x);
1.154 -}
1.155 -inline bool _STLP_CALL operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
1.156 - return !(__x < __y);
1.157 -}
1.158 -
1.159 -template <class _Ref, class _Ptr>
1.160 -struct _Bit_iter : public _Bit_iterator_base
1.161 -{
1.162 - typedef _Ref reference;
1.163 - typedef _Ptr pointer;
1.164 - typedef _Bit_iter<_Ref, _Ptr> _Self;
1.165 - typedef random_access_iterator_tag iterator_category;
1.166 - typedef bool value_type;
1.167 - typedef ptrdiff_t difference_type;
1.168 - typedef size_t size_type;
1.169 -
1.170 - _Bit_iter(unsigned int* __x, unsigned int __y) : _Bit_iterator_base(__x, __y) {}
1.171 - _Bit_iter() {}
1.172 -
1.173 - _Bit_iter(const _Bit_iter<_Bit_reference, _Bit_reference*>& __x):
1.174 - _Bit_iterator_base((const _Bit_iterator_base&)__x) {}
1.175 -
1.176 - // _Self& operator = (const _Bit_iter<_Bit_reference, _Bit_reference*>& __x)
1.177 - // { (_Bit_iterator_base&)*this = (const _Bit_iterator_base&)__x; return *this; }
1.178 -
1.179 - reference operator*() const {
1.180 - return _Bit_reference(_M_p, 1UL << _M_offset);
1.181 - }
1.182 - _Self& operator++() {
1.183 - _M_bump_up();
1.184 - return *this;
1.185 - }
1.186 - _Self operator++(int) {
1.187 - _Self __tmp = *this;
1.188 - _M_bump_up();
1.189 - return __tmp;
1.190 - }
1.191 - _Self& operator--() {
1.192 - _M_bump_down();
1.193 - return *this;
1.194 - }
1.195 - _Self operator--(int) {
1.196 - _Self __tmp = *this;
1.197 - _M_bump_down();
1.198 - return __tmp;
1.199 - }
1.200 - _Self& operator+=(difference_type __i) {
1.201 - _M_advance(__i);
1.202 - return *this;
1.203 - }
1.204 - _Self& operator-=(difference_type __i) {
1.205 - *this += -__i;
1.206 - return *this;
1.207 - }
1.208 - _Self operator+(difference_type __i) const {
1.209 - _Self __tmp = *this;
1.210 - return __tmp += __i;
1.211 - }
1.212 - _Self operator-(difference_type __i) const {
1.213 - _Self __tmp = *this;
1.214 - return __tmp -= __i;
1.215 - }
1.216 - difference_type operator-(const _Self& __x) const {
1.217 - return _M_subtract(__x);
1.218 - }
1.219 - reference operator[](difference_type __i) { return *(*this + __i); }
1.220 -};
1.221 -
1.222 -template <class _Ref, class _Ptr>
1.223 -inline _Bit_iter<_Ref,_Ptr> _STLP_CALL
1.224 -operator+(ptrdiff_t __n, const _Bit_iter<_Ref, _Ptr>& __x) {
1.225 - return __x + __n;
1.226 -}
1.227 -
1.228 -# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
1.229 -inline random_access_iterator_tag iterator_category(const _Bit_iterator_base&) {return random_access_iterator_tag();}
1.230 -inline ptrdiff_t* distance_type(const _Bit_iterator_base&) {return (ptrdiff_t*)0;}
1.231 -inline bool* value_type(const _Bit_iter<_Bit_reference, _Bit_reference*>&) {return (bool*)0;}
1.232 -inline bool* value_type(const _Bit_iter<bool, const bool*>&) {return (bool*)0;}
1.233 -# endif
1.234 -
1.235 -typedef _Bit_iter<bool, const bool*> _Bit_const_iterator;
1.236 -typedef _Bit_iter<_Bit_reference, _Bit_reference*> _Bit_iterator;
1.237 -
1.238 -// Bit-vector base class, which encapsulates the difference between
1.239 -// old SGI-style allocators and standard-conforming allocators.
1.240 -
1.241 -
1.242 -template <class _Alloc>
1.243 -class _Bvector_base
1.244 -{
1.245 -public:
1.246 - _STLP_FORCE_ALLOCATORS(bool, _Alloc)
1.247 - typedef typename _Alloc_traits<bool, _Alloc>::allocator_type allocator_type;
1.248 - typedef unsigned int __chunk_type;
1.249 - typedef typename _Alloc_traits<__chunk_type,
1.250 - _Alloc>::allocator_type __chunk_allocator_type;
1.251 - allocator_type get_allocator() const {
1.252 - return _STLP_CONVERT_ALLOCATOR((const __chunk_allocator_type&)_M_end_of_storage, bool);
1.253 - }
1.254 - static allocator_type __get_dfl_allocator() { return allocator_type(); }
1.255 -
1.256 - _Bvector_base(const allocator_type& __a)
1.257 - : _M_start(), _M_finish(), _M_end_of_storage(_STLP_CONVERT_ALLOCATOR(__a, __chunk_type),
1.258 - (__chunk_type*)0) {
1.259 - }
1.260 - ~_Bvector_base() { _M_deallocate();
1.261 - }
1.262 -
1.263 -protected:
1.264 -
1.265 - unsigned int* _M_bit_alloc(size_t __n)
1.266 - { return _M_end_of_storage.allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
1.267 - void _M_deallocate() {
1.268 - if (_M_start._M_p)
1.269 - _M_end_of_storage.deallocate(_M_start._M_p,
1.270 - _M_end_of_storage._M_data - _M_start._M_p);
1.271 - }
1.272 -
1.273 - _Bit_iterator _M_start;
1.274 - _Bit_iterator _M_finish;
1.275 - _STLP_alloc_proxy<__chunk_type*, __chunk_type, __chunk_allocator_type> _M_end_of_storage;
1.276 -};
1.277 -
1.278 -
1.279 -// The next few lines are confusing. What we're doing is declaring a
1.280 -// partial specialization of vector<T, Alloc> if we have the necessary
1.281 -// compiler support. Otherwise, we define a class bit_vector which uses
1.282 -// the default allocator.
1.283 -
1.284 -#if defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) && ! defined(_STLP_NO_BOOL) && ! defined (__SUNPRO_CC)
1.285 -# define _STLP_VECBOOL_TEMPLATE
1.286 -# define __BVEC_TMPL_HEADER template <class _Alloc>
1.287 -#else
1.288 -# undef _STLP_VECBOOL_TEMPLATE
1.289 -# ifdef _STLP_NO_BOOL
1.290 -# define __BVEC_TMPL_HEADER
1.291 -# else
1.292 -# define __BVEC_TMPL_HEADER _STLP_TEMPLATE_NULL
1.293 -# endif
1.294 -# if !(defined(__MRC__)||(defined(__SC__)&&!defined(__DMC__))) //*TY 12/17/2000 -
1.295 -# define _Alloc _STLP_DEFAULT_ALLOCATOR(bool)
1.296 -# else
1.297 -# define _Alloc allocator<bool>
1.298 -# endif
1.299 -#endif
1.300 -
1.301 -#ifdef _STLP_NO_BOOL
1.302 -# define __BVECTOR_QUALIFIED bit_vector
1.303 -# define __BVECTOR bit_vector
1.304 -#else
1.305 -# ifdef _STLP_VECBOOL_TEMPLATE
1.306 -# define __BVECTOR_QUALIFIED __WORKAROUND_DBG_RENAME(vector) <bool, _Alloc>
1.307 -# else
1.308 -# define __BVECTOR_QUALIFIED __WORKAROUND_DBG_RENAME(vector) <bool, allocator<bool> >
1.309 -# endif
1.310 -#if defined (_STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS)
1.311 -# define __BVECTOR __BVECTOR_QUALIFIED
1.312 -#else
1.313 -# define __BVECTOR __WORKAROUND_DBG_RENAME(vector)
1.314 -#endif
1.315 -#endif
1.316 -
1.317 -
1.318 -__BVEC_TMPL_HEADER
1.319 -class __BVECTOR_QUALIFIED : public _Bvector_base<_Alloc >
1.320 -{
1.321 - typedef _Bvector_base<_Alloc > _Base;
1.322 - typedef __BVECTOR_QUALIFIED _Self;
1.323 -public:
1.324 - typedef bool value_type;
1.325 - typedef size_t size_type;
1.326 - typedef ptrdiff_t difference_type;
1.327 - typedef _Bit_reference reference;
1.328 - typedef bool const_reference;
1.329 - typedef _Bit_reference* pointer;
1.330 - typedef const bool* const_pointer;
1.331 - typedef random_access_iterator_tag _Iterator_category;
1.332 -
1.333 - typedef _Bit_iterator iterator;
1.334 - typedef _Bit_const_iterator const_iterator;
1.335 -
1.336 -#if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )
1.337 - typedef _STLP_STD::reverse_iterator<const_iterator> const_reverse_iterator;
1.338 - typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator;
1.339 -#else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
1.340 -# if defined (_STLP_MSVC50_COMPATIBILITY)
1.341 - typedef _STLP_STD::reverse_iterator<const_iterator, value_type, const_reference,
1.342 - const_pointer, difference_type> const_reverse_iterator;
1.343 - typedef _STLP_STD::reverse_iterator<iterator, value_type, reference, reference*,
1.344 - difference_type> reverse_iterator;
1.345 -# else
1.346 - typedef _STLP_STD::reverse_iterator<const_iterator, value_type, const_reference,
1.347 - difference_type> const_reverse_iterator;
1.348 - typedef _STLP_STD::reverse_iterator<iterator, value_type, reference, difference_type>
1.349 - reverse_iterator;
1.350 -# endif
1.351 -#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
1.352 -
1.353 -# ifdef _STLP_VECBOOL_TEMPLATE
1.354 - typedef typename _Bvector_base<_Alloc >::allocator_type allocator_type;
1.355 - typedef typename _Bvector_base<_Alloc >::__chunk_type __chunk_type ;
1.356 -# else
1.357 - typedef _Bvector_base<_Alloc >::allocator_type allocator_type;
1.358 - typedef _Bvector_base<_Alloc >::__chunk_type __chunk_type ;
1.359 -# endif
1.360 -
1.361 -protected:
1.362 -
1.363 - void _M_initialize(size_type __n) {
1.364 - unsigned int* __q = this->_M_bit_alloc(__n);
1.365 - this->_M_end_of_storage._M_data = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
1.366 - this->_M_start = iterator(__q, 0);
1.367 - this->_M_finish = this->_M_start + difference_type(__n);
1.368 - }
1.369 - void _M_insert_aux(iterator __position, bool __x) {
1.370 - if (this->_M_finish._M_p != this->_M_end_of_storage._M_data) {
1.371 - __copy_backward(__position, this->_M_finish, this->_M_finish + 1, random_access_iterator_tag(), (difference_type*)0 );
1.372 - *__position = __x;
1.373 - ++this->_M_finish;
1.374 - }
1.375 - else {
1.376 - size_type __len = size() ? 2 * size() : __WORD_BIT;
1.377 - unsigned int* __q = this->_M_bit_alloc(__len);
1.378 - iterator __i = copy(begin(), __position, iterator(__q, 0));
1.379 - *__i++ = __x;
1.380 - this->_M_finish = copy(__position, end(), __i);
1.381 - this->_M_deallocate();
1.382 - this->_M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
1.383 - this->_M_start = iterator(__q, 0);
1.384 - }
1.385 - }
1.386 -
1.387 -#ifdef _STLP_MEMBER_TEMPLATES
1.388 - template <class _InputIterator>
1.389 - void _M_initialize_range(_InputIterator __first, _InputIterator __last,
1.390 - const input_iterator_tag &) {
1.391 - this->_M_start = iterator();
1.392 - this->_M_finish = iterator();
1.393 - this->_M_end_of_storage._M_data = 0;
1.394 - for ( ; __first != __last; ++__first)
1.395 - push_back(*__first);
1.396 - }
1.397 -
1.398 - template <class _ForwardIterator>
1.399 - void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1.400 - const forward_iterator_tag &) {
1.401 - size_type __n = distance(__first, __last);
1.402 - _M_initialize(__n);
1.403 - // copy(__first, __last, _M_start);
1.404 - copy(__first, __last, this->_M_start); // dwa 12/22/99 -- resolving ambiguous reference.
1.405 - }
1.406 -
1.407 - template <class _InputIterator>
1.408 - void _M_insert_range(iterator __pos,
1.409 - _InputIterator __first, _InputIterator __last,
1.410 - const input_iterator_tag &) {
1.411 - for ( ; __first != __last; ++__first) {
1.412 - __pos = insert(__pos, *__first);
1.413 - ++__pos;
1.414 - }
1.415 - }
1.416 -
1.417 - template <class _ForwardIterator>
1.418 - void _M_insert_range(iterator __position,
1.419 - _ForwardIterator __first, _ForwardIterator __last,
1.420 - const forward_iterator_tag &) {
1.421 - if (__first != __last) {
1.422 - size_type __n = distance(__first, __last);
1.423 - if (capacity() - size() >= __n) {
1.424 - __copy_backward(__position, end(), this->_M_finish + difference_type(__n), random_access_iterator_tag(), (difference_type*)0 );
1.425 - copy(__first, __last, __position);
1.426 - this->_M_finish += difference_type(__n);
1.427 - }
1.428 - else {
1.429 - size_type __len = size() + (max)(size(), __n);
1.430 - unsigned int* __q = this->_M_bit_alloc(__len);
1.431 - iterator __i = copy(begin(), __position, iterator(__q, 0));
1.432 - __i = copy(__first, __last, __i);
1.433 - this->_M_finish = copy(__position, end(), __i);
1.434 - this->_M_deallocate();
1.435 - this->_M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
1.436 - this->_M_start = iterator(__q, 0);
1.437 - }
1.438 - }
1.439 - }
1.440 -
1.441 -#endif /* _STLP_MEMBER_TEMPLATES */
1.442 -
1.443 -public:
1.444 - iterator begin() { return this->_M_start; }
1.445 - const_iterator begin() const { return this->_M_start; }
1.446 - iterator end() { return this->_M_finish; }
1.447 - const_iterator end() const { return this->_M_finish; }
1.448 -
1.449 - reverse_iterator rbegin() { return reverse_iterator(end()); }
1.450 - const_reverse_iterator rbegin() const {
1.451 - return const_reverse_iterator(end());
1.452 - }
1.453 - reverse_iterator rend() { return reverse_iterator(begin()); }
1.454 - const_reverse_iterator rend() const {
1.455 - return const_reverse_iterator(begin());
1.456 - }
1.457 -
1.458 - size_type size() const { return size_type(end() - begin()); }
1.459 - size_type max_size() const { return size_type(-1); }
1.460 - size_type capacity() const {
1.461 - return size_type(const_iterator(this->_M_end_of_storage._M_data, 0) - begin());
1.462 - }
1.463 - bool empty() const { return begin() == end(); }
1.464 - reference operator[](size_type __n)
1.465 - { return *(begin() + difference_type(__n)); }
1.466 - const_reference operator[](size_type __n) const
1.467 - { return *(begin() + difference_type(__n)); }
1.468 -
1.469 - void _M_range_check(size_type __n) const {
1.470 - if (__n >= this->size())
1.471 - __stl_throw_range_error("vector<bool>");
1.472 - }
1.473 -
1.474 - reference at(size_type __n)
1.475 - { _M_range_check(__n); return (*this)[__n]; }
1.476 - const_reference at(size_type __n) const
1.477 - { _M_range_check(__n); return (*this)[__n]; }
1.478 -
1.479 - explicit __BVECTOR(const allocator_type& __a = allocator_type())
1.480 - : _Bvector_base<_Alloc >(__a) {
1.481 - _STLP_POP_IF_CHECK
1.482 - }
1.483 -
1.484 - __BVECTOR(size_type __n, bool __val,
1.485 - const allocator_type& __a =
1.486 - allocator_type())
1.487 - : _Bvector_base<_Alloc >(__a)
1.488 - {
1.489 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.490 - _M_initialize(__n);
1.491 - fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __val ? ~0 : 0);
1.492 - _STLP_POP_CLEANUP_ITEM
1.493 - }
1.494 -
1.495 - explicit __BVECTOR(size_type __n)
1.496 - : _Bvector_base<_Alloc >(allocator_type())
1.497 - {
1.498 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.499 - _M_initialize(__n);
1.500 - fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), 0);
1.501 - _STLP_POP_CLEANUP_ITEM
1.502 - }
1.503 -
1.504 - __BVECTOR(const _Self& __x) : _Bvector_base<_Alloc >(__x.get_allocator()) {
1.505 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.506 - _M_initialize(__x.size());
1.507 - copy(__x.begin(), __x.end(), this->_M_start);
1.508 - _STLP_POP_CLEANUP_ITEM
1.509 - }
1.510 -
1.511 -#if defined (_STLP_MEMBER_TEMPLATES)
1.512 - template <class _Integer>
1.513 - void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type&) {
1.514 - _M_initialize(__n);
1.515 - fill(this->_M_start._M_p, this->_M_end_of_storage._M_data, __x ? ~0 : 0);
1.516 - }
1.517 -
1.518 - template <class _InputIterator>
1.519 - void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1.520 - const __false_type&) {
1.521 - _M_initialize_range(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
1.522 - }
1.523 -# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
1.524 - // Check whether it's an integral type. If so, it's not an iterator.
1.525 - template <class _InputIterator>
1.526 - __BVECTOR(_InputIterator __first, _InputIterator __last)
1.527 - : _Base(allocator_type())
1.528 - {
1.529 - typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
1.530 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.531 - _M_initialize_dispatch(__first, __last, _Integral());
1.532 - _STLP_POP_CLEANUP_ITEM
1.533 - }
1.534 -# endif
1.535 - template <class _InputIterator>
1.536 - __BVECTOR(_InputIterator __first, _InputIterator __last,
1.537 - const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
1.538 - : _Base(__a)
1.539 - {
1.540 - typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
1.541 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.542 - _M_initialize_dispatch(__first, __last, _Integral());
1.543 - _STLP_POP_CLEANUP_ITEM
1.544 - }
1.545 -#else /* _STLP_MEMBER_TEMPLATES */
1.546 - __BVECTOR(const_iterator __first, const_iterator __last,
1.547 - const allocator_type& __a = allocator_type())
1.548 - : _Bvector_base<_Alloc >(__a)
1.549 - {
1.550 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.551 - size_type __n = distance(__first, __last);
1.552 - _M_initialize(__n);
1.553 - copy(__first, __last, this->_M_start);
1.554 - _STLP_POP_CLEANUP_ITEM
1.555 - }
1.556 - __BVECTOR(const bool* __first, const bool* __last,
1.557 - const allocator_type& __a = allocator_type())
1.558 - : _Bvector_base<_Alloc >(__a)
1.559 - {
1.560 - size_type __n = distance(__first, __last);
1.561 - _STLP_PUSH_CLEANUP_ITEM(_Base, this)
1.562 - _M_initialize(__n);
1.563 - copy(__first, __last, this->_M_start);
1.564 - _STLP_POP_CLEANUP_ITEM
1.565 - }
1.566 -#endif /* _STLP_MEMBER_TEMPLATES */
1.567 -
1.568 - ~__BVECTOR() { }
1.569 -
1.570 - __BVECTOR_QUALIFIED& operator=(const __BVECTOR_QUALIFIED& __x) {
1.571 - if (&__x == this) return *this;
1.572 - if (__x.size() > capacity()) {
1.573 - this->_M_deallocate();
1.574 - _M_initialize(__x.size());
1.575 - }
1.576 - copy(__x.begin(), __x.end(), begin());
1.577 - this->_M_finish = begin() + difference_type(__x.size());
1.578 - return *this;
1.579 - }
1.580 -
1.581 -#ifdef _STLP_USE_TRAP_LEAVE
1.582 -public:
1.583 - static void* operator new (size_t __n, TLeave) { return _STLP_StackHelper<bool>::_NewLC(__n); }
1.584 - static void* operator new (size_t __n) { return _STLP_StackHelper<bool>::_NewLC(__n); }
1.585 -#endif
1.586 -
1.587 - // assign(), a generalized assignment member function. Two
1.588 - // versions: one that takes a count, and one that takes a range.
1.589 - // The range version is a member template, so we dispatch on whether
1.590 - // or not the type is an integer.
1.591 -
1.592 - void _M_fill_assign(size_t __n, bool __x) {
1.593 - if (__n > size()) {
1.594 - fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
1.595 - insert(end(), __n - size(), __x);
1.596 - }
1.597 - else {
1.598 - erase(begin() + __n, end());
1.599 - fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
1.600 - }
1.601 - }
1.602 - void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
1.603 -
1.604 -#ifdef _STLP_MEMBER_TEMPLATES
1.605 -
1.606 - template <class _InputIterator>
1.607 - void assign(_InputIterator __first, _InputIterator __last) {
1.608 - typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
1.609 - _M_assign_dispatch(__first, __last, _Integral());
1.610 - }
1.611 -
1.612 - template <class _Integer>
1.613 - void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&)
1.614 - { _M_fill_assign((size_t) __n, (bool) __val); }
1.615 -
1.616 - template <class _InputIter>
1.617 - void _M_assign_dispatch(_InputIter __first, _InputIter __last, const __false_type&)
1.618 - { _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); }
1.619 -
1.620 - template <class _InputIterator>
1.621 - void _M_assign_aux(_InputIterator __first, _InputIterator __last,
1.622 - const input_iterator_tag &) {
1.623 - iterator __cur = begin();
1.624 - for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
1.625 - *__cur = *__first;
1.626 - if (__first == __last)
1.627 - erase(__cur, end());
1.628 - else
1.629 - insert(end(), __first, __last);
1.630 - }
1.631 -
1.632 - template <class _ForwardIterator>
1.633 - void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1.634 - const forward_iterator_tag &) {
1.635 - size_type __len = distance(__first, __last);
1.636 - if (__len < size())
1.637 - erase(copy(__first, __last, begin()), end());
1.638 - else {
1.639 - _ForwardIterator __mid = __first;
1.640 - advance(__mid, size());
1.641 - copy(__first, __mid, begin());
1.642 - insert(end(), __mid, __last);
1.643 - }
1.644 - }
1.645 -
1.646 -#endif /* _STLP_MEMBER_TEMPLATES */
1.647 -
1.648 - void reserve(size_type __n) {
1.649 - if (capacity() < __n) {
1.650 - unsigned int* __q = this->_M_bit_alloc(__n);
1.651 - _Bit_iterator __z(__q, 0);
1.652 - this->_M_finish = copy(begin(), end(), __z);
1.653 - this->_M_deallocate();
1.654 - this->_M_start = iterator(__q, 0);
1.655 - this->_M_end_of_storage._M_data = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
1.656 - }
1.657 - }
1.658 -
1.659 - reference front() { return *begin(); }
1.660 - const_reference front() const { return *begin(); }
1.661 - reference back() { return *(end() - 1); }
1.662 - const_reference back() const { return *(end() - 1); }
1.663 - void push_back(bool __x) {
1.664 - if (this->_M_finish._M_p != this->_M_end_of_storage._M_data) {
1.665 - *(this->_M_finish) = __x;
1.666 - ++this->_M_finish;
1.667 - }
1.668 - else
1.669 - _M_insert_aux(end(), __x);
1.670 - }
1.671 - void swap(__BVECTOR_QUALIFIED& __x) {
1.672 - _STLP_STD::swap(this->_M_start, __x._M_start);
1.673 - _STLP_STD::swap(this->_M_finish, __x._M_finish);
1.674 - _STLP_STD::swap(this->_M_end_of_storage, __x._M_end_of_storage);
1.675 - }
1.676 - iterator insert(iterator __position, bool __x = bool()) {
1.677 - difference_type __n = __position - begin();
1.678 - if (this->_M_finish._M_p != this->_M_end_of_storage._M_data && __position == end()) {
1.679 - *(this->_M_finish) = __x;
1.680 - ++this->_M_finish;
1.681 - }
1.682 - else
1.683 - _M_insert_aux(__position, __x);
1.684 - return begin() + __n;
1.685 - }
1.686 -
1.687 -#if defined ( _STLP_MEMBER_TEMPLATES )
1.688 -
1.689 - template <class _Integer>
1.690 - void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1.691 - const __true_type&) {
1.692 - _M_fill_insert(__pos, (size_type) __n, (bool) __x);
1.693 - }
1.694 -
1.695 - template <class _InputIterator>
1.696 - void _M_insert_dispatch(iterator __pos,
1.697 - _InputIterator __first, _InputIterator __last,
1.698 - const __false_type&) {
1.699 - _M_insert_range(__pos, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
1.700 - }
1.701 -
1.702 - // Check whether it's an integral type. If so, it's not an iterator.
1.703 - template <class _InputIterator>
1.704 - void insert(iterator __position,
1.705 - _InputIterator __first, _InputIterator __last) {
1.706 - typedef typename _Is_integer<_InputIterator>::_Integral _Is_Integral;
1.707 - _M_insert_dispatch(__position, __first, __last, _Is_Integral());
1.708 - }
1.709 -#else /* _STLP_MEMBER_TEMPLATES */
1.710 - void insert(iterator __position,
1.711 - const_iterator __first, const_iterator __last) {
1.712 - if (__first == __last) return;
1.713 - size_type __n = distance(__first, __last);
1.714 - if (capacity() - size() >= __n) {
1.715 - __copy_backward(__position, end(), this->_M_finish + __n,
1.716 - random_access_iterator_tag(), (difference_type*)0 );
1.717 - copy(__first, __last, __position);
1.718 - this->_M_finish += __n;
1.719 - }
1.720 - else {
1.721 - size_type __len = size() + (max)(size(), __n);
1.722 - unsigned int* __q = this->_M_bit_alloc(__len);
1.723 - iterator __i = copy(begin(), __position, iterator(__q, 0));
1.724 - __i = copy(__first, __last, __i);
1.725 - this->_M_finish = copy(__position, end(), __i);
1.726 - this->_M_deallocate();
1.727 - this->_M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
1.728 - this->_M_start = iterator(__q, 0);
1.729 - }
1.730 - }
1.731 -
1.732 - void insert(iterator __position, const bool* __first, const bool* __last) {
1.733 - if (__first == __last) return;
1.734 - size_type __n = distance(__first, __last);
1.735 - if (capacity() - size() >= __n) {
1.736 - __copy_backward(__position, end(), this->_M_finish + __n,
1.737 - random_access_iterator_tag(), (difference_type*)0 );
1.738 - copy(__first, __last, __position);
1.739 - this->_M_finish += __n;
1.740 - }
1.741 - else {
1.742 - size_type __len = size() + (max)(size(), __n);
1.743 - unsigned int* __q = this->_M_bit_alloc(__len);
1.744 - iterator __i = copy(begin(), __position, iterator(__q, 0));
1.745 - __i = copy(__first, __last, __i);
1.746 - this->_M_finish = copy(__position, end(), __i);
1.747 - this->_M_deallocate();
1.748 - this->_M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
1.749 - this->_M_start = iterator(__q, 0);
1.750 - }
1.751 - }
1.752 -#endif /* _STLP_MEMBER_TEMPLATES */
1.753 -
1.754 - void _M_fill_insert(iterator __position, size_type __n, bool __x) {
1.755 - if (__n == 0) return;
1.756 - if (capacity() - size() >= __n) {
1.757 - __copy_backward(__position, end(), this->_M_finish + difference_type(__n), random_access_iterator_tag(), (difference_type*)0 );
1.758 - fill(__position, __position + difference_type(__n), __x);
1.759 - this->_M_finish += difference_type(__n);
1.760 - }
1.761 - else {
1.762 - size_type __len = size() + (max)(size(), __n);
1.763 - unsigned int* __q = this->_M_bit_alloc(__len);
1.764 - iterator __i = copy(begin(), __position, iterator(__q, 0));
1.765 - fill_n(__i, __n, __x);
1.766 - this->_M_finish = copy(__position, end(), __i + difference_type(__n));
1.767 - this->_M_deallocate();
1.768 - this->_M_end_of_storage._M_data = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
1.769 - this->_M_start = iterator(__q, 0);
1.770 - }
1.771 - }
1.772 -
1.773 - void insert(iterator __position, size_type __n, bool __x) {
1.774 - _M_fill_insert(__position, __n, __x);
1.775 - }
1.776 -
1.777 - void pop_back() {
1.778 - --this->_M_finish;
1.779 - }
1.780 - iterator erase(iterator __position) {
1.781 - if (__position + 1 != end())
1.782 - copy(__position + 1, end(), __position);
1.783 - --this->_M_finish;
1.784 - return __position;
1.785 - }
1.786 - iterator erase(iterator __first, iterator __last) {
1.787 - this->_M_finish = copy(__last, end(), __first);
1.788 - return __first;
1.789 - }
1.790 - void resize(size_type __new_size, bool __x = bool()) {
1.791 - if (__new_size < size())
1.792 - erase(begin() + difference_type(__new_size), end());
1.793 - else
1.794 - insert(end(), __new_size - size(), __x);
1.795 - }
1.796 - void flip() {
1.797 - for (unsigned int* __p = this->_M_start._M_p; __p != this->_M_end_of_storage._M_data; ++__p)
1.798 - *__p = ~*__p;
1.799 - }
1.800 -
1.801 - void clear() { erase(begin(), end()); }
1.802 -};
1.803 -
1.804 -# if defined ( _STLP_NO_BOOL ) || defined (__HP_aCC) // fixed soon (03/17/2000)
1.805 -
1.806 -#define _STLP_TEMPLATE_HEADER __BVEC_TMPL_HEADER
1.807 -#define _STLP_TEMPLATE_CONTAINER __BVECTOR_QUALIFIED
1.808 -#include <stl/_relops_cont.h>
1.809 -#undef _STLP_TEMPLATE_CONTAINER
1.810 -#undef _STLP_TEMPLATE_HEADER
1.811 -
1.812 -# endif /* NO_BOOL */
1.813 -
1.814 -#if !defined (_STLP_NO_BOOL)
1.815 -// This typedef is non-standard. It is provided for backward compatibility.
1.816 - typedef __WORKAROUND_DBG_RENAME(vector) <bool, allocator<bool> > bit_vector;
1.817 -#endif
1.818 -
1.819 -_STLP_END_NAMESPACE
1.820 -
1.821 -#undef _Alloc
1.822 -#undef _STLP_VECBOOL_TEMPLATE
1.823 -#undef __BVECTOR
1.824 -#undef __BVECTOR_QUALIFIED
1.825 -#undef __BVEC_TMPL_HEADER
1.826 -
1.827 -# undef __WORD_BIT
1.828 -
1.829 -#endif /* _STLP_INTERNAL_BVECTOR_H */
1.830 -
1.831 -// Local Variables:
1.832 -// mode:C++
1.833 -// End:
1.834 -