← Back to branch summary

~ubuntu-branches/ubuntu/hardy/libterralib/hardy

« back to all changes in this revision

Viewing changes to src/STLport/stl/debug/_list.h

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2005-11-25 22:32:59 UTC
  • Revision ID: james.westby@ubuntu.com-20051125223259-3zubal8ux4ki4fjg
Tags: upstream-3.0.3b2
Import upstream version 3.0.3b2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/STLport/stl/debug/_list.h
 
1
/*
 
2
 *
 
3
 * Copyright (c) 1994
 
4
 * Hewlett-Packard Company
 
5
 *
 
6
 * Copyright (c) 1996,1997
 
7
 * Silicon Graphics Computer Systems, Inc.
 
8
 *
 
9
 * Copyright (c) 1997
 
10
 * Moscow Center for SPARC Technology
 
11
 *
 
12
 * Copyright (c) 1999 
 
13
 * Boris Fomitchev
 
14
 *
 
15
 * This material is provided "as is", with absolutely no warranty expressed
 
16
 * or implied. Any use is at your own risk.
 
17
 *
 
18
 * Permission to use or copy this software for any purpose is hereby granted 
 
19
 * without fee, provided the above notices are retained on all copies.
 
20
 * Permission to modify the code and to distribute modified code is granted,
 
21
 * provided the above notices are retained, and a notice that the code was
 
22
 * modified is included with the above copyright notice.
 
23
 *
 
24
 */
 
25
 
 
26
/* NOTE: This is an internal header file, included by other STL headers.
 
27
 *   You should not attempt to use it directly.
 
28
 */
 
29
 
 
30
#ifndef _STLP_INTERNAL_DBG_LIST_H
 
31
#define _STLP_INTERNAL_DBG_LIST_H
 
32
 
 
33
#include <stl/debug/_iterator.h>
 
34
 
 
35
# ifndef _STLP_USE_WRAPPER_FOR_ALLOC_PARAM
 
36
#  undef  _DBG_list
 
37
#  define _DBG_list list
 
38
# endif
 
39
 
 
40
#  define _STLP_DBG_LIST_BASE \
 
41
__WORKAROUND_DBG_RENAME(list) <_Tp, _Alloc>
 
42
 
 
43
_STLP_BEGIN_NAMESPACE
 
44
 
 
45
# ifdef _STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS
 
46
template <class _Tp, class _Alloc>
 
47
inline _Tp*
 
48
value_type(const  _DBG_iter_base< _STLP_DBG_LIST_BASE >&) {
 
49
  return (_Tp*)0;
 
50
}
 
51
template <class _Tp, class _Alloc>
 
52
inline bidirectional_iterator_tag
 
53
iterator_category(const _DBG_iter_base< _STLP_DBG_LIST_BASE >&) {
 
54
  return bidirectional_iterator_tag();
 
55
}
 
56
# endif
 
57
 
 
58
template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
 
