开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > STL > 查看源码
concept_.h
资源名称：STL_doc.rar　[点击查看]
上传用户：nizebo
上传日期：2022-05-14
资源大小：882k
文件大小：28k
源码类别：

STL

开发平台：

Visual C++

concept_.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.  */
  14. #ifndef __CONCEPT_CHECKS_H
  15. #define __CONCEPT_CHECKS_H
  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".
  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.
  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
  35.   Jeremy Siek, 1999
  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
  45.   */
  47. #ifndef __STL_USE_CONCEPT_CHECKS
  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 __STL_REQUIRES(__type_var, __concept) do {} while(0)
  52. #define __STL_CLASS_REQUIRES(__type_var, __concept) 
  53.   static int  __##__type_var##_##__concept
  54. #define __STL_CONVERTIBLE(__type_x, __type_y) do {} while(0)
  55. #define __STL_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
  56. #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) 
  57.   static int  __##__type_x##__type_y##_require_same_type
  58. #define __STL_GENERATOR_CHECK(__func, __ret) do {} while(0)
  59. #define __STL_CLASS_GENERATOR_CHECK(__func, __ret) 
  60.   static int  __##__func##__ret##_generator_check
  61. #define __STL_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
  62. #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) 
  63.   static int  __##__func##__ret##__arg##_unary_function_check
  64. #define __STL_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) 
  65.   do {} while(0)
  66. #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) 
  67.   static int  __##__func##__ret##__first##__second##_binary_function_check
  68. #define __STL_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) 
  69.   do {} while(0)
  70. #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) 
  71.   static int __##__opname##__ret##__first##__second##_require_binary_op
  73. #else /* __STL_USE_CONCEPT_CHECKS */
  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
  94. #define __STL_REQUIRES(__type_var, __concept) 
  95. do { 
  96.   void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >
  97.     ::__concept##_requirement_violation; __x = __x; } while (0)
  99. // Use this to check whether type X is convertible to type Y
  100. #define __STL_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)
  106. // Use this to test whether two template arguments are the same type
  107. #define __STL_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)
  114. // function object checks
  115. #define __STL_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)
  123. #define __STL_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)
  131. #define __STL_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)
  139. #define __STL_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)
  149. #ifdef __STL_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
  151. #define __STL_CLASS_REQUIRES(__type_var, __concept)
  152. #define __STL_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
  153. #define __STL_CLASS_GENERATOR_CHECK(__func, __ret)
  154. #define __STL_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
  155. #define __STL_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
  156. #define __STL_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)
  158. #else
  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 __STL_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
  175. #define __STL_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
  185. #define __STL_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
  195. #define __STL_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
  206. #define __STL_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
  217. #define __STL_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
  227. #endif
  229. /* helper class for finding non-const version of a type. Need to have
  230.    something to assign to etc. when testing constant iterators. */
  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. };
  242. /* helper function for avoiding compiler warnings about unused variables */
  243. template <class _Type>
  244. void __sink_unused_warning(_Type) { }
  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. };
  256. template <class _Type> struct __check_equal { };
  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. };
  267. // Some Functon Object Checks
  269. template <class _Func, class _Ret>
  270. struct _STL_GENERATOR_ERROR {
  271.   static _Ret __generator_requirement_violation(_Func& __f) {
  272.     return __f();
  273.   }
  274. };
  276. template <class _Func>
  277. struct _STL_GENERATOR_ERROR<_Func, void> {
  278.   static void __generator_requirement_violation(_Func& __f) {
  279.     __f();
  280.   }
  281. };
  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. };
  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. };
  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. };
  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. };
  323. #define __STL_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. }
  338. __STL_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
  339. __STL_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
  340. __STL_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
  341. __STL_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
  342. __STL_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
  343. __STL_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
  344. __STL_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
  345. __STL_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
  346. __STL_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
  347. __STL_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
  348. __STL_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
  349. // ...
  351. // TODO, add unary operators (prefix and postfix)
  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 {
  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.   }
  489. }; /* _STL_ERROR */
  491. /* Associated Type Requirements */
  493. __STL_BEGIN_NAMESPACE
  494. template <class _Iterator> struct iterator_traits;
  495. __STL_END_NAMESPACE
  497. template <class _Iter> 
  498. struct __value_type_type_definition_requirement_violation {
  499.   typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
  500. };
  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. };
  508. template <class _Iter> 
  509. struct __reference_type_definition_requirement_violation {
  510.   typedef typename __STD::iterator_traits<_Iter>::reference reference;
  511. };
  513. template <class _Iter> 
  514. struct __pointer_type_definition_requirement_violation {
  515.   typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
  516. };
  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. };
  524. /* Assignable Requirements */
  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. };
  537. /* DefaultConstructible Requirements */
  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. };
  547. /* EqualityComparable Requirements */
  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. };
  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. };
  564. /* TrivialIterator Requirements */
  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. };
  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. };
  598. /* InputIterator Requirements */
  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. };
  618. /* OutputIterator Requirements */
  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. };
  638. /* ForwardIterator Requirements */
  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. };
  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. };
  662. /* BidirectionalIterator Requirements */
  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. };
  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. };
  699. /* RandomAccessIterator Requirements */
  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;
  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. };
  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;
  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. };
  766. #define __STL_TYPEDEF_REQUIREMENT(__REQUIREMENT) 
  767. template <class Type> 
  768. struct __##__REQUIREMENT##__typedef_requirement_violation { 
  769.   typedef typename Type::__REQUIREMENT __REQUIREMENT; 
  770. }
  772. __STL_TYPEDEF_REQUIREMENT(value_type);
  773. __STL_TYPEDEF_REQUIREMENT(difference_type);
  774. __STL_TYPEDEF_REQUIREMENT(size_type);
  775. __STL_TYPEDEF_REQUIREMENT(reference);
  776. __STL_TYPEDEF_REQUIREMENT(const_reference);
  777. __STL_TYPEDEF_REQUIREMENT(pointer);
  778. __STL_TYPEDEF_REQUIREMENT(const_pointer);
  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 _Tp;
  800.   //__STL_REQUIRES_SAME_TYPE(typename _Alloc::__STL_TEMPLATE rebind<_Tp>::other,
  801.   //                         _Alloc);
  802. }
  803. };
  805. #endif /* __STL_USE_CONCEPT_CHECKS */
  807. #endif /* __CONCEPT_CHECKS_H */
  809. // Local Variables:
  810. // mode:C++
  811. // End: