Context Navigation

safe_iterator.h

Last change on this file was 76, checked in by megakiss, 10 years ago
1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
Property svn:executable set to ``*
File size: 20.4 KB

Line
1	// Safe iterator implementation -- C++ --
2
3	// Copyright (C) 2003, 2004
4	// Free Software Foundation, Inc.
5	//
6	// This file is part of the GNU ISO C++ Library. This library is free
7	// software; you can redistribute it and/or modify it under the
8	// terms of the GNU General Public License as published by the
9	// Free Software Foundation; either version 2, or (at your option)
10	// any later version.
11
12	// This library is distributed in the hope that it will be useful,
13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	// GNU General Public License for more details.
16
17	// You should have received a copy of the GNU General Public License along
18	// with this library; see the file COPYING. If not, write to the Free
19	// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20	// USA.
21
22	// As a special exception, you may use this file as part of a free software
23	// library without restriction. Specifically, if other files instantiate
24	// templates or use macros or inline functions from this file, or you compile
25	// this file and link it with other files to produce an executable, this
26	// file does not by itself cause the resulting executable to be covered by
27	// the GNU General Public License. This exception does not however
28	// invalidate any other reasons why the executable file might be covered by
29	// the GNU General Public License.
30
31	#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_H
32	#define _GLIBCXX_DEBUG_SAFE_ITERATOR_H 1
33
34	#include <bits/stl_pair.h>
35	#include <debug/debug.h>
36	#include <debug/formatter.h>
37	#include <debug/safe_base.h>
38	#include <bits/cpp_type_traits.h>
39
40	namespace __gnu_debug
41	{
42	using std::iterator_traits;
43	using std::pair;
44
45	/** Iterators that derive from _Safe_iterator_base but that aren't
46	* _Safe_iterators can be determined singular or non-singular via
47	* _Safe_iterator_base.
48	*/
49	inline bool __check_singular_aux(const _Safe_iterator_base* __x)
50	{ return __x->_M_singular(); }
51
52	/** \brief Safe iterator wrapper.
53	*
54	* The class template %_Safe_iterator is a wrapper around an
55	* iterator that tracks the iterator's movement among sequences and
56	* checks that operations performed on the "safe" iterator are
57	* legal. In additional to the basic iterator operations (which are
58	* validated, and then passed to the underlying iterator),
59	* %_Safe_iterator has member functions for iterator invalidation,
60	* attaching/detaching the iterator from sequences, and querying
61	* the iterator's state.
62	*/
63	template<typename _Iterator, typename _Sequence>
64	class _Safe_iterator : public _Safe_iterator_base
65	{
66	typedef _Safe_iterator _Self;
67
68	/** The precision to which we can calculate the distance between
69	* two iterators.
70	*/
71	enum _Distance_precision
72	{
73	__dp_equality, //< Can compare iterator equality, only
74	__dp_sign, //< Can determine equality and ordering
75	__dp_exact //< Can determine distance precisely
76	};
77
78	/// The underlying iterator
79	_Iterator _M_current;
80
81	/// Determine if this is a constant iterator.
82	bool
83	_M_constant() const
84	{
85	typedef typename _Sequence::const_iterator const_iterator;
86	return __is_same<const_iterator, _Safe_iterator>::value;
87	}
88
89	typedef iterator_traits<_Iterator> _Traits;
90
91	public:
92	typedef _Iterator _Base_iterator;
93	typedef typename _Traits::iterator_category iterator_category;
94	typedef typename _Traits::value_type value_type;
95	typedef typename _Traits::difference_type difference_type;
96	typedef typename _Traits::reference reference;
97	typedef typename _Traits::pointer pointer;
98
99	/// @post the iterator is singular and unattached
100	_Safe_iterator() : _M_current() { }
101
102	/**
103	* @brief Safe iterator construction from an unsafe iterator and
104	* its sequence.
105	*
106	* @pre @p seq is not NULL
107	* @post this is not singular
108	*/
109	_Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
110	: _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
111	{
112	_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
113	_M_message(__msg_init_singular)
114	._M_iterator(*this, "this"));
115	}
116
117	/**
118	* @brief Copy construction.
119	* @pre @p x is not singular
120	*/
121	_Safe_iterator(const _Safe_iterator& __x)
122	: _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
123	{
124	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
125	_M_message(__msg_init_copy_singular)
126	._M_iterator(*this, "this")
127	._M_iterator(__x, "other"));
128	}
129
130	/**
131	* @brief Converting constructor from a mutable iterator to a
132	* constant iterator.
133	*
134	* @pre @p x is not singular
135	*/
136	template<typename _MutableIterator>
137	_Safe_iterator(
138	const _Safe_iterator<_MutableIterator,
139	typename std::__enable_if<
140	_Sequence,
141	(std::__are_same<_MutableIterator,
142	typename _Sequence::iterator::_Base_iterator>::_M_type)
143	>::_M_type>& __x)
144	: _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
145	{
146	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
147	_M_message(__msg_init_const_singular)
148	._M_iterator(*this, "this")
149	._M_iterator(__x, "other"));
150	}
151
152	/**
153	* @brief Copy assignment.
154	* @pre @p x is not singular
155	*/
156	_Safe_iterator&
157	operator=(const _Safe_iterator& __x)
158	{
159	_GLIBCXX_DEBUG_VERIFY(!__x._M_singular(),
160	_M_message(__msg_copy_singular)
161	._M_iterator(*this, "this")
162	._M_iterator(__x, "other"));
163	_M_current = __x._M_current;
164	this->_M_attach(static_cast<_Sequence*>(__x._M_sequence));
165	return *this;
166	}
167
168	/**
169	* @brief Iterator dereference.
170	* @pre iterator is dereferenceable
171	*/
172	reference
173	operator*() const
174	{
175
176	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
177	_M_message(__msg_bad_deref)
178	._M_iterator(*this, "this"));
179	return *_M_current;
180	}
181
182	/**
183	* @brief Iterator dereference.
184	* @pre iterator is dereferenceable
185	* @todo Make this correct w.r.t. iterators that return proxies
186	* @todo Use addressof() instead of & operator
187	*/
188	pointer
189	operator->() const
190	{
191	_GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
192	_M_message(__msg_bad_deref)
193	._M_iterator(*this, "this"));
194	return &*_M_current;
195	}
196
197	// ------ Input iterator requirements ------
198	/**
199	* @brief Iterator preincrement
200	* @pre iterator is incrementable
201	*/
202	_Safe_iterator&
203	operator++()
204	{
205	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
206	_M_message(__msg_bad_inc)
207	._M_iterator(*this, "this"));
208	++_M_current;
209	return *this;
210	}
211
212	/**
213	* @brief Iterator postincrement
214	* @pre iterator is incrementable
215	*/
216	_Safe_iterator
217	operator++(int)
218	{
219	_GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
220	_M_message(__msg_bad_inc)
221	._M_iterator(*this, "this"));
222	_Safe_iterator __tmp(*this);
223	++_M_current;
224	return __tmp;
225	}
226
227	// ------ Bidirectional iterator requirements ------
228	/**
229	* @brief Iterator predecrement
230	* @pre iterator is decrementable
231	*/
232	_Safe_iterator&
233	operator--()
234	{
235	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
236	_M_message(__msg_bad_dec)
237	._M_iterator(*this, "this"));
238	--_M_current;
239	return *this;
240	}
241
242	/**
243	* @brief Iterator postdecrement
244	* @pre iterator is decrementable
245	*/
246	_Safe_iterator
247	operator--(int)
248	{
249	_GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
250	_M_message(__msg_bad_dec)
251	._M_iterator(*this, "this"));
252	_Safe_iterator __tmp(*this);
253	--_M_current;
254	return __tmp;
255	}
256
257	// ------ Random access iterator requirements ------
258	reference
259	operator[](const difference_type& __n) const
260	{
261	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
262	&& this->_M_can_advance(__n+1),
263	_M_message(__msg_iter_subscript_oob)
264	._M_iterator(*this)._M_integer(__n));
265
266	return _M_current[__n];
267	}
268
269	_Safe_iterator&
270	operator+=(const difference_type& __n)
271	{
272	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
273	_M_message(__msg_advance_oob)
274	._M_iterator(*this)._M_integer(__n));
275	_M_current += __n;
276	return *this;
277	}
278
279	_Safe_iterator
280	operator+(const difference_type& __n) const
281	{
282	_Safe_iterator __tmp(*this);
283	__tmp += __n;
284	return __tmp;
285	}
286
287	_Safe_iterator&
288	operator-=(const difference_type& __n)
289	{
290	_GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
291	_M_message(__msg_retreat_oob)
292	._M_iterator(*this)._M_integer(__n));
293	_M_current += -__n;
294	return *this;
295	}
296
297	_Safe_iterator
298	operator-(const difference_type& __n) const
299	{
300	_Safe_iterator __tmp(*this);
301	__tmp -= __n;
302	return __tmp;
303	}
304
305	// ------ Utilities ------
306	/**
307	* @brief Return the underlying iterator
308	*/
309	_Iterator
310	base() const { return _M_current; }
311
312	/**
313	* @brief Conversion to underlying non-debug iterator to allow
314	* better interaction with non-debug containers.
315	*/
316	operator _Iterator() const { return _M_current; }
317
318	/** Attach iterator to the given sequence. */
319	void
320	_M_attach(const _Sequence* __seq)
321	{
322	_Safe_iterator_base::_M_attach(const_cast<_Sequence*>(__seq),
323	_M_constant());
324	}
325
326	/** Invalidate the iterator, making it singular. */
327	void
328	_M_invalidate();
329
330	/// Is the iterator dereferenceable?
331	bool
332	_M_dereferenceable() const
333	{ return !this->_M_singular() && !_M_is_end(); }
334
335	/// Is the iterator incrementable?
336	bool
337	_M_incrementable() const { return this->_M_dereferenceable(); }
338
339	// Is the iterator decrementable?
340	bool
341	_M_decrementable() const { return !_M_singular() && !_M_is_begin(); }
342
343	// Can we advance the iterator @p __n steps (@p __n may be negative)
344	bool
345	_M_can_advance(const difference_type& __n) const;
346
347	// Is the iterator range [*this, __rhs) valid?
348	template<typename _Other>
349	bool
350	_M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const;
351
352	// The sequence this iterator references.
353	const _Sequence*
354	_M_get_sequence() const
355	{ return static_cast<const _Sequence*>(_M_sequence); }
356
357	/** Determine the distance between two iterators with some known
358	* precision.
359	*/
360	template<typename _Iterator1, typename _Iterator2>
361	static pair<difference_type, _Distance_precision>
362	_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs)
363	{
364	typedef typename iterator_traits<_Iterator1>::iterator_category
365	_Category;
366	return _M_get_distance(__lhs, __rhs, _Category());
367	}
368
369	template<typename _Iterator1, typename _Iterator2>
370	static pair<difference_type, _Distance_precision>
371	_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
372	std::random_access_iterator_tag)
373	{
374	return std::make_pair(__rhs.base() - __lhs.base(), __dp_exact);
375	}
376
377	template<typename _Iterator1, typename _Iterator2>
378	static pair<difference_type, _Distance_precision>
379	_M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
380	std::forward_iterator_tag)
381	{
382	return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1,
383	__dp_equality);
384	}
385
386	/// Is this iterator equal to the sequence's begin() iterator?
387	bool _M_is_begin() const
388	{ return this == static_cast<const _Sequence>(_M_sequence)->begin(); }
389
390	/// Is this iterator equal to the sequence's end() iterator?
391	bool _M_is_end() const
392	{ return this == static_cast<const _Sequence>(_M_sequence)->end(); }
393	};
394
395	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
396	inline bool
397	operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
398	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
399	{
400	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
401	_M_message(__msg_iter_compare_bad)
402	._M_iterator(__lhs, "lhs")
403	._M_iterator(__rhs, "rhs"));
404	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
405	_M_message(__msg_compare_different)
406	._M_iterator(__lhs, "lhs")
407	._M_iterator(__rhs, "rhs"));
408	return __lhs.base() == __rhs.base();
409	}
410
411	template<typename _Iterator, typename _Sequence>
412	inline bool
413	operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
414	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
415	{
416	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
417	_M_message(__msg_iter_compare_bad)
418	._M_iterator(__lhs, "lhs")
419	._M_iterator(__rhs, "rhs"));
420	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
421	_M_message(__msg_compare_different)
422	._M_iterator(__lhs, "lhs")
423	._M_iterator(__rhs, "rhs"));
424	return __lhs.base() == __rhs.base();
425	}
426
427	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
428	inline bool
429	operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
430	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
431	{
432	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
433	_M_message(__msg_iter_compare_bad)
434	._M_iterator(__lhs, "lhs")
435	._M_iterator(__rhs, "rhs"));
436	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
437	_M_message(__msg_compare_different)
438	._M_iterator(__lhs, "lhs")
439	._M_iterator(__rhs, "rhs"));
440	return __lhs.base() != __rhs.base();
441	}
442
443	template<typename _Iterator, typename _Sequence>
444	inline bool
445	operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
446	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
447	{
448	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
449	_M_message(__msg_iter_compare_bad)
450	._M_iterator(__lhs, "lhs")
451	._M_iterator(__rhs, "rhs"));
452	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
453	_M_message(__msg_compare_different)
454	._M_iterator(__lhs, "lhs")
455	._M_iterator(__rhs, "rhs"));
456	return __lhs.base() != __rhs.base();
457	}
458
459	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
460	inline bool
461	operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
462	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
463	{
464	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
465	_M_message(__msg_iter_order_bad)
466	._M_iterator(__lhs, "lhs")
467	._M_iterator(__rhs, "rhs"));
468	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
469	_M_message(__msg_order_different)
470	._M_iterator(__lhs, "lhs")
471	._M_iterator(__rhs, "rhs"));
472	return __lhs.base() < __rhs.base();
473	}
474
475	template<typename _Iterator, typename _Sequence>
476	inline bool
477	operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
478	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
479	{
480	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
481	_M_message(__msg_iter_order_bad)
482	._M_iterator(__lhs, "lhs")
483	._M_iterator(__rhs, "rhs"));
484	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
485	_M_message(__msg_order_different)
486	._M_iterator(__lhs, "lhs")
487	._M_iterator(__rhs, "rhs"));
488	return __lhs.base() < __rhs.base();
489	}
490
491	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
492	inline bool
493	operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
494	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
495	{
496	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
497	_M_message(__msg_iter_order_bad)
498	._M_iterator(__lhs, "lhs")
499	._M_iterator(__rhs, "rhs"));
500	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
501	_M_message(__msg_order_different)
502	._M_iterator(__lhs, "lhs")
503	._M_iterator(__rhs, "rhs"));
504	return __lhs.base() <= __rhs.base();
505	}
506
507	template<typename _Iterator, typename _Sequence>
508	inline bool
509	operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
510	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
511	{
512	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
513	_M_message(__msg_iter_order_bad)
514	._M_iterator(__lhs, "lhs")
515	._M_iterator(__rhs, "rhs"));
516	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
517	_M_message(__msg_order_different)
518	._M_iterator(__lhs, "lhs")
519	._M_iterator(__rhs, "rhs"));
520	return __lhs.base() <= __rhs.base();
521	}
522
523	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
524	inline bool
525	operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
526	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
527	{
528	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
529	_M_message(__msg_iter_order_bad)
530	._M_iterator(__lhs, "lhs")
531	._M_iterator(__rhs, "rhs"));
532	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
533	_M_message(__msg_order_different)
534	._M_iterator(__lhs, "lhs")
535	._M_iterator(__rhs, "rhs"));
536	return __lhs.base() > __rhs.base();
537	}
538
539	template<typename _Iterator, typename _Sequence>
540	inline bool
541	operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
542	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
543	{
544	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
545	_M_message(__msg_iter_order_bad)
546	._M_iterator(__lhs, "lhs")
547	._M_iterator(__rhs, "rhs"));
548	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
549	_M_message(__msg_order_different)
550	._M_iterator(__lhs, "lhs")
551	._M_iterator(__rhs, "rhs"));
552	return __lhs.base() > __rhs.base();
553	}
554
555	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
556	inline bool
557	operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
558	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
559	{
560	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
561	_M_message(__msg_iter_order_bad)
562	._M_iterator(__lhs, "lhs")
563	._M_iterator(__rhs, "rhs"));
564	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
565	_M_message(__msg_order_different)
566	._M_iterator(__lhs, "lhs")
567	._M_iterator(__rhs, "rhs"));
568	return __lhs.base() >= __rhs.base();
569	}
570
571	template<typename _Iterator, typename _Sequence>
572	inline bool
573	operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
574	const _Safe_iterator<_Iterator, _Sequence>& __rhs)
575	{
576	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
577	_M_message(__msg_iter_order_bad)
578	._M_iterator(__lhs, "lhs")
579	._M_iterator(__rhs, "rhs"));
580	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
581	_M_message(__msg_order_different)
582	._M_iterator(__lhs, "lhs")
583	._M_iterator(__rhs, "rhs"));
584	return __lhs.base() >= __rhs.base();
585	}
586
587	// _GLIBCXX_RESOLVE_LIB_DEFECTS
588	// According to the resolution of DR179 not only the various comparison
589	// operators but also operator- must accept mixed iterator/const_iterator
590	// parameters.
591	template<typename _IteratorL, typename _IteratorR, typename _Sequence>
592	inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
593	operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
594	const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
595	{
596	_GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
597	_M_message(__msg_distance_bad)
598	._M_iterator(__lhs, "lhs")
599	._M_iterator(__rhs, "rhs"));
600	_GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
601	_M_message(__msg_distance_different)
602	._M_iterator(__lhs, "lhs")
603	._M_iterator(__rhs, "rhs"));
604	return __lhs.base() - __rhs.base();
605	}
606
607	template<typename _Iterator, typename _Sequence>
608	inline _Safe_iterator<_Iterator, _Sequence>
609	operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
610	const _Safe_iterator<_Iterator, _Sequence>& __i)
611	{ return __i + __n; }
612	} // namespace __gnu_debug
613
614	#ifndef _GLIBCXX_EXPORT_TEMPLATE
615	# include <debug/safe_iterator.tcc>
616	#endif
617
618	#endif

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/newcon3bcm2_21bu/toolchain/include/c++/3.4.2/debug/safe_iterator.h

Download in other formats: