libstdc++
boost_concept_check.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 
3 // Copyright (C) 2004-2025 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 // (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
26 // sell and distribute this software is granted provided this
27 // copyright notice appears in all copies. This software is provided
28 // "as is" without express or implied warranty, and with no claim as
29 // to its suitability for any purpose.
30 //
31 
32 /** @file bits/boost_concept_check.h
33  * This is an internal header file, included by other library headers.
34  * Do not attempt to use it directly. @headername{iterator}
35  */
36 
37 // GCC Note: based on version 1.12.0 of the Boost library.
38 
39 #ifndef _BOOST_CONCEPT_CHECK_H
40 #define _BOOST_CONCEPT_CHECK_H 1
41 
42 #ifdef _GLIBCXX_SYSHDR
43 #pragma GCC system_header
44 #endif
45 
46 #include <bits/c++config.h>
47 #include <bits/stl_iterator_base_types.h> // for traits and tags
48 
49 namespace std _GLIBCXX_VISIBILITY(default)
50 {
51 _GLIBCXX_BEGIN_NAMESPACE_VERSION
52 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
53  struct _Bit_iterator;
54  struct _Bit_const_iterator;
55 _GLIBCXX_END_NAMESPACE_CONTAINER
56 _GLIBCXX_END_NAMESPACE_VERSION
57 }
58 
59 namespace __gnu_debug
60 {
61  template<typename _Iterator, typename _Sequence, typename _Category>
62  class _Safe_iterator;
63 }
64 
65 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
66 {
67 _GLIBCXX_BEGIN_NAMESPACE_VERSION
68 
69 #pragma GCC diagnostic push
70 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
71 
72 #define _IsUnused __attribute__ ((__unused__))
73 
74 // When the C-C code is in use, we would like this function to do as little
75 // as possible at runtime, use as few resources as possible, and hopefully
76 // be elided out of existence... hmmm.
77 template <class _Concept>
78 _GLIBCXX14_CONSTEXPR inline void __function_requires()
79 {
80  void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
81 }
82 
83 // No definition: if this is referenced, there's a problem with
84 // the instantiating type not being one of the required integer types.
85 // Unfortunately, this results in a link-time error, not a compile-time error.
86 void __error_type_must_be_an_integer_type();
87 void __error_type_must_be_an_unsigned_integer_type();
88 void __error_type_must_be_a_signed_integer_type();
89 
90 // ??? Should the "concept_checking*" structs begin with more than _ ?
91 #define _GLIBCXX_CLASS_REQUIRES(_type_var, _ns, _concept) \
92  typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \
93  template <_func##_type_var##_concept _Tp1> \
94  struct _concept_checking##_type_var##_concept { }; \
95  typedef _concept_checking##_type_var##_concept< \
96  &_ns::_concept <_type_var>::__constraints> \
97  _concept_checking_typedef##_type_var##_concept
98 
99 #define _GLIBCXX_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \
100  typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \
101  template <_func##_type_var1##_type_var2##_concept _Tp1> \
102  struct _concept_checking##_type_var1##_type_var2##_concept { }; \
103  typedef _concept_checking##_type_var1##_type_var2##_concept< \
104  &_ns::_concept <_type_var1,_type_var2>::__constraints> \
105  _concept_checking_typedef##_type_var1##_type_var2##_concept
106 
107 #define _GLIBCXX_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \
108  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \
109  template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \
110  struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \
111  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \
112  &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints> \
113  _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept
114 
115 #define _GLIBCXX_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \
116  typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \
117  template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \
118  struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \
119  typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \
120  &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \
121  _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept
122 
123 
124 template <class _Tp1, class _Tp2>
125 struct _Aux_require_same { };
126 
127 template <class _Tp>
128 struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; };
129 
130  template <class _Tp1, class _Tp2>
131  struct _SameTypeConcept
132  {
133  void __constraints() {
134  typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
135  }
136  };
137 
138  template <class _Tp>
139  struct _IntegerConcept {
140  void __constraints() {
141  __error_type_must_be_an_integer_type();
142  }
143  };
144  template <> struct _IntegerConcept<short> { void __constraints() {} };
145  template <> struct _IntegerConcept<unsigned short> { void __constraints(){} };
146  template <> struct _IntegerConcept<int> { void __constraints() {} };
147  template <> struct _IntegerConcept<unsigned int> { void __constraints() {} };
148  template <> struct _IntegerConcept<long> { void __constraints() {} };
149  template <> struct _IntegerConcept<unsigned long> { void __constraints() {} };
150  template <> struct _IntegerConcept<long long> { void __constraints() {} };
151  template <> struct _IntegerConcept<unsigned long long>
152  { void __constraints() {} };
153 
154  template <class _Tp>
155  struct _SignedIntegerConcept {
156  void __constraints() {
157  __error_type_must_be_a_signed_integer_type();
158  }
159  };
160  template <> struct _SignedIntegerConcept<short> { void __constraints() {} };
161  template <> struct _SignedIntegerConcept<int> { void __constraints() {} };
162  template <> struct _SignedIntegerConcept<long> { void __constraints() {} };
163  template <> struct _SignedIntegerConcept<long long> { void __constraints(){}};
164 
165  template <class _Tp>
166  struct _UnsignedIntegerConcept {
167  void __constraints() {
168  __error_type_must_be_an_unsigned_integer_type();
169  }
170  };
171  template <> struct _UnsignedIntegerConcept<unsigned short>
172  { void __constraints() {} };
173  template <> struct _UnsignedIntegerConcept<unsigned int>
174  { void __constraints() {} };
175  template <> struct _UnsignedIntegerConcept<unsigned long>
176  { void __constraints() {} };
177  template <> struct _UnsignedIntegerConcept<unsigned long long>
178  { void __constraints() {} };
179 
180  //===========================================================================
181  // Basic Concepts
182 
183  template <class _Tp>
184  struct _DefaultConstructibleConcept
185  {
186  void __constraints() {
187  _Tp __a _IsUnused; // require default constructor
188  }
189  };
190 
191  template <class _Tp>
192  struct _AssignableConcept
193  {
194  void __constraints() {
195  __a = __a; // require assignment operator
196  __const_constraints(__a);
197  }
198  void __const_constraints(const _Tp& __b) {
199  __a = __b; // const required for argument to assignment
200  }
201  _Tp __a;
202  // possibly should be "Tp* a;" and then dereference "a" in constraint
203  // functions? present way would require a default ctor, i think...
204  };
205 
206  template <class _Tp>
207  struct _CopyConstructibleConcept
208  {
209  void __constraints() {
210  _Tp __a(__b); // require copy constructor
211  _Tp* __ptr _IsUnused = &__a; // require address of operator
212  __const_constraints(__a);
213  }
214  void __const_constraints(const _Tp& __a) {
215  _Tp __c _IsUnused(__a); // require const copy constructor
216  const _Tp* __ptr _IsUnused = &__a; // require const address of operator
217  }
218  _Tp __b;
219  };
220 
221  // The SGI STL version of Assignable requires copy constructor and operator=
222  template <class _Tp>
223  struct _SGIAssignableConcept
224  {
225  void __constraints() {
226  _Tp __b _IsUnused(__a);
227  __a = __a; // require assignment operator
228  __const_constraints(__a);
229  }
230  void __const_constraints(const _Tp& __b) {
231  _Tp __c _IsUnused(__b);
232  __a = __b; // const required for argument to assignment
233  }
234  _Tp __a;
235  };
236 
237  template <class _From, class _To>
238  struct _ConvertibleConcept
239  {
240  void __constraints() {
241  _To __y _IsUnused = __x;
242  }
243  _From __x;
244  };
245 
246  // The C++ standard requirements for many concepts talk about return
247  // types that must be "convertible to bool". The problem with this
248  // requirement is that it leaves the door open for evil proxies that
249  // define things like operator|| with strange return types. Two
250  // possible solutions are:
251  // 1) require the return type to be exactly bool
252  // 2) stay with convertible to bool, and also
253  // specify stuff about all the logical operators.
254  // For now we just test for convertible to bool.
255  template <class _Tp>
256  void __aux_require_boolean_expr(const _Tp& __t) {
257  bool __x _IsUnused = __t;
258  }
259 
260 // FIXME
261  template <class _Tp>
262  struct _EqualityComparableConcept
263  {
264  void __constraints() {
265  __aux_require_boolean_expr(__a == __b);
266  }
267  _Tp __a, __b;
268  };
269 
270  template <class _Tp>
271  struct _LessThanComparableConcept
272  {
273  void __constraints() {
274  __aux_require_boolean_expr(__a < __b);
275  }
276  _Tp __a, __b;
277  };
278 
279  // This is equivalent to SGI STL's LessThanComparable.
280  template <class _Tp>
281  struct _ComparableConcept
282  {
283  void __constraints() {
284  __aux_require_boolean_expr(__a < __b);
285  __aux_require_boolean_expr(__a > __b);
286  __aux_require_boolean_expr(__a <= __b);
287  __aux_require_boolean_expr(__a >= __b);
288  }
289  _Tp __a, __b;
290  };
291 
292 #define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
293  template <class _First, class _Second> \
294  struct _NAME { \
295  void __constraints() { (void)__constraints_(); } \
296  bool __constraints_() { \
297  return __a _OP __b; \
298  } \
299  _First __a; \
300  _Second __b; \
301  }
302 
303 #define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
304  template <class _Ret, class _First, class _Second> \
305  struct _NAME { \
306  void __constraints() { (void)__constraints_(); } \
307  _Ret __constraints_() { \
308  return __a _OP __b; \
309  } \
310  _First __a; \
311  _Second __b; \
312  }
313 
314  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept);
315  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept);
316  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept);
317  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept);
318  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept);
319  _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept);
320 
321  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept);
322  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept);
323  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept);
324  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept);
325  _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept);
326 
327 #undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
328 #undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT
329 
330  //===========================================================================
331  // Function Object Concepts
332 
333  template <class _Func, class _Return>
334  struct _GeneratorConcept
335  {
336  void __constraints() {
337  const _Return& __r _IsUnused = __f();// require operator() member function
338  }
339  _Func __f;
340  };
341 
342 
343  template <class _Func>
344  struct _GeneratorConcept<_Func,void>
345  {
346  void __constraints() {
347  __f(); // require operator() member function
348  }
349  _Func __f;
350  };
351 
352  template <class _Func, class _Return, class _Arg>
353  struct _UnaryFunctionConcept
354  {
355  void __constraints() {
356  __r = __f(__arg); // require operator()
357  }
358  _Func __f;
359  _Arg __arg;
360  _Return __r;
361  };
362 
363  template <class _Func, class _Arg>
364  struct _UnaryFunctionConcept<_Func, void, _Arg> {
365  void __constraints() {
366  __f(__arg); // require operator()
367  }
368  _Func __f;
369  _Arg __arg;
370  };
371 
372  template <class _Func, class _Return, class _First, class _Second>
373  struct _BinaryFunctionConcept
374  {
375  void __constraints() {
376  __r = __f(__first, __second); // require operator()
377  }
378  _Func __f;
379  _First __first;
380  _Second __second;
381  _Return __r;
382  };
383 
384  template <class _Func, class _First, class _Second>
385  struct _BinaryFunctionConcept<_Func, void, _First, _Second>
386  {
387  void __constraints() {
388  __f(__first, __second); // require operator()
389  }
390  _Func __f;
391  _First __first;
392  _Second __second;
393  };
394 
395  template <class _Func, class _Arg>
396  struct _UnaryPredicateConcept
397  {
398  void __constraints() {
399  __aux_require_boolean_expr(__f(__arg)); // require op() returning bool
400  }
401  _Func __f;
402  _Arg __arg;
403  };
404 
405  template <class _Func, class _First, class _Second>
406  struct _BinaryPredicateConcept
407  {
408  void __constraints() {
409  __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool
410  }
411  _Func __f;
412  _First __a;
413  _Second __b;
414  };
415 
416  // use this when functor is used inside a container class like std::set
417  template <class _Func, class _First, class _Second>
418  struct _Const_BinaryPredicateConcept {
419  void __constraints() {
420  __const_constraints(__f);
421  }
422  void __const_constraints(const _Func& __fun) {
423  __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
424  // operator() must be a const member function
425  __aux_require_boolean_expr(__fun(__a, __b));
426  }
427  _Func __f;
428  _First __a;
429  _Second __b;
430  };
431 
432  //===========================================================================
433  // Iterator Concepts
434 
435  template <class _Tp>
436  struct _TrivialIteratorConcept
437  {
438  void __constraints() {
439 // __function_requires< _DefaultConstructibleConcept<_Tp> >();
440  __function_requires< _AssignableConcept<_Tp> >();
441  __function_requires< _EqualityComparableConcept<_Tp> >();
442 // typedef typename std::iterator_traits<_Tp>::value_type _V;
443  (void)*__i; // require dereference operator
444  }
445  _Tp __i;
446  };
447 
448  template <class _Tp>
449  struct _Mutable_TrivialIteratorConcept
450  {
451  void __constraints() {
452  __function_requires< _TrivialIteratorConcept<_Tp> >();
453  *__i = *__j; // require dereference and assignment
454  }
455  _Tp __i, __j;
456  };
457 
458  template <class _Tp>
459  struct _InputIteratorConcept
460  {
461  void __constraints() {
462  __function_requires< _TrivialIteratorConcept<_Tp> >();
463  // require iterator_traits typedef's
464  typedef typename std::iterator_traits<_Tp>::difference_type _Diff;
465 // __function_requires< _SignedIntegerConcept<_Diff> >();
466  typedef typename std::iterator_traits<_Tp>::reference _Ref;
467  typedef typename std::iterator_traits<_Tp>::pointer _Pt;
468  typedef typename std::iterator_traits<_Tp>::iterator_category _Cat;
469  __function_requires< _ConvertibleConcept<
472  ++__i; // require preincrement operator
473  __i++; // require postincrement operator
474  }
475  _Tp __i;
476  };
477 
478  template <class _Tp, class _ValueT>
479  struct _OutputIteratorConcept
480  {
481  void __constraints() {
482  __function_requires< _AssignableConcept<_Tp> >();
483  ++__i; // require preincrement operator
484  __i++; // require postincrement operator
485  *__i++ = __val(); // require postincrement and assignment
486  }
487  _Tp __i;
488  // Use a function pointer here so no definition of the function needed.
489  // Just need something that returns a _ValueT (which might be a reference).
490  _ValueT (*__val)();
491  };
492 
493  template<typename _Tp>
494  struct _Is_vector_bool_iterator
495  { static const bool __value = false; };
496 
497 #ifdef _GLIBCXX_DEBUG
498  namespace __cont = ::std::_GLIBCXX_STD_C;
499 #else
500  namespace __cont = ::std;
501 #endif
502 
503  // Trait to identify vector<bool>::iterator
504  template <>
505  struct _Is_vector_bool_iterator<__cont::_Bit_iterator>
506  { static const bool __value = true; };
507 
508  // And for vector<bool>::const_iterator.
509  template <>
510  struct _Is_vector_bool_iterator<__cont::_Bit_const_iterator>
511  { static const bool __value = true; };
512 
513  // And for __gnu_debug::vector<bool> iterators too.
514  template <typename _It, typename _Seq, typename _Tag>
515  struct _Is_vector_bool_iterator<__gnu_debug::_Safe_iterator<_It, _Seq, _Tag> >
516  : _Is_vector_bool_iterator<_It> { };
517 
518  template <class _Tp, bool = _Is_vector_bool_iterator<_Tp>::__value>
519  struct _ForwardIteratorReferenceConcept
520  {
521  void __constraints() {
522 #if __cplusplus >= 201103L
523  typedef typename std::iterator_traits<_Tp>::reference _Ref;
524  static_assert(std::is_reference<_Ref>::value,
525  "reference type of a forward iterator must be a real reference");
526 #endif
527  }
528  };
529 
530  template <class _Tp, bool = _Is_vector_bool_iterator<_Tp>::__value>
531  struct _Mutable_ForwardIteratorReferenceConcept
532  {
533  void __constraints() {
534  typedef typename std::iterator_traits<_Tp>::reference _Ref;
535  typedef typename std::iterator_traits<_Tp>::value_type _Val;
536  __function_requires< _SameTypeConcept<_Ref, _Val&> >();
537  }
538  };
539 
540  // vector<bool> iterators are not real forward iterators, but we ignore that.
541  template <class _Tp>
542  struct _ForwardIteratorReferenceConcept<_Tp, true>
543  {
544  void __constraints() { }
545  };
546 
547  // vector<bool> iterators are not real forward iterators, but we ignore that.
548  template <class _Tp>
549  struct _Mutable_ForwardIteratorReferenceConcept<_Tp, true>
550  {
551  void __constraints() { }
552  };
553 
554 #pragma GCC diagnostic push
555 #pragma GCC diagnostic ignored "-Wunused-variable"
556 
557  template <class _Tp>
558  struct _ForwardIteratorConcept
559  {
560  void __constraints() {
561  __function_requires< _InputIteratorConcept<_Tp> >();
562  __function_requires< _DefaultConstructibleConcept<_Tp> >();
563  __function_requires< _ConvertibleConcept<
566  __function_requires< _ForwardIteratorReferenceConcept<_Tp> >();
567  _Tp& __j = ++__i;
568  const _Tp& __k = __i++;
569  typedef typename std::iterator_traits<_Tp>::reference _Ref;
570  _Ref __r = *__k;
571  _Ref __r2 = *__i++;
572  }
573  _Tp __i;
574  };
575 
576  template <class _Tp>
577  struct _Mutable_ForwardIteratorConcept
578  {
579  void __constraints() {
580  __function_requires< _ForwardIteratorConcept<_Tp> >();
581  typedef typename std::iterator_traits<_Tp>::reference _Ref;
582  typedef typename std::iterator_traits<_Tp>::value_type _Val;
583  __function_requires< _Mutable_ForwardIteratorReferenceConcept<_Tp> >();
584  }
585  _Tp __i;
586  };
587 
588  template <class _Tp>
589  struct _BidirectionalIteratorConcept
590  {
591  void __constraints() {
592  __function_requires< _ForwardIteratorConcept<_Tp> >();
593  __function_requires< _ConvertibleConcept<
596  _Tp& __j = --__i; // require predecrement operator
597  const _Tp& __k = __i--; // require postdecrement operator
598  typedef typename std::iterator_traits<_Tp>::reference _Ref;
599  _Ref __r = *__j--;
600  }
601  _Tp __i;
602  };
603 
604  template <class _Tp>
605  struct _Mutable_BidirectionalIteratorConcept
606  {
607  void __constraints() {
608  __function_requires< _BidirectionalIteratorConcept<_Tp> >();
609  __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
610  }
611  _Tp __i;
612  };
613 
614 
615  template <class _Tp>
616  struct _RandomAccessIteratorConcept
617  {
618  void __constraints() {
619  __function_requires< _BidirectionalIteratorConcept<_Tp> >();
620  __function_requires< _ComparableConcept<_Tp> >();
621  __function_requires< _ConvertibleConcept<
624  typedef typename std::iterator_traits<_Tp>::reference _Ref;
625 
626  _Tp& __j = __i += __n; // require assignment addition operator
627  __i = __i + __n; __i = __n + __i; // require addition with difference type
628  _Tp& __k = __i -= __n; // require assignment subtraction op
629  __i = __i - __n; // require subtraction with
630  // difference type
631  __n = __i - __j; // require difference operator
632  _Ref __r = __i[__n]; // require element access operator
633  }
634  _Tp __a, __b;
635  _Tp __i, __j;
637  };
638 
639  template <class _Tp>
640  struct _Mutable_RandomAccessIteratorConcept
641  {
642  void __constraints() {
643  __function_requires< _RandomAccessIteratorConcept<_Tp> >();
644  __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
645  }
646  _Tp __i;
648  };
649 
650 #pragma GCC diagnostic pop
651 
652  //===========================================================================
653  // Container Concepts
654 
655  template <class _Container>
656  struct _ContainerConcept
657  {
658  typedef typename _Container::value_type _Value_type;
659  typedef typename _Container::difference_type _Difference_type;
660  typedef typename _Container::size_type _Size_type;
661  typedef typename _Container::const_reference _Const_reference;
662  typedef typename _Container::const_pointer _Const_pointer;
663  typedef typename _Container::const_iterator _Const_iterator;
664 
665  void __constraints() {
666  __function_requires< _InputIteratorConcept<_Const_iterator> >();
667  __function_requires< _AssignableConcept<_Container> >();
668  const _Container __c;
669  __i = __c.begin();
670  __i = __c.end();
671  __n = __c.size();
672  __n = __c.max_size();
673  __b = __c.empty();
674  }
675  bool __b;
676  _Const_iterator __i;
677  _Size_type __n;
678  };
679 
680  template <class _Container>
681  struct _Mutable_ContainerConcept
682  {
683  typedef typename _Container::value_type _Value_type;
684  typedef typename _Container::reference _Reference;
685  typedef typename _Container::iterator _Iterator;
686  typedef typename _Container::pointer _Pointer;
687 
688  void __constraints() {
689  __function_requires< _ContainerConcept<_Container> >();
690  __function_requires< _AssignableConcept<_Value_type> >();
691  __function_requires< _InputIteratorConcept<_Iterator> >();
692 
693  __i = __c.begin();
694  __i = __c.end();
695  __c.swap(__c2);
696  }
697  _Iterator __i;
698  _Container __c, __c2;
699  };
700 
701  template <class _ForwardContainer>
702  struct _ForwardContainerConcept
703  {
704  void __constraints() {
705  __function_requires< _ContainerConcept<_ForwardContainer> >();
706  typedef typename _ForwardContainer::const_iterator _Const_iterator;
707  __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
708  }
709  };
710 
711  template <class _ForwardContainer>
712  struct _Mutable_ForwardContainerConcept
713  {
714  void __constraints() {
715  __function_requires< _ForwardContainerConcept<_ForwardContainer> >();
716  __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >();
717  typedef typename _ForwardContainer::iterator _Iterator;
718  __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >();
719  }
720  };
721 
722  template <class _ReversibleContainer>
723  struct _ReversibleContainerConcept
724  {
725  typedef typename _ReversibleContainer::const_iterator _Const_iterator;
726  typedef typename _ReversibleContainer::const_reverse_iterator
727  _Const_reverse_iterator;
728 
729  void __constraints() {
730  __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
731  __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
732  __function_requires<
733  _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
734 
735  const _ReversibleContainer __c;
736  _Const_reverse_iterator __i = __c.rbegin();
737  __i = __c.rend();
738  }
739  };
740 
741  template <class _ReversibleContainer>
742  struct _Mutable_ReversibleContainerConcept
743  {
744  typedef typename _ReversibleContainer::iterator _Iterator;
745  typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
746 
747  void __constraints() {
748  __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
749  __function_requires<
750  _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
751  __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
752  __function_requires<
753  _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
754 
755  _Reverse_iterator __i = __c.rbegin();
756  __i = __c.rend();
757  }
758  _ReversibleContainer __c;
759  };
760 
761  template <class _RandomAccessContainer>
762  struct _RandomAccessContainerConcept
763  {
764  typedef typename _RandomAccessContainer::size_type _Size_type;
765  typedef typename _RandomAccessContainer::const_reference _Const_reference;
766  typedef typename _RandomAccessContainer::const_iterator _Const_iterator;
767  typedef typename _RandomAccessContainer::const_reverse_iterator
768  _Const_reverse_iterator;
769 
770  void __constraints() {
771  __function_requires<
772  _ReversibleContainerConcept<_RandomAccessContainer> >();
773  __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
774  __function_requires<
775  _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
776 
777  const _RandomAccessContainer __c;
778  _Const_reference __r _IsUnused = __c[__n];
779  }
780  _Size_type __n;
781  };
782 
783  template <class _RandomAccessContainer>
784  struct _Mutable_RandomAccessContainerConcept
785  {
786  typedef typename _RandomAccessContainer::size_type _Size_type;
787  typedef typename _RandomAccessContainer::reference _Reference;
788  typedef typename _RandomAccessContainer::iterator _Iterator;
789  typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator;
790 
791  void __constraints() {
792  __function_requires<
793  _RandomAccessContainerConcept<_RandomAccessContainer> >();
794  __function_requires<
795  _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
796  __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
797  __function_requires<
798  _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
799 
800  _Reference __r _IsUnused = __c[__i];
801  }
802  _Size_type __i;
803  _RandomAccessContainer __c;
804  };
805 
806  // A Sequence is inherently mutable
807  template <class _Sequence>
808  struct _SequenceConcept
809  {
810  typedef typename _Sequence::reference _Reference;
811  typedef typename _Sequence::const_reference _Const_reference;
812 
813  void __constraints() {
814  // Matt Austern's book puts DefaultConstructible here, the C++
815  // standard places it in Container
816  // function_requires< DefaultConstructible<Sequence> >();
817  __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
818  __function_requires< _DefaultConstructibleConcept<_Sequence> >();
819 
820  _Sequence
821  __c _IsUnused(__n, __t),
822  __c2 _IsUnused(__first, __last);
823 
824  __c.insert(__p, __t);
825  __c.insert(__p, __n, __t);
826  __c.insert(__p, __first, __last);
827 
828  __c.erase(__p);
829  __c.erase(__p, __q);
830 
831  _Reference __r _IsUnused = __c.front();
832 
833  __const_constraints(__c);
834  }
835  void __const_constraints(const _Sequence& __c) {
836  _Const_reference __r _IsUnused = __c.front();
837  }
838  typename _Sequence::value_type __t;
839  typename _Sequence::size_type __n;
840  typename _Sequence::value_type *__first, *__last;
841  typename _Sequence::iterator __p, __q;
842  };
843 
844  template <class _FrontInsertionSequence>
845  struct _FrontInsertionSequenceConcept
846  {
847  void __constraints() {
848  __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
849 
850  __c.push_front(__t);
851  __c.pop_front();
852  }
853  _FrontInsertionSequence __c;
854  typename _FrontInsertionSequence::value_type __t;
855  };
856 
857  template <class _BackInsertionSequence>
858  struct _BackInsertionSequenceConcept
859  {
860  typedef typename _BackInsertionSequence::reference _Reference;
861  typedef typename _BackInsertionSequence::const_reference _Const_reference;
862 
863  void __constraints() {
864  __function_requires< _SequenceConcept<_BackInsertionSequence> >();
865 
866  __c.push_back(__t);
867  __c.pop_back();
868  _Reference __r _IsUnused = __c.back();
869  }
870  void __const_constraints(const _BackInsertionSequence& __c) {
871  _Const_reference __r _IsUnused = __c.back();
872  };
873  _BackInsertionSequence __c;
874  typename _BackInsertionSequence::value_type __t;
875  };
876 
877 _GLIBCXX_END_NAMESPACE_VERSION
878 } // namespace
879 
880 #pragma GCC diagnostic pop
881 #undef _IsUnused
882 
883 #endif // _GLIBCXX_BOOST_CONCEPT_CHECK
884 
885 
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
GNU debug classes for public use.
is_reference
Definition: type_traits:720
Safe iterator wrapper.
Marking input iterators.
Forward iterators support a superset of input iterator operations.
Bidirectional iterators support a superset of forward iterator operations.
Random-access iterators support a superset of bidirectional iterator operations.
Traits class for iterators.