59
class _DBG_list : public _STLP_DBG_LIST_BASE {
 
60
 
 
61
  typedef _STLP_DBG_LIST_BASE _Base;
 
62
  typedef _DBG_list<_Tp, _Alloc> _Self;
 
63
 
 
64
public:      
 
65
  __IMPORT_CONTAINER_TYPEDEFS(_Base)
 
66
 
 
67
public:
 
68
  typedef _DBG_iter<_Base, _Nonconst_traits<value_type> >     iterator;
 
69
  typedef _DBG_iter<_Base, _Const_traits<value_type> >    const_iterator;
 
70
 
 
71
  _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
 
72
 
 
73
protected:
 
74
  mutable __owned_list _M_iter_list;
 
75
  void _Invalidate_all() { _M_iter_list._Invalidate_all();}
 
76
 
 
77
public:
 
78
  const _Base* _Get_base() const { return (const _Base*)this; }
 
79
  _Base* _Get_base() { return (_Base*)this; }
 
80
  explicit _DBG_list(const allocator_type& __a = allocator_type()) :
 
81
    _STLP_DBG_LIST_BASE(__a), _M_iter_list(_Get_base()) {}
 
82
  _DBG_list(size_type __n, const _Tp& __value,
 
83
            const allocator_type& __a = allocator_type())
 
84
    : _STLP_DBG_LIST_BASE(__n, __value, __a), _M_iter_list(_Get_base()) {}
 
85
  explicit _DBG_list(size_type __n)
 
86
    : _STLP_DBG_LIST_BASE(__n), _M_iter_list(_Get_base()) {}
 
87
  
 
88
#ifdef _STLP_MEMBER_TEMPLATES
 
89
 
 
90
  // We don't need any dispatching tricks here, because insert does all of
 
91
  // that anyway.  
 
92
#  ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
 
93
  template <class _InputIterator>
 
94
  _DBG_list(_InputIterator __first, _InputIterator __last)
 
95
    : _STLP_DBG_LIST_BASE(__first, __last, allocator_type()), _M_iter_list(_Get_base()) {}
 
96
#  endif
 
97
  template <class _InputIterator>
 
98
  _DBG_list(_InputIterator __first, _InputIterator __last,
 
99
       const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
 
100
    : _STLP_DBG_LIST_BASE(__first, __last, __a), _M_iter_list(_Get_base()) {}
 
101
#else /* _STLP_MEMBER_TEMPLATES */
 
102
 
 
103
  _DBG_list(const _Tp* __first, const _Tp* __last,
 
104
       const allocator_type& __a = allocator_type())
 
105
    : _STLP_DBG_LIST_BASE(__first, __last, __a), _M_iter_list(_Get_base()) {}
 
106
  _DBG_list(const_iterator __first, const_iterator __last,
 
107
       const allocator_type& __a = allocator_type()):
 
108
    _STLP_DBG_LIST_BASE(__first._M_iterator, __last._M_iterator, __a),
 
109
    _M_iter_list(_Get_base()) {}
 
110
 
 
111
#endif /* _STLP_MEMBER_TEMPLATES */
 
112
 
 
113
  _DBG_list(const _Self& __x) : 
 
114
    _STLP_DBG_LIST_BASE(__x) , _M_iter_list(_Get_base()) {}
 
115
 
 
116
  _Self& operator=(const _Self& __x) {
 
117
    _Invalidate_all();
 
118
    _Base::operator=((const _Base&)__x);
 
119
    return *this;
 
120
  }
 
121
 
 
122
public:
 
123
  iterator begin()             { return iterator(&_M_iter_list, _Base::begin()); }
 
124
  const_iterator begin() const { return const_iterator(&_M_iter_list, _Base::begin()); }
 
125
 
 
126
  iterator end()               { return iterator(&_M_iter_list, _Base::end()); }
 
127
  const_iterator end() const   { return const_iterator(&_M_iter_list, _Base::end()); }
 
128
 
 
129
  reverse_iterator rbegin()    { return reverse_iterator(end()); }
 
130
  reverse_iterator rend()      { return reverse_iterator(begin()); }
 
131
 
 
132
  const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
 
133
  const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
134
 
 
135
  // those are here to enforce checking
 
136
  reference front() { return *begin(); }
 
137
  const_reference front() const { return *begin(); }
 
138
  reference back() { return *(--end()); }
 
139
  const_reference back() const { return *(--end()); }
 
140
 
 
141
  void swap(_Self& __x) {
 
142
    _M_iter_list._Swap_owners(__x._M_iter_list);
 
143
    _Base::swap(__x); 
 
144
  }
 
145
 
 
146
  iterator insert(iterator __position, const _Tp& __x) {
 
147
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
148
      return iterator(&_M_iter_list,_Base::insert(__position._M_iterator, __x) );
 
149
  }
 
150
 
 
151
# ifndef _STLP_NO_ANACHRONISMS
 
152
  iterator insert(iterator __position) { return insert(__position, _Tp()); }
 
153
# endif
 
154
 
 
155
#ifdef _STLP_MEMBER_TEMPLATES
 
156
 
 
157
  template <class _InputIterator>
 
158
  void insert(iterator __position, _InputIterator __first, _InputIterator __last) {
 
159
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
160
    _Base::insert(__position._M_iterator, __first, __last);
 
161
  }
 
162
 
 
163
#else
 
164
 
 
165
  void insert(iterator __position, const _Tp* __first, const _Tp* __last) {
 
166
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
167
    _Base::insert(__position._M_iterator, __first, __last);
 
168
  }
 
169
 
 
170
  void insert(iterator __position,
 
171
              const_iterator __first, const_iterator __last) {
 
172
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
173
    _Base::insert(__position._M_iterator, __first._M_iterator, __last._M_iterator);
 
174
  }
 
175
  
 
176
#endif /* _STLP_MEMBER_TEMPLATES */
 
177
 
 
178
  void insert(iterator __position, size_type __n, const _Tp& __x) {
 
179
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
180
    _Base::insert(__position._M_iterator, __n, __x);    
 
181
  }
 
182
 
 
183
  void pop_back() {
 
184
    _STLP_VERBOSE_ASSERT(!this->empty(), _StlMsg_EMPTY_CONTAINER)
 
185
    __invalidate_iterator(&_M_iter_list,end());
 
186
    _Base::pop_back();
 
187
  }
 
188
 
 
189
  void pop_front() {
 
190
    _STLP_VERBOSE_ASSERT(!this->empty(), _StlMsg_EMPTY_CONTAINER)
 
191
    __invalidate_iterator(&_M_iter_list,begin());
 
192
    _Base::pop_front();
 
193
  }
 
194
 
 
195
  iterator erase(iterator __position) {
 
196
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
197
    _STLP_VERBOSE_ASSERT(__position._M_iterator._M_node!=this->_M_node._M_data, 
 
198
                         _StlMsg_ERASE_PAST_THE_END)
 
199
    // fbp : CHECK !!!
 
200
    __invalidate_iterator(&_M_iter_list, __position);
 
201
    return iterator(&_M_iter_list,_Base::erase(__position._M_iterator));
 
202
  }
 
203
  iterator erase(iterator __first, iterator __last) {
 
204
    while (__first != __last)
 
205
      erase(__first++);
 
206
    return __last;
 
207
  }
 
208
 
 
209
  void resize(size_type __new_size, const _Tp& __x) {
 
210
    typename _Base::iterator __i = _Base::begin();
 
211
    size_type __len = 0;
 
212
    for ( ; __i != _Base::end() && __len < __new_size; ++__i, ++__len);
 
213
    
 
214
    if (__len == __new_size)
 
215
      erase(iterator(&_M_iter_list,__i), end());
 
216
    else                          // __i == end()
 
217
      _Base::insert(_Base::end(), __new_size - __len, __x);
 
218
  }
 
219
 
 
220
  void resize(size_type __new_size) { this->resize(__new_size, _Tp()); }
 
221
 
 
222
  void remove(const _Tp& __value) {
 
223
    typename _Base::iterator __first = _Base::begin();
 
224
    typename _Base::iterator __last = _Base::end();
 
225
    while (__first != __last) {
 
226
      typename _Base::iterator __next = __first;
 
227
      ++__next;
 
228
      if (__value == *__first) erase(iterator(&_M_iter_list,__first));
 
229
      __first = __next;
 
230
    }
 
231
  }
 
232
 
 
233
  void clear() {   
 
234
    _Invalidate_all();
 
235
    _Base::clear(); 
 
236
  }
 
237
 
 
238
public:
 
239
  void splice(iterator __position, _Self& __x) {
 
240
    _STLP_VERBOSE_ASSERT(&__x!=this, _StlMsg_INVALID_ARGUMENT)
 
241
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position))
 
242
    _Base::splice(__position._M_iterator, __x);
 
243
    __x._Invalidate_all();
 
244
  }
 
