39#ifndef _BOOST_CONCEPT_CHECK_H
40#define _BOOST_CONCEPT_CHECK_H 1
43#pragma GCC system_header
49namespace std _GLIBCXX_VISIBILITY(default)
51_GLIBCXX_BEGIN_NAMESPACE_VERSION
52_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
54 struct _Bit_const_iterator;
55_GLIBCXX_END_NAMESPACE_CONTAINER
56_GLIBCXX_END_NAMESPACE_VERSION
61 template<
typename _Iterator,
typename _Sequence,
typename _Category>
65namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
67_GLIBCXX_BEGIN_NAMESPACE_VERSION
69#pragma GCC diagnostic push
70#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
72#define _IsUnused __attribute__ ((__unused__))
77template <
class _Concept>
78_GLIBCXX14_CONSTEXPR
inline void __function_requires()
80 void (_Concept::*__x)() _IsUnused = &_Concept::__constraints;
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();
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
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
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
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
124template <
class _Tp1,
class _Tp2>
125struct _Aux_require_same { };
128struct _Aux_require_same<_Tp,_Tp> {
typedef _Tp _Type; };
130 template <
class _Tp1,
class _Tp2>
131 struct _SameTypeConcept
133 void __constraints() {
134 typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required;
139 struct _IntegerConcept {
140 void __constraints() {
141 __error_type_must_be_an_integer_type();
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() {} };
155 struct _SignedIntegerConcept {
156 void __constraints() {
157 __error_type_must_be_a_signed_integer_type();
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(){}};
166 struct _UnsignedIntegerConcept {
167 void __constraints() {
168 __error_type_must_be_an_unsigned_integer_type();
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() {} };
184 struct _DefaultConstructibleConcept
186 void __constraints() {
192 struct _AssignableConcept
194 void __constraints() {
196 __const_constraints(__a);
198 void __const_constraints(
const _Tp& __b) {
207 struct _CopyConstructibleConcept
209 void __constraints() {
211 _Tp* __ptr _IsUnused = &__a;
212 __const_constraints(__a);
214 void __const_constraints(
const _Tp& __a) {
215 _Tp __c _IsUnused(__a);
216 const _Tp* __ptr _IsUnused = &__a;
223 struct _SGIAssignableConcept
225 void __constraints() {
226 _Tp __b _IsUnused(__a);
228 __const_constraints(__a);
230 void __const_constraints(
const _Tp& __b) {
231 _Tp __c _IsUnused(__b);
237 template <
class _From,
class _To>
238 struct _ConvertibleConcept
240 void __constraints() {
241 _To __y _IsUnused = __x;
256 void __aux_require_boolean_expr(
const _Tp& __t) {
257 bool __x _IsUnused = __t;
262 struct _EqualityComparableConcept
264 void __constraints() {
265 __aux_require_boolean_expr(__a == __b);
271 struct _LessThanComparableConcept
273 void __constraints() {
274 __aux_require_boolean_expr(__a < __b);
281 struct _ComparableConcept
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);
292#define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \
293 template <class _First, class _Second> \
295 void __constraints() { (void)__constraints_(); } \
296 bool __constraints_() { \
297 return __a _OP __b; \
303#define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \
304 template <class _Ret, class _First, class _Second> \
306 void __constraints() { (void)__constraints_(); } \
307 _Ret __constraints_() { \
308 return __a _OP __b; \
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);
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);
327#undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT
328#undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT
333 template <
class _Func,
class _Return>
334 struct _GeneratorConcept
336 void __constraints() {
337 const _Return& __r _IsUnused = __f();
343 template <
class _Func>
344 struct _GeneratorConcept<_Func,void>
346 void __constraints() {
352 template <
class _Func,
class _Return,
class _Arg>
353 struct _UnaryFunctionConcept
355 void __constraints() {
363 template <
class _Func,
class _Arg>
364 struct _UnaryFunctionConcept<_Func, void, _Arg> {
365 void __constraints() {
372 template <
class _Func,
class _Return,
class _First,
class _Second>
373 struct _BinaryFunctionConcept
375 void __constraints() {
376 __r = __f(__first, __second);
384 template <
class _Func,
class _First,
class _Second>
385 struct _BinaryFunctionConcept<_Func, void, _First, _Second>
387 void __constraints() {
388 __f(__first, __second);
395 template <
class _Func,
class _Arg>
396 struct _UnaryPredicateConcept
398 void __constraints() {
399 __aux_require_boolean_expr(__f(__arg));
405 template <
class _Func,
class _First,
class _Second>
406 struct _BinaryPredicateConcept
408 void __constraints() {
409 __aux_require_boolean_expr(__f(__a, __b));
417 template <
class _Func,
class _First,
class _Second>
418 struct _Const_BinaryPredicateConcept {
419 void __constraints() {
420 __const_constraints(__f);
422 void __const_constraints(
const _Func& __fun) {
423 __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >();
425 __aux_require_boolean_expr(__fun(__a, __b));
436 struct _TrivialIteratorConcept
438 void __constraints() {
440 __function_requires< _AssignableConcept<_Tp> >();
441 __function_requires< _EqualityComparableConcept<_Tp> >();
449 struct _Mutable_TrivialIteratorConcept
451 void __constraints() {
452 __function_requires< _TrivialIteratorConcept<_Tp> >();
459 struct _InputIteratorConcept
461 void __constraints() {
462 __function_requires< _TrivialIteratorConcept<_Tp> >();
469 __function_requires< _ConvertibleConcept<
478 template <
class _Tp,
class _ValueT>
479 struct _OutputIteratorConcept
481 void __constraints() {
482 __function_requires< _AssignableConcept<_Tp> >();
493 template<
typename _Tp>
494 struct _Is_vector_bool_iterator
495 {
static const bool __value =
false; };
498 namespace __cont = ::std::_GLIBCXX_STD_C;
505 struct _Is_vector_bool_iterator<
__cont::_Bit_iterator>
506 {
static const bool __value =
true; };
510 struct _Is_vector_bool_iterator<
__cont::_Bit_const_iterator>
511 {
static const bool __value =
true; };
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> { };
518 template <class _Tp, bool = _Is_vector_bool_iterator<_Tp>::__value>
519 struct _ForwardIteratorReferenceConcept
521 void __constraints() {
522#if __cplusplus >= 201103L
525 "reference type of a forward iterator must be a real reference");
530 template <class _Tp, bool = _Is_vector_bool_iterator<_Tp>::__value>
531 struct _Mutable_ForwardIteratorReferenceConcept
533 void __constraints() {
536 __function_requires< _SameTypeConcept<_Ref, _Val&> >();
542 struct _ForwardIteratorReferenceConcept<_Tp, true>
544 void __constraints() { }
549 struct _Mutable_ForwardIteratorReferenceConcept<_Tp, true>
551 void __constraints() { }
554#pragma GCC diagnostic push
555#pragma GCC diagnostic ignored "-Wunused-variable"
558 struct _ForwardIteratorConcept
560 void __constraints() {
561 __function_requires< _InputIteratorConcept<_Tp> >();
562 __function_requires< _DefaultConstructibleConcept<_Tp> >();
563 __function_requires< _ConvertibleConcept<
566 __function_requires< _ForwardIteratorReferenceConcept<_Tp> >();
568 const _Tp& __k = __i++;
577 struct _Mutable_ForwardIteratorConcept
579 void __constraints() {
580 __function_requires< _ForwardIteratorConcept<_Tp> >();
583 __function_requires< _Mutable_ForwardIteratorReferenceConcept<_Tp> >();
589 struct _BidirectionalIteratorConcept
591 void __constraints() {
592 __function_requires< _ForwardIteratorConcept<_Tp> >();
593 __function_requires< _ConvertibleConcept<
597 const _Tp& __k = __i--;
605 struct _Mutable_BidirectionalIteratorConcept
607 void __constraints() {
608 __function_requires< _BidirectionalIteratorConcept<_Tp> >();
609 __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >();
616 struct _RandomAccessIteratorConcept
618 void __constraints() {
619 __function_requires< _BidirectionalIteratorConcept<_Tp> >();
620 __function_requires< _ComparableConcept<_Tp> >();
621 __function_requires< _ConvertibleConcept<
626 _Tp& __j = __i += __n;
627 __i = __i + __n; __i = __n + __i;
628 _Tp& __k = __i -= __n;
640 struct _Mutable_RandomAccessIteratorConcept
642 void __constraints() {
643 __function_requires< _RandomAccessIteratorConcept<_Tp> >();
644 __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >();
650#pragma GCC diagnostic pop
655 template <
class _Container>
656 struct _ContainerConcept
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;
665 void __constraints() {
666 __function_requires< _InputIteratorConcept<_Const_iterator> >();
667 __function_requires< _AssignableConcept<_Container> >();
668 const _Container __c;
672 __n = __c.max_size();
680 template <
class _Container>
681 struct _Mutable_ContainerConcept
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;
688 void __constraints() {
689 __function_requires< _ContainerConcept<_Container> >();
690 __function_requires< _AssignableConcept<_Value_type> >();
691 __function_requires< _InputIteratorConcept<_Iterator> >();
698 _Container __c, __c2;
701 template <
class _ForwardContainer>
702 struct _ForwardContainerConcept
704 void __constraints() {
705 __function_requires< _ContainerConcept<_ForwardContainer> >();
706 typedef typename _ForwardContainer::const_iterator _Const_iterator;
707 __function_requires< _ForwardIteratorConcept<_Const_iterator> >();
711 template <
class _ForwardContainer>
712 struct _Mutable_ForwardContainerConcept
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> >();
722 template <
class _ReversibleContainer>
723 struct _ReversibleContainerConcept
725 typedef typename _ReversibleContainer::const_iterator _Const_iterator;
726 typedef typename _ReversibleContainer::const_reverse_iterator
727 _Const_reverse_iterator;
729 void __constraints() {
730 __function_requires< _ForwardContainerConcept<_ReversibleContainer> >();
731 __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >();
733 _BidirectionalIteratorConcept<_Const_reverse_iterator> >();
735 const _ReversibleContainer __c;
736 _Const_reverse_iterator __i = __c.rbegin();
741 template <
class _ReversibleContainer>
742 struct _Mutable_ReversibleContainerConcept
744 typedef typename _ReversibleContainer::iterator _Iterator;
745 typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator;
747 void __constraints() {
748 __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >();
750 _Mutable_ForwardContainerConcept<_ReversibleContainer> >();
751 __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >();
753 _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >();
755 _Reverse_iterator __i = __c.rbegin();
758 _ReversibleContainer __c;
761 template <
class _RandomAccessContainer>
762 struct _RandomAccessContainerConcept
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;
770 void __constraints() {
772 _ReversibleContainerConcept<_RandomAccessContainer> >();
773 __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >();
775 _RandomAccessIteratorConcept<_Const_reverse_iterator> >();
777 const _RandomAccessContainer __c;
778 _Const_reference __r _IsUnused = __c[__n];
783 template <
class _RandomAccessContainer>
784 struct _Mutable_RandomAccessContainerConcept
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;
791 void __constraints() {
793 _RandomAccessContainerConcept<_RandomAccessContainer> >();
795 _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >();
796 __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >();
798 _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >();
800 _Reference __r _IsUnused = __c[__i];
803 _RandomAccessContainer __c;
807 template <
class _Sequence>
808 struct _SequenceConcept
810 typedef typename _Sequence::reference _Reference;
811 typedef typename _Sequence::const_reference _Const_reference;
813 void __constraints() {
817 __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >();
818 __function_requires< _DefaultConstructibleConcept<_Sequence> >();
821 __c _IsUnused(__n, __t),
822 __c2 _IsUnused(__first, __last);
824 __c.insert(__p, __t);
825 __c.insert(__p, __n, __t);
826 __c.insert(__p, __first, __last);
831 _Reference __r _IsUnused = __c.front();
833 __const_constraints(__c);
835 void __const_constraints(
const _Sequence& __c) {
836 _Const_reference __r _IsUnused = __c.front();
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;
844 template <
class _FrontInsertionSequence>
845 struct _FrontInsertionSequenceConcept
847 void __constraints() {
848 __function_requires< _SequenceConcept<_FrontInsertionSequence> >();
853 _FrontInsertionSequence __c;
854 typename _FrontInsertionSequence::value_type __t;
857 template <
class _BackInsertionSequence>
858 struct _BackInsertionSequenceConcept
860 typedef typename _BackInsertionSequence::reference _Reference;
861 typedef typename _BackInsertionSequence::const_reference _Const_reference;
863 void __constraints() {
864 __function_requires< _SequenceConcept<_BackInsertionSequence> >();
868 _Reference __r _IsUnused = __c.back();
870 void __const_constraints(
const _BackInsertionSequence& __c) {
871 _Const_reference __r _IsUnused = __c.back();
873 _BackInsertionSequence __c;
874 typename _BackInsertionSequence::value_type __t;
877_GLIBCXX_END_NAMESPACE_VERSION
880#pragma GCC diagnostic pop
ISO C++ entities toplevel namespace is std.
GNU extensions for public use.
GNU debug classes for public use.
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.