ReactOS 0.4.15-dev-7918-g2a2556c
concept_checks.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 1999
3 * Silicon Graphics Computer Systems, Inc.
4 *
5 * Permission to use, copy, modify, distribute and sell this software
6 * and its documentation for any purpose is hereby granted without fee,
7 * provided that the above copyright notice appear in all copies and
8 * that both that copyright notice and this permission notice appear
9 * in supporting documentation. Silicon Graphics makes no
10 * representations about the suitability of this software for any
11 * purpose. It is provided "as is" without express or implied warranty.
12 */
13
14#ifndef __CONCEPT_CHECKS_H
15#define __CONCEPT_CHECKS_H
16
17/*
18 Use these macro like assertions, but they assert properties
19 on types (usually template arguments). In technical terms they
20 verify whether a type "models" a "concept".
21
22 This set of requirements and the terminology used here is derived
23 from the book "Generic Programming and the STL" by Matt Austern
24 (Addison Wesley). For further information please consult that
25 book. The requirements also are intended to match the ANSI/ISO C++
26 standard.
27
28 This file covers the basic concepts and the iterator concepts.
29 There are several other files that provide the requirements
30 for the STL containers:
31 container_concepts.h
32 sequence_concepts.h
33 assoc_container_concepts.h
34
35 Jeremy Siek, 1999
36
37 TO DO:
38 - some issues with regards to concept classification and mutability
39 including AssociativeContianer -> ForwardContainer
40 and SortedAssociativeContainer -> ReversibleContainer
41 - HashedAssociativeContainer
42 - Allocator
43 - Function Object Concepts
44
45 */
46
47#ifndef _STLP_USE_CONCEPT_CHECKS
48
49// Some compilers lack the features that are necessary for concept checks.
50// On those compilers we define the concept check macros to do nothing.
51#define _STLP_REQUIRES(__type_var, __concept) do {} while(0)
52#define _STLP_CLASS_REQUIRES(__type_var, __concept) \
53 static int __##__type_var##_##__concept
54#define _STLP_CONVERTIBLE(__type_x, __type_y) do {} while(0)
55#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
56#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
57 static int __##__type_x##__type_y##_require_same_type
58#define _STLP_GENERATOR_CHECK(__func, __ret) do {} while(0)
59#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret) \
60 static int __##__func##__ret##_generator_check
61#define _STLP_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
62#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
63 static int __##__func##__ret##__arg##_unary_function_check
64#define _STLP_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
65 do {} while(0)
66#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
67 static int __##__func##__ret##__first##__second##_binary_function_check
68#define _STLP_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
69 do {} while(0)
70#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
71 static int __##__opname##__ret##__first##__second##_require_binary_op
72
73#else /* _STLP_USE_CONCEPT_CHECKS */
74
75// This macro tests whether the template argument "__type_var"
76// satisfies the requirements of "__concept". Here is a list of concepts
77// that we know how to check:
78// _Allocator
79// _Assignable
80// _DefaultConstructible
81// _EqualityComparable
82// _LessThanComparable
83// _TrivialIterator
84// _InputIterator
85// _OutputIterator
86// _ForwardIterator
87// _BidirectionalIterator
88// _RandomAccessIterator
89// _Mutable_TrivialIterator
90// _Mutable_ForwardIterator
91// _Mutable_BidirectionalIterator
92// _Mutable_RandomAccessIterator
93
94#define _STLP_REQUIRES(__type_var, __concept) \
95do { \
96 void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
97 ::##__concept##_requirement_violation; __x = __x; } while (0)
98
99// Use this to check whether type X is convertible to type Y
100#define _STLP_CONVERTIBLE(__type_x, __type_y) \
101do { \
102 void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
103 __type_y >::__type_X_is_not_convertible_to_type_Y; \
104 __x = __x; } while (0)
105
106// Use this to test whether two template arguments are the same type
107#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y) \
108do { \
109 void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
110 __type_y >::__type_X_not_same_as_type_Y; \
111 __x = __x; } while (0)
112
113
114// function object checks
115#define _STLP_GENERATOR_CHECK(__func, __ret) \
116do { \
117 __ret (*__x)( __func&) = \
118 _STL_GENERATOR_ERROR< \
119 __func, __ret>::__generator_requirement_violation; \
120 __x = __x; } while (0)
121
122
123#define _STLP_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
124do { \
125 __ret (*__x)( __func&, const __arg& ) = \
126 _STL_UNARY_FUNCTION_ERROR< \
127 __func, __ret, __arg>::__unary_function_requirement_violation; \
128 __x = __x; } while (0)
129
130
131#define _STLP_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
132do { \
133 __ret (*__x)( __func&, const __first&, const __second& ) = \
134 _STL_BINARY_FUNCTION_ERROR< \
135 __func, __ret, __first, __second>::__binary_function_requirement_violation; \
136 __x = __x; } while (0)
137
138
139#define _STLP_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
140 do { \
141 __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
142 __ret, __first, __second>::__binary_operator_requirement_violation; \
143 __ret (*__y)( const __first&, const __second& ) = \
144 _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
145 __const_binary_operator_requirement_violation; \
146 __y = __y; __x = __x; } while (0)
147
148
149#ifdef _STLP_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
150
151#define _STLP_CLASS_REQUIRES(__type_var, __concept)
152#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
153#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret)
154#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
155#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
156#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)
157
158#else
159
160// Use this macro inside of template classes, where you would
161// like to place requirements on the template arguments to the class
162// Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
163// since the type_var is used to construct identifiers. Instead typedef
164// the pointer type, then use the typedef name for the __type_var.
165#define _STLP_CLASS_REQUIRES(__type_var, __concept) \
166 typedef void (* __func##__type_var##__concept)( __type_var ); \
167 template <__func##__type_var##__concept _Tp1> \
168 struct __dummy_struct_##__type_var##__concept { }; \
169 static __dummy_struct_##__type_var##__concept< \
170 __concept##_concept_specification< \
171 __type_var>::__concept##_requirement_violation> \
172 __dummy_ptr_##__type_var##__concept
173
174
175#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
176 typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
177 __type_y ); \
178 template < __func_##__type_x##__type_y##same_type _Tp1> \
179 struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
180 static __dummy_struct_##__type_x##__type_y##_same_type< \
181 _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \
182 __dummy_ptr_##__type_x##__type_y##_same_type
183
184
185#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret) \
186 typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
187 template <__f_##__func##__ret##_generator _Tp1> \
188 struct __dummy_struct_##__func##__ret##_generator { }; \
189 static __dummy_struct_##__func##__ret##_generator< \
190 _STL_GENERATOR_ERROR< \
191 __func, __ret>::__generator_requirement_violation> \
192 __dummy_ptr_##__func##__ret##_generator
193
194
195#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
196 typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
197 const __arg& ); \
198 template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
199 struct __dummy_struct_##__func##__ret##__arg##_unary_check { }; \
200 static __dummy_struct_##__func##__ret##__arg##_unary_check< \
201 _STL_UNARY_FUNCTION_ERROR< \
202 __func, __ret, __arg>::__unary_function_requirement_violation> \
203 __dummy_ptr_##__func##__ret##__arg##_unary_check
204
205
206#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
207 typedef __ret (* __f_##__func##__ret##__first##__second##_binary_check)( __func&, const __first&,\
208 const __second& ); \
209 template <__f_##__func##__ret##__first##__second##_binary_check _Tp1> \
210 struct __dummy_struct_##__func##__ret##__first##__second##_binary_check { }; \
211 static __dummy_struct_##__func##__ret##__first##__second##_binary_check< \
212 _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
213 __binary_function_requirement_violation> \
214 __dummy_ptr_##__func##__ret##__first##__second##_binary_check
215
216
217#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
218 typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op)(const __first&, \
219 const __second& ); \
220 template <__f_##__func##__ret##__first##__second##_binary_op _Tp1> \
221 struct __dummy_struct_##__func##__ret##__first##__second##_binary_op { }; \
222 static __dummy_struct_##__func##__ret##__first##__second##_binary_op< \
223 _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
224 __binary_operator_requirement_violation> \
225 __dummy_ptr_##__func##__ret##__first##__second##_binary_op
226
227#endif
228
229/* helper class for finding non-const version of a type. Need to have
230 something to assign to etc. when testing constant iterators. */
231
232template <class _Tp>
233struct _Mutable_trait {
234 typedef _Tp _Type;
235};
236template <class _Tp>
237struct _Mutable_trait<const _Tp> {
238 typedef _Tp _Type;
239};
240
241
242/* helper function for avoiding compiler warnings about unused variables */
243template <class _Type>
244void __sink_unused_warning(_Type) { }
245
246template <class _TypeX, class _TypeY>
247struct _STL_CONVERT_ERROR {
248 static void
249 __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
250 _TypeY __y = __x;
251 __sink_unused_warning(__y);
252 }
253};
254
255
256template <class _Type> struct __check_equal { };
257
258template <class _TypeX, class _TypeY>
259struct _STL_SAME_TYPE_ERROR {
260 static void
261 __type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
262 __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
263 }
264};
265
266
267// Some Functon Object Checks
268
269template <class _Func, class _Ret>
270struct _STL_GENERATOR_ERROR {
271 static _Ret __generator_requirement_violation(_Func& __f) {
272 return __f();
273 }
274};
275
276template <class _Func>
277struct _STL_GENERATOR_ERROR<_Func, void> {
278 static void __generator_requirement_violation(_Func& __f) {
279 __f();
280 }
281};
282
283
284template <class _Func, class _Ret, class _Arg>
285struct _STL_UNARY_FUNCTION_ERROR {
286 static _Ret
287 __unary_function_requirement_violation(_Func& __f,
288 const _Arg& __arg) {
289 return __f(__arg);
290 }
291};
292
293template <class _Func, class _Arg>
294struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
295 static void
296 __unary_function_requirement_violation(_Func& __f,
297 const _Arg& __arg) {
298 __f(__arg);
299 }
300};
301
302template <class _Func, class _Ret, class _First, class _Second>
303struct _STL_BINARY_FUNCTION_ERROR {
304 static _Ret
305 __binary_function_requirement_violation(_Func& __f,
306 const _First& __first,
307 const _Second& __second) {
308 return __f(__first, __second);
309 }
310};
311
312template <class _Func, class _First, class _Second>
313struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
314 static void
315 __binary_function_requirement_violation(_Func& __f,
316 const _First& __first,
317 const _Second& __second) {
318 __f(__first, __second);
319 }
320};
321
322
323#define _STLP_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
324template <class _Ret, class _First, class _Second> \
325struct _STL_BINARY##_NAME##_ERROR { \
326 static _Ret \
327 __const_binary_operator_requirement_violation(const _First& __first, \
328 const _Second& __second) { \
329 return __first _OP __second; \
330 } \
331 static _Ret \
332 __binary_operator_requirement_violation(_First& __first, \
333 _Second& __second) { \
334 return __first _OP __second; \
335 } \
336}
337
338_STLP_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
339_STLP_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
340_STLP_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
341_STLP_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
342_STLP_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
343_STLP_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
344_STLP_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
345_STLP_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
346_STLP_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
347_STLP_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
348_STLP_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
349// ...
350
351// TODO, add unary operators (prefix and postfix)
352
353/*
354 The presence of this class is just to trick EDG into displaying
355 these error messages before any other errors. Without the
356 classes, the errors in the functions get reported after
357 other class errors deep inside the library. The name
358 choice just makes for an eye catching error message :)
359 */
360struct _STL_ERROR {
361
362 template <class _Type>
363 static _Type
364 __default_constructor_requirement_violation(_Type) {
365 return _Type();
366 }
367 template <class _Type>
368 static _Type
369 __assignment_operator_requirement_violation(_Type __a) {
370 __a = __a;
371 return __a;
372 }
373 template <class _Type>
374 static _Type
375 __copy_constructor_requirement_violation(_Type __a) {
376 _Type __c(__a);
377 return __c;
378 }
379 template <class _Type>
380 static _Type
381 __const_parameter_required_for_copy_constructor(_Type /* __a */,
382 const _Type& __b) {
383 _Type __c(__b);
384 return __c;
385 }
386 template <class _Type>
387 static _Type
388 __const_parameter_required_for_assignment_operator(_Type __a,
389 const _Type& __b) {
390 __a = __b;
391 return __a;
392 }
393 template <class _Type>
394 static _Type
395 __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
396 if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
397 return __b;
398 }
399 template <class _Type>
400 static _Type
401 __equality_comparable_requirement_violation(_Type __a, _Type __b) {
402 if (__a == __b || __a != __b) return __a;
403 return __b;
404 }
405 template <class _Iterator>
406 static void
407 __dereference_operator_requirement_violation(_Iterator __i) {
408 __sink_unused_warning(*__i);
409 }
410 template <class _Iterator>
411 static void
412 __dereference_operator_and_assignment_requirement_violation(_Iterator __i) {
413 *__i = *__i;
414 }
415 template <class _Iterator>
416 static void
417 __preincrement_operator_requirement_violation(_Iterator __i) {
418 ++__i;
419 }
420 template <class _Iterator>
421 static void
422 __postincrement_operator_requirement_violation(_Iterator __i) {
423 __i++;
424 }
425 template <class _Iterator>
426 static void
427 __predecrement_operator_requirement_violation(_Iterator __i) {
428 --__i;
429 }
430 template <class _Iterator>
431 static void
432 __postdecrement_operator_requirement_violation(_Iterator __i) {
433 __i--;
434 }
435 template <class _Iterator, class _Type>
436 static void
437 __postincrement_operator_and_assignment_requirement_violation(_Iterator __i,
438 _Type __t) {
439 *__i++ = __t;
440 }
441 template <class _Iterator, class _Distance>
442 static _Iterator
443 __iterator_addition_assignment_requirement_violation(_Iterator __i,
444 _Distance __n) {
445 __i += __n;
446 return __i;
447 }
448 template <class _Iterator, class _Distance>
449 static _Iterator
450 __iterator_addition_requirement_violation(_Iterator __i, _Distance __n) {
451 __i = __i + __n;
452 __i = __n + __i;
453 return __i;
454 }
455 template <class _Iterator, class _Distance>
456 static _Iterator
457 __iterator_subtraction_assignment_requirement_violation(_Iterator __i,
458 _Distance __n) {
459 __i -= __n;
460 return __i;
461 }
462 template <class _Iterator, class _Distance>
463 static _Iterator
464 __iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) {
465 __i = __i - __n;
466 return __i;
467 }
468 template <class _Iterator, class _Distance>
469 static _Distance
470 __difference_operator_requirement_violation(_Iterator __i, _Iterator __j,
471 _Distance __n) {
472 __n = __i - __j;
473 return __n;
474 }
475 template <class _Exp, class _Type, class _Distance>
476 static _Type
477 __element_access_operator_requirement_violation(_Exp __x, _Type*,
478 _Distance __n) {
479 return __x[__n];
480 }
481 template <class _Exp, class _Type, class _Distance>
482 static void
483 __element_assignment_operator_requirement_violation(_Exp __x,
484 _Type* __t,
485 _Distance __n) {
486 __x[__n] = *__t;
487 }
488
489}; /* _STL_ERROR */
490
491/* Associated Type Requirements */
492
493_STLP_BEGIN_NAMESPACE
494template <class _Iterator> struct iterator_traits;
495_STLP_END_NAMESPACE
496
497template <class _Iter>
498struct __value_type_type_definition_requirement_violation {
499 typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
500};
501
502template <class _Iter>
503struct __difference_type_type_definition_requirement_violation {
504 typedef typename __STD::iterator_traits<_Iter>::difference_type
505 difference_type;
506};
507
508template <class _Iter>
509struct __reference_type_definition_requirement_violation {
510 typedef typename __STD::iterator_traits<_Iter>::reference reference;
511};
512
513template <class _Iter>
514struct __pointer_type_definition_requirement_violation {
515 typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
516};
517
518template <class _Iter>
519struct __iterator_category_type_definition_requirement_violation {
520 typedef typename __STD::iterator_traits<_Iter>::iterator_category
521 iterator_category;
522};
523
524/* Assignable Requirements */
525
526
527template <class _Type>
528struct _Assignable_concept_specification {
529 static void _Assignable_requirement_violation(_Type __a) {
530 _STL_ERROR::__assignment_operator_requirement_violation(__a);
531 _STL_ERROR::__copy_constructor_requirement_violation(__a);
532 _STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a);
533 _STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a);
534 }
535};
536
537/* DefaultConstructible Requirements */
538
539
540template <class _Type>
541struct _DefaultConstructible_concept_specification {
542 static void _DefaultConstructible_requirement_violation(_Type __a) {
543 _STL_ERROR::__default_constructor_requirement_violation(__a);
544 }
545};
546
547/* EqualityComparable Requirements */
548
549template <class _Type>
550struct _EqualityComparable_concept_specification {
551 static void _EqualityComparable_requirement_violation(_Type __a) {
552 _STL_ERROR::__equality_comparable_requirement_violation(__a, __a);
553 }
554};
555
556/* LessThanComparable Requirements */
557template <class _Type>
558struct _LessThanComparable_concept_specification {
559 static void _LessThanComparable_requirement_violation(_Type __a) {
560 _STL_ERROR::__less_than_comparable_requirement_violation(__a, __a);
561 }
562};
563
564/* TrivialIterator Requirements */
565
566template <class _TrivialIterator>
567struct _TrivialIterator_concept_specification {
568static void
569_TrivialIterator_requirement_violation(_TrivialIterator __i) {
570 typedef typename
571 __value_type_type_definition_requirement_violation<_TrivialIterator>::
572 value_type __T;
573 // Refinement of Assignable
574 _Assignable_concept_specification<_TrivialIterator>::
575 _Assignable_requirement_violation(__i);
576 // Refinement of DefaultConstructible
577 _DefaultConstructible_concept_specification<_TrivialIterator>::
578 _DefaultConstructible_requirement_violation(__i);
579 // Refinement of EqualityComparable
580 _EqualityComparable_concept_specification<_TrivialIterator>::
581 _EqualityComparable_requirement_violation(__i);
582 // Valid Expressions
583 _STL_ERROR::__dereference_operator_requirement_violation(__i);
584}
585};
586
587template <class _TrivialIterator>
588struct _Mutable_TrivialIterator_concept_specification {
589static void
590_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) {
591 _TrivialIterator_concept_specification<_TrivialIterator>::
592 _TrivialIterator_requirement_violation(__i);
593 // Valid Expressions
594 _STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i);
595}
596};
597
598/* InputIterator Requirements */
599
600template <class _InputIterator>
601struct _InputIterator_concept_specification {
602static void
603_InputIterator_requirement_violation(_InputIterator __i) {
604 // Refinement of TrivialIterator
605 _TrivialIterator_concept_specification<_InputIterator>::
606 _TrivialIterator_requirement_violation(__i);
607 // Associated Types
608 __difference_type_type_definition_requirement_violation<_InputIterator>();
609 __reference_type_definition_requirement_violation<_InputIterator>();
610 __pointer_type_definition_requirement_violation<_InputIterator>();
611 __iterator_category_type_definition_requirement_violation<_InputIterator>();
612 // Valid Expressions
613 _STL_ERROR::__preincrement_operator_requirement_violation(__i);
614 _STL_ERROR::__postincrement_operator_requirement_violation(__i);
615}
616};
617
618/* OutputIterator Requirements */
619
620template <class _OutputIterator>
621struct _OutputIterator_concept_specification {
622static void
623_OutputIterator_requirement_violation(_OutputIterator __i) {
624 // Refinement of Assignable
625 _Assignable_concept_specification<_OutputIterator>::
626 _Assignable_requirement_violation(__i);
627 // Associated Types
628 __iterator_category_type_definition_requirement_violation<_OutputIterator>();
629 // Valid Expressions
630 _STL_ERROR::__dereference_operator_requirement_violation(__i);
631 _STL_ERROR::__preincrement_operator_requirement_violation(__i);
632 _STL_ERROR::__postincrement_operator_requirement_violation(__i);
633 _STL_ERROR::
634 __postincrement_operator_and_assignment_requirement_violation(__i, *__i);
635}
636};
637
638/* ForwardIterator Requirements */
639
640template <class _ForwardIterator>
641struct _ForwardIterator_concept_specification {
642static void
643_ForwardIterator_requirement_violation(_ForwardIterator __i) {
644 // Refinement of InputIterator
645 _InputIterator_concept_specification<_ForwardIterator>::
646 _InputIterator_requirement_violation(__i);
647}
648};
649
650template <class _ForwardIterator>
651struct _Mutable_ForwardIterator_concept_specification {
652static void
653_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) {
654 _ForwardIterator_concept_specification<_ForwardIterator>::
655 _ForwardIterator_requirement_violation(__i);
656 // Refinement of OutputIterator
657 _OutputIterator_concept_specification<_ForwardIterator>::
658 _OutputIterator_requirement_violation(__i);
659}
660};
661
662/* BidirectionalIterator Requirements */
663
664template <class _BidirectionalIterator>
665struct _BidirectionalIterator_concept_specification {
666static void
667_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) {
668 // Refinement of ForwardIterator
669 _ForwardIterator_concept_specification<_BidirectionalIterator>::
670 _ForwardIterator_requirement_violation(__i);
671 // Valid Expressions
672 _STL_ERROR::__predecrement_operator_requirement_violation(__i);
673 _STL_ERROR::__postdecrement_operator_requirement_violation(__i);
674}
675};
676
677template <class _BidirectionalIterator>
678struct _Mutable_BidirectionalIterator_concept_specification {
679static void
680_Mutable_BidirectionalIterator_requirement_violation(
681 _BidirectionalIterator __i)
682{
683 _BidirectionalIterator_concept_specification<_BidirectionalIterator>::
684 _BidirectionalIterator_requirement_violation(__i);
685 // Refinement of mutable_ForwardIterator
686 _Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>::
687 _Mutable_ForwardIterator_requirement_violation(__i);
688 typedef typename
689 __value_type_type_definition_requirement_violation<
690 _BidirectionalIterator>::value_type __T;
691 typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0;
692 // Valid Expressions
693 _STL_ERROR::
694 __postincrement_operator_and_assignment_requirement_violation(__i,
695 *__tmp_ptr);
696}
697};
698
699/* RandomAccessIterator Requirements */
700
701template <class _RandAccIter>
702struct _RandomAccessIterator_concept_specification {
703static void
704_RandomAccessIterator_requirement_violation(_RandAccIter __i) {
705 // Refinement of BidirectionalIterator
706 _BidirectionalIterator_concept_specification<_RandAccIter>::
707 _BidirectionalIterator_requirement_violation(__i);
708 // Refinement of LessThanComparable
709 _LessThanComparable_concept_specification<_RandAccIter>::
710 _LessThanComparable_requirement_violation(__i);
711 typedef typename
712 __value_type_type_definition_requirement_violation<_RandAccIter>
713 ::value_type
714 value_type;
715 typedef typename
716 __difference_type_type_definition_requirement_violation<_RandAccIter>
717 ::difference_type
718 _Dist;
719 typedef typename _Mutable_trait<_Dist>::_Type _MutDist;
720
721 // Valid Expressions
722 _STL_ERROR::__iterator_addition_assignment_requirement_violation(__i,
723 _MutDist());
724 _STL_ERROR::__iterator_addition_requirement_violation(__i,
725 _MutDist());
726 _STL_ERROR::
727 __iterator_subtraction_assignment_requirement_violation(__i,
728 _MutDist());
729 _STL_ERROR::__iterator_subtraction_requirement_violation(__i,
730 _MutDist());
731 _STL_ERROR::__difference_operator_requirement_violation(__i, __i,
732 _MutDist());
733 typename _Mutable_trait<value_type>::_Type* __dummy_ptr = 0;
734 _STL_ERROR::__element_access_operator_requirement_violation(__i,
735 __dummy_ptr,
736 _MutDist());
737}
738};
739
740template <class _RandAccIter>
741struct _Mutable_RandomAccessIterator_concept_specification {
742static void
743_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i)
744{
745 _RandomAccessIterator_concept_specification<_RandAccIter>::
746 _RandomAccessIterator_requirement_violation(__i);
747 // Refinement of mutable_BidirectionalIterator
748 _Mutable_BidirectionalIterator_concept_specification<_RandAccIter>::
749 _Mutable_BidirectionalIterator_requirement_violation(__i);
750 typedef typename
751 __value_type_type_definition_requirement_violation<_RandAccIter>
752 ::value_type
753 value_type;
754 typedef typename
755 __difference_type_type_definition_requirement_violation<_RandAccIter>
756 ::difference_type
757 _Dist;
758
759 typename _Mutable_trait<value_type>::_Type* __tmp_ptr = 0;
760 // Valid Expressions
761 _STL_ERROR::__element_assignment_operator_requirement_violation(__i,
762 __tmp_ptr, _Dist());
763}
764};
765
766#define _STLP_TYPEDEF_REQUIREMENT(__REQUIREMENT) \
767template <class Type> \
768struct __##__REQUIREMENT##__typedef_requirement_violation { \
769 typedef typename Type::__REQUIREMENT __REQUIREMENT; \
770};
771
772_STLP_TYPEDEF_REQUIREMENT(value_type);
773_STLP_TYPEDEF_REQUIREMENT(difference_type);
774_STLP_TYPEDEF_REQUIREMENT(size_type);
775_STLP_TYPEDEF_REQUIREMENT(reference);
776_STLP_TYPEDEF_REQUIREMENT(const_reference);
777_STLP_TYPEDEF_REQUIREMENT(pointer);
778_STLP_TYPEDEF_REQUIREMENT(const_pointer);
779
780
781template <class _Alloc>
782struct _Allocator_concept_specification {
783static void
784_Allocator_requirement_violation(_Alloc __a) {
785 // Refinement of DefaultConstructible
786 _DefaultConstructible_concept_specification<_Alloc>::
787 _DefaultConstructible_requirement_violation(__a);
788 // Refinement of EqualityComparable
789 _EqualityComparable_concept_specification<_Alloc>::
790 _EqualityComparable_requirement_violation(__a);
791 // Associated Types
792 __value_type__typedef_requirement_violation<_Alloc>();
793 __difference_type__typedef_requirement_violation<_Alloc>();
794 __size_type__typedef_requirement_violation<_Alloc>();
795 __reference__typedef_requirement_violation<_Alloc>();
796 __const_reference__typedef_requirement_violation<_Alloc>();
797 __pointer__typedef_requirement_violation<_Alloc>();
798 __const_pointer__typedef_requirement_violation<_Alloc>();
799 typedef typename _Alloc::value_type _Type;
800 _STLP_REQUIRES_SAME_TYPE(typename _Alloc::rebind<_Type>::other, _Alloc);
801}
802};
803
804#endif /* _STLP_USE_CONCEPT_CHECKS */
805
806#endif /* __CONCEPT_CHECKS_H */
807
808// Local Variables:
809// mode:C++
810// End:
__n
return __n
Definition: _algo.h:75
_Alloc
#define _Alloc
Definition: _bvector.h:330
_STLP_REQUIRES_SAME_TYPE
#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y)
Definition: concept_checks.h:55
_STLP_BEGIN_NAMESPACE
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
_STLP_END_NAMESPACE
#define _STLP_END_NAMESPACE
Definition: features.h:503
pointer
GLsizei const GLvoid * pointer
Definition: glext.h:5848
reference
GLint reference
Definition: glext.h:11729
__c
#define __c
Definition: schilyio.h:209
iterator_traits
Definition: _iterator_base.h:147
__T
#define __T(x)
Definition: vfdio.h:17
_Exp
_CRTIMP short __cdecl _Exp(double *, double, short)
const
#define const
Definition: zconf.h:233