245
 
 
246
  void splice(iterator __position, _Self& __x, iterator __i) {
 
247
      _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__position) &&
 
248
                        __check_if_owner(&__x._M_iter_list ,__i))
 
249
    _STLP_DEBUG_CHECK(_Dereferenceable(__i))
 
250
    // fbp : CHECK !!!
 
251
        // __invalidate_iterator(&__x._M_iter_list, __i);
 
252
    _Base::splice(__position._M_iterator, __x, __i._M_iterator);
 
253
  }
 
254
 
 
255
  void splice(iterator __position, _Self& __x, iterator __first, iterator __last) {
 
256
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list, __position))
 
257
    _STLP_VERBOSE_ASSERT(__first._Owner()==&__x._M_iter_list && __last._Owner()==&__x._M_iter_list, 
 
258
                         _StlMsg_NOT_OWNER)
 
259
    _Base::splice(__position._M_iterator, __x, __first._M_iterator, __last._M_iterator);
 
260
  }
 
261
 
 
262
  void merge(_Self& __x) {   
 
263
    __x._Invalidate_all();
 
264
    _Base::merge(__x); 
 
265
  }
 
266
  void reverse() {
 
267
    _Invalidate_all();
 
268
    _Base::reverse();
 
269
  }
 
270
  void unique() {
 
271
    _Invalidate_all();
 
272
    _Base::unique();
 
273
  }
 
274
  void sort() {
 
275
    _Invalidate_all();
 
276
    _Base::sort();
 
277
  }
 
278
 
 
279
#ifdef _STLP_MEMBER_TEMPLATES
 
280
 
 
281
  template <class _Predicate> void remove_if(_Predicate __pred)  {
 
282
    _Base::remove_if(__pred);
 
283
  }
 
284
  template <class _BinaryPredicate>
 
285
    void unique(_BinaryPredicate __binary_pred) {
 
286
    _Base::unique(__binary_pred);
 
287
  }
 
288
  template <class _StrictWeakOrdering>
 
289
    void merge(_Self& __x,
 
290
               _StrictWeakOrdering __comp) {
 
291
    __x._Invalidate_all();
 
292
    _Base::merge(__x, __comp);
 
293
  }
 
294
 
 
295
  template <class _StrictWeakOrdering>
 
296
  void sort(_StrictWeakOrdering __comp) {
 
297
      _Invalidate_all();
 
298
      _Base::sort(__comp);
 
299
  }
 
300
#endif /* _STLP_MEMBER_TEMPLATES */
 
301
 
 
302
};
 
303
 
 
304
#define _STLP_TEMPLATE_HEADER template <class _Tp, class _Alloc>
 
305
#define _STLP_TEMPLATE_CONTAINER _DBG_list<_Tp,_Alloc>
 
306
#define _STLP_TEMPLATE_CONTAINER_BASE _STLP_DBG_LIST_BASE
 
307
#include <stl/debug/_relops_cont.h>
 
308
#undef _STLP_TEMPLATE_CONTAINER_BASE
 
309
#undef _STLP_TEMPLATE_CONTAINER
 
310
#undef _STLP_TEMPLATE_HEADER
 
311
 
 
312
_STLP_END_NAMESPACE 
 
313
 
 
314
#endif /* _STLP_INTERNAL_LIST_H */
 
315
 
 
316
// Local Variables:
 
317
// mode:C++
 
318
// End: