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:
811