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
49namespace 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
59namespace __gnu_debug
60{
61 template<typename _Iterator, typename _Sequence, typename _Category>
62 class _Safe_iterator;
63}
64
65namespace __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.
77template <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.
86void __error_type_must_be_an_integer_type();
87void __error_type_must_be_an_unsigned_integer_type();
88void __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
124template <class _Tp1, class _Tp2>
125struct _Aux_require_same { };
126
127template <class _Tp>
128struct _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;
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:714
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.