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