include/c++/stl/stl/concept_checks.h

   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
 493 _STLP_BEGIN_NAMESPACE
 494 template <class _Iterator> struct iterator_traits;
 495 _STLP_END_NAMESPACE
 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 {
 510   typedef typename __STD::iterator_traits<_Iter>::reference reference;
 511 };
 512
 513 template <class _Iter>
 514 struct __pointer_type_definition_requirement_violation {
 515   typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
 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;
 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: