ReactOS 0.4.15-dev-7674-gc0b4db1
_unordered_map.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2004
3 * Francois Dumont
4 *
5 * This material is provided "as is", with absolutely no warranty expressed
6 * or implied. Any use is at your own risk.
7 *
8 * Permission to use or copy this software for any purpose is hereby granted
9 * without fee, provided the above notices are retained on all copies.
10 * Permission to modify the code and to distribute modified code is granted,
11 * provided the above notices are retained, and a notice that the code was
12 * modified is included with the above copyright notice.
13 *
14 */
15
16/* NOTE: This is an internal header file, included by other STL headers.
17 * You should not attempt to use it directly.
18 */
19
20#ifndef _STLP_INTERNAL_UNORDERED_MAP_H
21#define _STLP_INTERNAL_UNORDERED_MAP_H
22
23#ifndef _STLP_INTERNAL_HASHTABLE_H
24# include <stl/_hashtable.h>
25#endif
26
28
29//Specific iterator traits creation
30_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMapTraitsT, traits)
31
33
34template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
35 _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
36 _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
38#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
39 : public __stlport_class<unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
40#endif
41{
42private:
44public:
45 typedef _Key key_type;
46 typedef _Tp data_type;
47 typedef _Tp mapped_type;
49private:
50 //Specific iterator traits creation
51 typedef _STLP_PRIV _UnorderedMapTraitsT<value_type> _UnorderedMapTraits;
52
53public:
55 _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
56
57 typedef typename _Ht::hasher hasher;
58 typedef typename _Ht::key_equal key_equal;
59
60 typedef typename _Ht::size_type size_type;
62 typedef typename _Ht::pointer pointer;
64 typedef typename _Ht::reference reference;
66
67 typedef typename _Ht::iterator iterator;
71
73
74 hasher hash_function() const { return _M_ht.hash_funct(); }
75 key_equal key_eq() const { return _M_ht.key_eq(); }
77
78private:
81
82public:
83 explicit unordered_map(size_type __n = 0, const hasher& __hf = hasher(),
84 const key_equal& __eql = key_equal(),
85 const allocator_type& __a = allocator_type())
86 : _M_ht(__n, __hf, __eql, __a) {}
87
88#if !defined (_STLP_NO_MOVE_SEMANTIC)
91#endif
92
93#if defined (_STLP_MEMBER_TEMPLATES)
94 template <class _InputIterator>
95 unordered_map(_InputIterator __f, _InputIterator __l,
96 size_type __n = 0, const hasher& __hf = hasher(),
97 const key_equal& __eql = key_equal(),
98 const allocator_type& __a = allocator_type())
99 : _M_ht(__n, __hf, __eql, __a)
100 { _M_ht.insert_unique(__f, __l); }
101#else
102 unordered_map(const value_type* __f, const value_type* __l,
103 size_type __n = 0, const hasher& __hf = hasher(),
104 const key_equal& __eql = key_equal(),
105 const allocator_type& __a = allocator_type())
106 : _M_ht(__n, __hf, __eql, __a)
107 { _M_ht.insert_unique(__f, __l); }
108
110 size_type __n = 0, const hasher& __hf = hasher(),
111 const key_equal& __eql = key_equal(),
112 const allocator_type& __a = allocator_type())
113 : _M_ht(__n, __hf, __eql, __a)
114 { _M_ht.insert_unique(__f, __l); }
115#endif /*_STLP_MEMBER_TEMPLATES */
116
117 _Self& operator = (const _Self& __other)
118 { _M_ht = __other._M_ht; return *this; }
119
120 size_type size() const { return _M_ht.size(); }
121 size_type max_size() const { return _M_ht.max_size(); }
122 bool empty() const { return _M_ht.empty(); }
123 void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
124#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
125 void _M_swap_workaround(_Self& __x) { swap(__x); }
126#endif
127
128 iterator begin() { return _M_ht.begin(); }
129 iterator end() { return _M_ht.end(); }
130 const_iterator begin() const { return _M_ht.begin(); }
131 const_iterator end() const { return _M_ht.end(); }
132
134 { return _M_ht.insert_unique(__obj); }
135 iterator insert(const_iterator /*__hint*/, const value_type& __obj)
136 { return _M_ht.insert_unique(__obj); }
137#if defined (_STLP_MEMBER_TEMPLATES)
138 template <class _InputIterator>
139 void insert(_InputIterator __f, _InputIterator __l)
140#else
141 void insert(const value_type* __f, const value_type* __l)
142 { _M_ht.insert_unique(__f,__l); }
144#endif /*_STLP_MEMBER_TEMPLATES */
145 { _M_ht.insert_unique(__f, __l); }
146
148 iterator find(const _KT& __key) { return _M_ht.find(__key); }
150 const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
151
153 _Tp& operator[](const _KT& __key) {
154 iterator __it = _M_ht.find(__key);
155 return (__it == _M_ht.end() ?
157 (*__it).second );
158 }
159
161 size_type count(const _KT& __key) const { return _M_ht.count(__key); }
162
165 { return _M_ht.equal_range(__key); }
168 { return _M_ht.equal_range(__key); }
169
170 size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
172 void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
173 void clear() { _M_ht.clear(); }
174
179 size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
184
185 float load_factor() const { return _M_ht.load_factor(); }
186 float max_load_factor() const { return _M_ht.max_load_factor(); }
188 void rehash(size_type __hint) { _M_ht.rehash(__hint); }
189
190#if defined (__DMC__) // disable operator==(pair<x,unordered_map>, pair<x,unordered_map>)
191 bool operator==(const _Self&) const;
192#endif
193};
194
196
197//Specific iterator traits creation
198_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMultimapTraitsT, traits)
199
201
202template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
203 _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
204 _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
206#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
207 : public __stlport_class<unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
208#endif
209{
210private:
212public:
213 typedef _Key key_type;
214 typedef _Tp data_type;
215 typedef _Tp mapped_type;
217private:
218 //Specific iterator traits creation
219 typedef _STLP_PRIV _UnorderedMultimapTraitsT<value_type> _UnorderedMultimapTraits;
220
221public:
223 _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
224
225 typedef typename _Ht::hasher hasher;
226 typedef typename _Ht::key_equal key_equal;
227
228 typedef typename _Ht::size_type size_type;
230 typedef typename _Ht::pointer pointer;
232 typedef typename _Ht::reference reference;
234
235 typedef typename _Ht::iterator iterator;
239
241
242 hasher hash_function() const { return _M_ht.hash_funct(); }
243 key_equal key_eq() const { return _M_ht.key_eq(); }
245
246private:
249
250public:
251 explicit unordered_multimap(size_type __n = 0, const hasher& __hf = hasher(),
252 const key_equal& __eql = key_equal(),
253 const allocator_type& __a = allocator_type())
254 : _M_ht(__n, __hf, __eql, __a) {}
255
256#if !defined (_STLP_NO_MOVE_SEMANTIC)
259#endif
260
261#if defined (_STLP_MEMBER_TEMPLATES)
262 template <class _InputIterator>
263 unordered_multimap(_InputIterator __f, _InputIterator __l,
264 size_type __n = 0, const hasher& __hf = hasher(),
265 const key_equal& __eql = key_equal(),
266 const allocator_type& __a = allocator_type())
267 : _M_ht(__n, __hf, __eql, __a)
268 { _M_ht.insert_equal(__f, __l); }
269#else
271 size_type __n = 0, const hasher& __hf = hasher(),
272 const key_equal& __eql = key_equal(),
273 const allocator_type& __a = allocator_type())
274 : _M_ht(__n, __hf, __eql, __a)
275 { _M_ht.insert_equal(__f, __l); }
276
278 size_type __n = 0, const hasher& __hf = hasher(),
279 const key_equal& __eql = key_equal(),
280 const allocator_type& __a = allocator_type())
281 : _M_ht(__n, __hf, __eql, __a)
282 { _M_ht.insert_equal(__f, __l); }
283#endif /*_STLP_MEMBER_TEMPLATES */
284
285 _Self& operator = (const _Self& __other)
286 { _M_ht = __other._M_ht; return *this; }
287
288 size_type size() const { return _M_ht.size(); }
289 size_type max_size() const { return _M_ht.max_size(); }
290 bool empty() const { return _M_ht.empty(); }
291 void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
292#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
293 void _M_swap_workaround(_Self& __x) { swap(__x); }
294#endif
295
296 iterator begin() { return _M_ht.begin(); }
297 iterator end() { return _M_ht.end(); }
298 const_iterator begin() const { return _M_ht.begin(); }
299 const_iterator end() const { return _M_ht.end(); }
300
302 { return _M_ht.insert_equal(__obj); }
303 iterator insert(const_iterator /*__hint*/, const value_type& __obj)
304 { return _M_ht.insert_equal(__obj); }
305#if defined (_STLP_MEMBER_TEMPLATES)
306 template <class _InputIterator>
307 void insert(_InputIterator __f, _InputIterator __l)
308#else
309 void insert(const value_type* __f, const value_type* __l)
310 { _M_ht.insert_equal(__f,__l); }
312#endif /*_STLP_MEMBER_TEMPLATES */
313 { _M_ht.insert_equal(__f, __l); }
314
316 iterator find(const _KT& __key) { return _M_ht.find(__key); }
318 const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
319
321 size_type count(const _KT& __key) const { return _M_ht.count(__key); }
322
325 { return _M_ht.equal_range(__key); }
328 { return _M_ht.equal_range(__key); }
329
330 size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
332 void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
333 void clear() { _M_ht.clear(); }
334
339 size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
344
345 float load_factor() const { return _M_ht.load_factor(); }
346 float max_load_factor() const { return _M_ht.max_load_factor(); }
348 void rehash(size_type __hint) { _M_ht.rehash(__hint); }
349};
350
351#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
352#define _STLP_TEMPLATE_CONTAINER unordered_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
353
355
356#undef _STLP_TEMPLATE_CONTAINER
357#define _STLP_TEMPLATE_CONTAINER unordered_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
358
360
361#undef _STLP_TEMPLATE_CONTAINER
362#undef _STLP_TEMPLATE_HEADER
363
365
366// Specialization of insert_iterator so that it will work for unordered_map
367// and unordered_multimap.
368
369#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
370# if !defined (_STLP_NO_MOVE_SEMANTIC)
371template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
372struct __move_traits<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
373 _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
374{};
375
376template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
377struct __move_traits<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
378 _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
379{};
380# endif
381
382template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
383class insert_iterator<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
384protected:
386 _Container* container;
387public:
388 typedef _Container container_type;
390 typedef void value_type;
391 typedef void difference_type;
392 typedef void pointer;
393 typedef void reference;
394
395 insert_iterator(_Container& __x) : container(&__x) {}
396 insert_iterator(_Container& __x, typename _Container::iterator)
397 : container(&__x) {}
399 operator=(const typename _Container::value_type& __val) {
400 container->insert(__val);
401 return *this;
402 }
403 insert_iterator<_Container>& operator*() { return *this; }
404 insert_iterator<_Container>& operator++() { return *this; }
405 insert_iterator<_Container>& operator++(int) { return *this; }
406};
407
408template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
409class insert_iterator<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
410protected:
412 _Container* container;
413 typename _Container::iterator iter;
414public:
415 typedef _Container container_type;
417 typedef void value_type;
418 typedef void difference_type;
419 typedef void pointer;
420 typedef void reference;
421
422 insert_iterator(_Container& __x) : container(&__x) {}
423 insert_iterator(_Container& __x, typename _Container::iterator)
424 : container(&__x) {}
426 operator=(const typename _Container::value_type& __val) {
427 container->insert(__val);
428 return *this;
429 }
430 insert_iterator<_Container>& operator*() { return *this; }
431 insert_iterator<_Container>& operator++() { return *this; }
432 insert_iterator<_Container>& operator++(int) { return *this; }
433};
434
435#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
436
438
439#endif /* _STLP_INTERNAL_UNORDERED_MAP_H */
440
441// Local Variables:
442// mode:C++
443// End:
return __n
Definition: _algo.h:75
_STLP_INLINE_LOOP _InputIter const _Tp & __val
Definition: _algobase.h:656
#define _Alloc
Definition: _bvector.h:330
#define _STLP_DEFAULT_CONSTRUCTED(_TTp)
Definition: _construct.h:265
#define _STLP_PRIV
Definition: _dm.h:70
#define _STLP_SELECT1ST(__x, __y)
#define _STLP_CREATE_HASH_ITERATOR_TRAITS(Motif, Traits)
_STLP_MOVE_TO_PRIV_NAMESPACE const _InputIterator const input_iterator_tag &_InputIterator __it(__first)
void get(int argc, const char *argv[])
Definition: cmds.c:480
reference _M_insert(const value_type &__obj)
Definition: _hashtable.c:254
size_type erase(const key_type &__key)
Definition: _hashtable.c:263
allocator_type get_allocator() const
Definition: _hashtable.h:300
key_equal key_eq() const
Definition: _hashtable.h:247
iterator insert_equal(const value_type &__obj)
Definition: _hashtable.h:412
pair< iterator, bool > insert_unique(const value_type &__obj)
Definition: _hashtable.h:407
iterator end()
Definition: _hashtable.h:377
bool empty() const
Definition: _hashtable.h:365
size_type bucket_count() const
Definition: _hashtable.h:391
float max_load_factor() const
Definition: _hashtable.h:401
size_type max_bucket_count() const
Definition: _hashtable.h:392
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
Definition: _hashtable.h:534
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
Definition: _hashtable.h:511
size_type max_size() const
Definition: _hashtable.h:364
void swap(_Self &__ht)
Definition: _hashtable.h:367
size_type elems_in_bucket(size_type __bucket) const
Definition: _hashtable.h:393
size_type size() const
Definition: _hashtable.h:363
void rehash(size_type __num_buckets_hint)
Definition: _hashtable.c:365
void clear()
Definition: _hashtable.c:501
iterator begin()
Definition: _hashtable.h:376
float load_factor() const
Definition: _hashtable.h:400
hasher hash_funct() const
Definition: _hashtable.h:246
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
Definition: _hashtable.h:397
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
Definition: _hashtable.h:516
output_iterator_tag iterator_category
Definition: _iterator.h:229
_Self & operator=(_Self const &__other)
Definition: _iterator.h:233
_Self & operator++()
Definition: _iterator.h:244
_Container * container
Definition: _iterator.h:225
_Container container_type
Definition: _iterator.h:228
_Self & operator*()
Definition: _iterator.h:243
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
iterator end()
hashtable< value_type, key_type, _HashFcn, _UnorderedMapTraits, _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht
size_type max_bucket_count() const
_Ht::const_reference const_reference
size_type bucket_size(size_type __n) const
const_iterator end() const
_Ht::reference reference
const_local_iterator end(size_type __n) const
const_local_iterator begin(size_type __n) const
unordered_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > _Self
iterator begin()
float load_factor() const
size_type erase(const key_type &__key)
_Self & operator=(const _Self &__other)
_Ht::iterator iterator
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
_Ht::pointer pointer
_STLP_TEMPLATE_FOR_CONT_EXT _Tp & operator[](const _KT &__key)
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
unordered_map(const_iterator __f, const_iterator __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
allocator_type get_allocator() const
bool empty() const
_Ht::hasher hasher
size_type size() const
size_type bucket_count() const
_Ht::const_pointer const_pointer
void erase(const_iterator __f, const_iterator __l)
_STLP_TEMPLATE_FOR_CONT_EXT const_iterator find(const _KT &__key) const
local_iterator end(size_type __n)
pair< iterator, bool > insert(const value_type &__obj)
const_iterator begin() const
void max_load_factor(float __val)
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
local_iterator begin(size_type __n)
void insert(const_iterator __f, const_iterator __l)
_Ht::local_iterator local_iterator
void swap(_Self &__hs)
void insert(const value_type *__f, const value_type *__l)
_STLP_PRIV _UnorderedMapTraitsT< value_type > _UnorderedMapTraits
_Ht::allocator_type allocator_type
size_type max_size() const
_Ht::key_equal key_equal
_Ht::const_local_iterator const_local_iterator
unordered_map(const value_type *__f, const value_type *__l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
key_equal key_eq() const
pair< _STLP_CONST key_type, data_type > value_type
void rehash(size_type __hint)
_Ht::difference_type difference_type
unordered_map(__move_source< _Self > src)
_Ht::size_type size_type
_Ht::const_iterator const_iterator
unordered_map(size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
hasher hash_function() const
float max_load_factor() const
iterator insert(const_iterator, const value_type &__obj)
_STLP_TEMPLATE_FOR_CONT_EXT pair< const_iterator, const_iterator > equal_range(const _KT &__key) const
void erase(const_iterator __it)
_STLP_TEMPLATE_FOR_CONT_EXT pair< const_iterator, const_iterator > equal_range(const _KT &__key) const
unordered_multimap(__move_source< _Self > src)
_Ht::allocator_type allocator_type
_Ht::iterator iterator
_Ht::size_type size_type
void swap(_Self &__hs)
_STLP_TEMPLATE_FOR_CONT_EXT const_iterator find(const _KT &__key) const
_Ht::difference_type difference_type
_Ht::reference reference
unordered_multimap(const_iterator __f, const_iterator __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
const_local_iterator begin(size_type __n) const
void insert(const value_type *__f, const value_type *__l)
void rehash(size_type __hint)
const_local_iterator end(size_type __n) const
size_type erase(const key_type &__key)
const_iterator begin() const
iterator insert(const_iterator, const value_type &__obj)
void max_load_factor(float __val)
size_type bucket_size(size_type __n) const
_Ht::const_iterator const_iterator
void insert(const_iterator __f, const_iterator __l)
hasher hash_function() const
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
const_iterator end() const
unordered_multimap(const value_type *__f, const value_type *__l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
size_type max_bucket_count() const
_STLP_PRIV _UnorderedMultimapTraitsT< value_type > _UnorderedMultimapTraits
_Ht::const_reference const_reference
void erase(const_iterator __it)
unordered_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > _Self
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
allocator_type get_allocator() const
hashtable< value_type, key_type, _HashFcn, _UnorderedMultimapTraits, _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht
float load_factor() const
unordered_multimap(size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
_Ht::const_pointer const_pointer
size_type max_size() const
pair< _STLP_CONST key_type, data_type > value_type
size_type size() const
size_type bucket_count() const
key_equal key_eq() const
_Ht::local_iterator local_iterator
bool empty() const
float max_load_factor() const
_Ht::const_local_iterator const_local_iterator
iterator insert(const value_type &__obj)
local_iterator end(size_type __n)
_Self & operator=(const _Self &__other)
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
void erase(const_iterator __f, const_iterator __l)
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
_Ht::pointer pointer
_Ht::key_equal key_equal
local_iterator begin(size_type __n)
#define _STLP_TEMPLATE_FOR_CONT_EXT
Definition: features.h:623
#define _STLP_BEGIN_TR1_NAMESPACE
Definition: features.h:502
#define _STLP_TR1
Definition: features.h:518
#define _STLP_KEY_TYPE_FOR_CONT_EXT(type)
Definition: features.h:622
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
#define _STLP_END_NAMESPACE
Definition: features.h:503
GLenum src
Definition: glext.h:6340
GLsizei const GLvoid * pointer
Definition: glext.h:5848
GLint reference
Definition: glext.h:11729
if(dx< 0)
Definition: linetemp.h:194
#define swap(a, b)
Definition: qsort.c:63
Definition: _pair.h:47
bool operator==(const TKeyDef &t1, const TKeyDef &t2)
Definition: tkeydef.cpp:122
static int insert
Definition: xmllint.c:138