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