ReactOS  0.4.15-dev-3440-g915569a
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) \
95 do { \
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) \
101 do { \
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) \
108 do { \
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) \
116 do { \
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) \
124 do { \
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) \
132 do { \
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 
232 template <class _Tp>
233 struct _Mutable_trait {
234  typedef _Tp _Type;
235 };
236 template <class _Tp>
237 struct _Mutable_trait<const _Tp> {
238  typedef _Tp _Type;
239 };
240 
241 
242 /* helper function for avoiding compiler warnings about unused variables */
243 template <class _Type>
244 void __sink_unused_warning(_Type) { }
245 
246 template <class _TypeX, class _TypeY>
247 struct _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 
256 template <class _Type> struct __check_equal { };
257 
258 template <class _TypeX, class _TypeY>
259 struct _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 
269 template <class _Func, class _Ret>
270 struct _STL_GENERATOR_ERROR {
271  static _Ret __generator_requirement_violation(_Func& __f) {
272  return __f();
273  }
274 };
275 
276 template <class _Func>
277 struct _STL_GENERATOR_ERROR<_Func, void> {
278  static void __generator_requirement_violation(_Func& __f) {
279  __f();
280  }
281 };
282 
283 
284 template <class _Func, class _Ret, class _Arg>
285 struct _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 
293 template <class _Func, class _Arg>
294 struct _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 
302 template <class _Func, class _Ret, class _First, class _Second>
303 struct _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 
312 template <class _Func, class _First, class _Second>
313 struct _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) \
324 template <class _Ret, class _First, class _Second> \
325 struct _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  */
360 struct _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 
494 template <class _Iterator> struct iterator_traits;
496 
497 template <class _Iter>
498 struct __value_type_type_definition_requirement_violation {
499  typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
500 };
501 
502 template <class _Iter>
503 struct __difference_type_type_definition_requirement_violation {
504  typedef typename __STD::iterator_traits<_Iter>::difference_type
505  difference_type;
506 };
507 
508 template <class _Iter>
509 struct __reference_type_definition_requirement_violation {
511 };
512 
513 template <class _Iter>
514 struct __pointer_type_definition_requirement_violation {
516 };
517 
518 template <class _Iter>
519 struct __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 
527 template <class _Type>
528 struct _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 
540 template <class _Type>
541 struct _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 
549 template <class _Type>
550 struct _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 */
557 template <class _Type>
558 struct _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 
566 template <class _TrivialIterator>
567 struct _TrivialIterator_concept_specification {
568 static 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 
587 template <class _TrivialIterator>
588 struct _Mutable_TrivialIterator_concept_specification {
589 static 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 
600 template <class _InputIterator>
601 struct _InputIterator_concept_specification {
602 static 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 
620 template <class _OutputIterator>
621 struct _OutputIterator_concept_specification {
622 static 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 
640 template <class _ForwardIterator>
641 struct _ForwardIterator_concept_specification {
642 static void
643 _ForwardIterator_requirement_violation(_ForwardIterator __i) {
644  // Refinement of InputIterator
645  _InputIterator_concept_specification<_ForwardIterator>::
646  _InputIterator_requirement_violation(__i);
647 }
648 };
649 
650 template <class _ForwardIterator>
651 struct _Mutable_ForwardIterator_concept_specification {
652 static 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 
664 template <class _BidirectionalIterator>
665 struct _BidirectionalIterator_concept_specification {
666 static 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 
677 template <class _BidirectionalIterator>
678 struct _Mutable_BidirectionalIterator_concept_specification {
679 static 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 
701 template <class _RandAccIter>
702 struct _RandomAccessIterator_concept_specification {
703 static 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 
740 template <class _RandAccIter>
741 struct _Mutable_RandomAccessIterator_concept_specification {
742 static 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) \
767 template <class Type> \
768 struct __##__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 
781 template <class _Alloc>
782 struct _Allocator_concept_specification {
783 static 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;
801 }
802 };
803 
804 #endif /* _STLP_USE_CONCEPT_CHECKS */
805 
806 #endif /* __CONCEPT_CHECKS_H */
807 
808 // Local Variables:
809 // mode:C++
810 // End:
return __n
Definition: _algo.h:75
GLsizei const GLvoid * pointer
Definition: glext.h:5848
#define _Alloc
Definition: _bvector.h:330
int other
Definition: msacm.c:1376
#define __T(x)
Definition: vfdio.h:17
#define __c
Definition: schilyio.h:209
_CRTIMP short __cdecl _Exp(double *, double, short)
#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y)
GLint reference
Definition: glext.h:11729
#define _STLP_END_NAMESPACE
Definition: features.h:503
#define const
Definition: zconf.h:230
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501