1 // (C) Copyright David Abrahams 2002. 2 // (C) Copyright Jeremy Siek 2002. 3 // (C) Copyright Thomas Witt 2002. 4 // Distributed under the Boost Software License, Version 1.0. (See 5 // accompanying file LICENSE_1_0.txt or copy at 6 // http://www.boost.org/LICENSE_1_0.txt) 7 #ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP 8 #define BOOST_ITERATOR_FACADE_23022003THW_HPP 9 10 #include <boost/iterator.hpp> 11 #include <boost/iterator/interoperable.hpp> 12 #include <boost/iterator/iterator_traits.hpp> 13 14 #include <boost/iterator/detail/facade_iterator_category.hpp> 15 #include <boost/iterator/detail/enable_if.hpp> 16 17 #include <boost/static_assert.hpp> 18 #include <boost/utility/addressof.hpp> 19 20 #include <boost/type_traits/is_same.hpp> 21 #include <boost/type_traits/add_const.hpp> 22 #include <boost/type_traits/add_pointer.hpp> 23 #include <boost/type_traits/remove_const.hpp> 24 #include <boost/type_traits/remove_reference.hpp> 25 #include <boost/type_traits/is_convertible.hpp> 26 #include <boost/type_traits/is_pod.hpp> 27 28 #include <boost/mpl/eval_if.hpp> 29 #include <boost/mpl/if.hpp> 30 #include <boost/mpl/or.hpp> 31 #include <boost/mpl/and.hpp> 32 #include <boost/mpl/not.hpp> 33 #include <boost/mpl/always.hpp> 34 #include <boost/mpl/apply.hpp> 35 #include <boost/mpl/identity.hpp> 36 37 #include <boost/iterator/detail/config_def.hpp> // this goes last 38 39 namespace boost 40 { 41 // This forward declaration is required for the friend declaration 42 // in iterator_core_access 43 template <class I, class V, class TC, class R, class D> class iterator_facade; 44 45 namespace detail 46 { 47 // A binary metafunction class that always returns bool. VC6 48 // ICEs on mpl::always<bool>, probably because of the default 49 // parameters. 50 struct always_bool2 51 { 52 template <class T, class U> 53 struct apply 54 { 55 typedef bool type; 56 }; 57 }; 58 59 // 60 // enable if for use in operator implementation. 61 // 62 template < 63 class Facade1 64 , class Facade2 65 , class Return 66 > 67 struct enable_if_interoperable 68 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 69 { 70 typedef typename mpl::if_< 71 mpl::or_< 72 is_convertible<Facade1, Facade2> 73 , is_convertible<Facade2, Facade1> 74 > 75 , Return 76 , int[3] 77 >::type type; 78 }; 79 #else 80 : ::boost::iterators::enable_if< 81 mpl::or_< 82 is_convertible<Facade1, Facade2> 83 , is_convertible<Facade2, Facade1> 84 > 85 , Return 86 > 87 {}; 88 #endif 89 90 // 91 // Generates associated types for an iterator_facade with the 92 // given parameters. 93 // 94 template < 95 class ValueParam 96 , class CategoryOrTraversal 97 , class Reference 98 , class Difference 99 > 100 struct iterator_facade_types 101 { 102 typedef typename facade_iterator_category< 103 CategoryOrTraversal, ValueParam, Reference 104 >::type iterator_category; 105 106 typedef typename remove_const<ValueParam>::type value_type; 107 108 // Not the real associated pointer type 109 typedef typename mpl::eval_if< 110 boost::detail::iterator_writability_disabled<ValueParam,Reference> 111 , add_pointer<const value_type> 112 , add_pointer<value_type> 113 >::type pointer; 114 115 # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 116 && (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \ 117 || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \ 118 || BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \ 119 || BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310) 120 121 // To interoperate with some broken library/compiler 122 // combinations, user-defined iterators must be derived from 123 // std::iterator. It is possible to implement a standard 124 // library for broken compilers without this limitation. 125 # define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1 126 127 typedef 128 iterator<iterator_category, value_type, Difference, pointer, Reference> 129 base; 130 # endif 131 }; 132 133 // iterators whose dereference operators reference the same value 134 // for all iterators into the same sequence (like many input 135 // iterators) need help with their postfix ++: the referenced 136 // value must be read and stored away before the increment occurs 137 // so that *a++ yields the originally referenced element and not 138 // the next one. 139 template <class Iterator> 140 class postfix_increment_proxy 141 { 142 typedef typename iterator_value<Iterator>::type value_type; 143 public: 144 explicit postfix_increment_proxy(Iterator const& x) 145 : stored_value(*x) 146 {} 147 148 // Returning a mutable reference allows nonsense like 149 // (*r++).mutate(), but it imposes fewer assumptions about the 150 // behavior of the value_type. In particular, recall that 151 // (*r).mutate() is legal if operator* returns by value. 152 value_type& 153 operator*() const 154 { 155 return this->stored_value; 156 } 157 private: 158 mutable value_type stored_value; 159 }; 160 161 // 162 // In general, we can't determine that such an iterator isn't 163 // writable -- we also need to store a copy of the old iterator so 164 // that it can be written into. 165 template <class Iterator> 166 class writable_postfix_increment_proxy 167 { 168 typedef typename iterator_value<Iterator>::type value_type; 169 public: 170 explicit writable_postfix_increment_proxy(Iterator const& x) 171 : stored_value(*x) 172 , stored_iterator(x) 173 {} 174 175 // Dereferencing must return a proxy so that both *r++ = o and 176 // value_type(*r++) can work. In this case, *r is the same as 177 // *r++, and the conversion operator below is used to ensure 178 // readability. 179 writable_postfix_increment_proxy const& 180 operator*() const 181 { 182 return *this; 183 } 184 185 // Provides readability of *r++ 186 operator value_type&() const 187 { 188 return stored_value; 189 } 190 191 // Provides writability of *r++ 192 template <class T> 193 T const& operator=(T const& x) const 194 { 195 *this->stored_iterator = x; 196 return x; 197 } 198 199 // This overload just in case only non-const objects are writable 200 template <class T> 201 T& operator=(T& x) const 202 { 203 *this->stored_iterator = x; 204 return x; 205 } 206 207 // Provides X(r++) 208 operator Iterator const&() const 209 { 210 return stored_iterator; 211 } 212 213 private: 214 mutable value_type stored_value; 215 Iterator stored_iterator; 216 }; 217 218 # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 219 220 template <class Reference, class Value> 221 struct is_non_proxy_reference_impl 222 { 223 static Reference r; 224 225 template <class R> 226 static typename mpl::if_< 227 is_convertible< 228 R const volatile* 229 , Value const volatile* 230 > 231 , char[1] 232 , char[2] 233 >::type& helper(R const&); 234 235 BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1); 236 }; 237 238 template <class Reference, class Value> 239 struct is_non_proxy_reference 240 : mpl::bool_< 241 is_non_proxy_reference_impl<Reference, Value>::value 242 > 243 {}; 244 # else 245 template <class Reference, class Value> 246 struct is_non_proxy_reference 247 : is_convertible< 248 typename remove_reference<Reference>::type 249 const volatile* 250 , Value const volatile* 251 > 252 {}; 253 # endif 254 255 // A metafunction to choose the result type of postfix ++ 256 // 257 // Because the C++98 input iterator requirements say that *r++ has 258 // type T (value_type), implementations of some standard 259 // algorithms like lexicographical_compare may use constructions 260 // like: 261 // 262 // *r++ < *s++ 263 // 264 // If *r++ returns a proxy (as required if r is writable but not 265 // multipass), this sort of expression will fail unless the proxy 266 // supports the operator<. Since there are any number of such 267 // operations, we're not going to try to support them. Therefore, 268 // even if r++ returns a proxy, *r++ will only return a proxy if 269 // *r also returns a proxy. 270 template <class Iterator, class Value, class Reference, class CategoryOrTraversal> 271 struct postfix_increment_result 272 : mpl::eval_if< 273 mpl::and_< 274 // A proxy is only needed for readable iterators 275 is_convertible<Reference,Value const&> 276 277 // No multipass iterator can have values that disappear 278 // before positions can be re-visited 279 , mpl::not_< 280 is_convertible< 281 typename iterator_category_to_traversal<CategoryOrTraversal>::type 282 , forward_traversal_tag 283 > 284 > 285 > 286 , mpl::if_< 287 is_non_proxy_reference<Reference,Value> 288 , postfix_increment_proxy<Iterator> 289 , writable_postfix_increment_proxy<Iterator> 290 > 291 , mpl::identity<Iterator> 292 > 293 {}; 294 295 // operator->() needs special support for input iterators to strictly meet the 296 // standard's requirements. If *i is not a reference type, we must still 297 // produce an lvalue to which a pointer can be formed. We do that by 298 // returning a proxy object containing an instance of the reference object. 299 template <class Reference, class Pointer> 300 struct operator_arrow_dispatch // proxy references 301 { 302 struct proxy 303 { 304 explicit proxy(Reference const & x) : m_ref(x) {} 305 Reference* operator->() { return boost::addressof(m_ref); } 306 // This function is needed for MWCW and BCC, which won't call 307 // operator-> again automatically per 13.3.1.2 para 8 308 operator Reference*() { return boost::addressof(m_ref); } 309 Reference m_ref; 310 }; 311 typedef proxy result_type; 312 static result_type apply(Reference const & x) 313 { 314 return result_type(x); 315 } 316 }; 317 318 template <class T, class Pointer> 319 struct operator_arrow_dispatch<T&, Pointer> // "real" references 320 { 321 typedef Pointer result_type; 322 static result_type apply(T& x) 323 { 324 return boost::addressof(x); 325 } 326 }; 327 328 # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) 329 // Deal with ETI 330 template<> 331 struct operator_arrow_dispatch<int, int> 332 { 333 typedef int result_type; 334 }; 335 # endif 336 337 // A proxy return type for operator[], needed to deal with 338 // iterators that may invalidate referents upon destruction. 339 // Consider the temporary iterator in *(a + n) 340 template <class Iterator> 341 class operator_brackets_proxy 342 { 343 // Iterator is actually an iterator_facade, so we do not have to 344 // go through iterator_traits to access the traits. 345 typedef typename Iterator::reference reference; 346 typedef typename Iterator::value_type value_type; 347 348 public: 349 operator_brackets_proxy(Iterator const& iter) 350 : m_iter(iter) 351 {} 352 353 operator reference() const 354 { 355 return *m_iter; 356 } 357 358 operator_brackets_proxy& operator=(value_type const& val) 359 { 360 *m_iter = val; 361 return *this; 362 } 363 364 private: 365 Iterator m_iter; 366 }; 367 368 // A metafunction that determines whether operator[] must return a 369 // proxy, or whether it can simply return a copy of the value_type. 370 template <class ValueType, class Reference> 371 struct use_operator_brackets_proxy 372 : mpl::not_< 373 mpl::and_< 374 // Really we want an is_copy_constructible trait here, 375 // but is_POD will have to suffice in the meantime. 376 boost::is_POD<ValueType> 377 , iterator_writability_disabled<ValueType,Reference> 378 > 379 > 380 {}; 381 382 template <class Iterator, class Value, class Reference> 383 struct operator_brackets_result 384 { 385 typedef typename mpl::if_< 386 use_operator_brackets_proxy<Value,Reference> 387 , operator_brackets_proxy<Iterator> 388 , Value 389 >::type type; 390 }; 391 392 template <class Iterator> 393 operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_) 394 { 395 return operator_brackets_proxy<Iterator>(iter); 396 } 397 398 template <class Iterator> 399 typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_) 400 { 401 return *iter; 402 } 403 404 struct choose_difference_type 405 { 406 template <class I1, class I2> 407 struct apply 408 : 409 # ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP 410 iterator_difference<I1> 411 # elif BOOST_WORKAROUND(BOOST_MSVC, < 1300) 412 mpl::if_< 413 is_convertible<I2,I1> 414 , typename I1::difference_type 415 , typename I2::difference_type 416 > 417 # else 418 mpl::eval_if< 419 is_convertible<I2,I1> 420 , iterator_difference<I1> 421 , iterator_difference<I2> 422 > 423 # endif 424 {}; 425 426 }; 427 } // namespace detail 428 429 430 // Macros which describe the declarations of binary operators 431 # ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY 432 # define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ 433 template < \ 434 class Derived1, class V1, class TC1, class Reference1, class Difference1 \ 435 , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ 436 > \ 437 prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \ 438 operator op( \ 439 iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \ 440 , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) 441 # else 442 # define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \ 443 template < \ 444 class Derived1, class V1, class TC1, class Reference1, class Difference1 \ 445 , class Derived2, class V2, class TC2, class Reference2, class Difference2 \ 446 > \ 447 prefix typename boost::detail::enable_if_interoperable< \ 448 Derived1, Derived2 \ 449 , typename mpl::apply2<result_type,Derived1,Derived2>::type \ 450 >::type \ 451 operator op( \ 452 iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \ 453 , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) 454 # endif 455 456 # define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \ 457 template <class Derived, class V, class TC, class R, class D> \ 458 prefix Derived operator+ args 459 460 // 461 // Helper class for granting access to the iterator core interface. 462 // 463 // The simple core interface is used by iterator_facade. The core 464 // interface of a user/library defined iterator type should not be made public 465 // so that it does not clutter the public interface. Instead iterator_core_access 466 // should be made friend so that iterator_facade can access the core 467 // interface through iterator_core_access. 468 // 469 class iterator_core_access 470 { 471 # if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) 472 // Tasteless as this may seem, making all members public allows member templates 473 // to work in the absence of member template friends. 474 public: 475 # else 476 477 template <class I, class V, class TC, class R, class D> friend class iterator_facade; 478 479 # define BOOST_ITERATOR_FACADE_RELATION(op) \ 480 BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::detail::always_bool2); 481 482 BOOST_ITERATOR_FACADE_RELATION(==) 483 BOOST_ITERATOR_FACADE_RELATION(!=) 484 485 BOOST_ITERATOR_FACADE_RELATION(<) 486 BOOST_ITERATOR_FACADE_RELATION(>) 487 BOOST_ITERATOR_FACADE_RELATION(<=) 488 BOOST_ITERATOR_FACADE_RELATION(>=) 489 # undef BOOST_ITERATOR_FACADE_RELATION 490 491 BOOST_ITERATOR_FACADE_INTEROP_HEAD( 492 friend, -, boost::detail::choose_difference_type) 493 ; 494 495 BOOST_ITERATOR_FACADE_PLUS_HEAD( 496 friend inline 497 , (iterator_facade<Derived, V, TC, R, D> const& 498 , typename Derived::difference_type) 499 ) 500 ; 501 502 BOOST_ITERATOR_FACADE_PLUS_HEAD( 503 friend inline 504 , (typename Derived::difference_type 505 , iterator_facade<Derived, V, TC, R, D> const&) 506 ) 507 ; 508 509 # endif 510 511 template <class Facade> 512 static typename Facade::reference dereference(Facade const& f) 513 { 514 return f.dereference(); 515 } 516 517 template <class Facade> 518 static void increment(Facade& f) 519 { 520 f.increment(); 521 } 522 523 template <class Facade> 524 static void decrement(Facade& f) 525 { 526 f.decrement(); 527 } 528 529 template <class Facade1, class Facade2> 530 static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_) 531 { 532 return f1.equal(f2); 533 } 534 535 template <class Facade1, class Facade2> 536 static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_) 537 { 538 return f2.equal(f1); 539 } 540 541 template <class Facade> 542 static void advance(Facade& f, typename Facade::difference_type n) 543 { 544 f.advance(n); 545 } 546 547 template <class Facade1, class Facade2> 548 static typename Facade1::difference_type distance_from( 549 Facade1 const& f1, Facade2 const& f2, mpl::true_) 550 { 551 return -f1.distance_to(f2); 552 } 553 554 template <class Facade1, class Facade2> 555 static typename Facade2::difference_type distance_from( 556 Facade1 const& f1, Facade2 const& f2, mpl::false_) 557 { 558 return f2.distance_to(f1); 559 } 560 561 // 562 // Curiously Recurring Template interface. 563 // 564 template <class I, class V, class TC, class R, class D> 565 static I& derived(iterator_facade<I,V,TC,R,D>& facade) 566 { 567 return *static_cast<I*>(&facade); 568 } 569 570 template <class I, class V, class TC, class R, class D> 571 static I const& derived(iterator_facade<I,V,TC,R,D> const& facade) 572 { 573 return *static_cast<I const*>(&facade); 574 } 575 576 private: 577 // objects of this class are useless 578 iterator_core_access(); //undefined 579 }; 580 581 // 582 // iterator_facade - use as a public base class for defining new 583 // standard-conforming iterators. 584 // 585 template < 586 class Derived // The derived iterator type being constructed 587 , class Value 588 , class CategoryOrTraversal 589 , class Reference = Value& 590 , class Difference = std::ptrdiff_t 591 > 592 class iterator_facade 593 # ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 594 : public boost::detail::iterator_facade_types< 595 Value, CategoryOrTraversal, Reference, Difference 596 >::base 597 # undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 598 # endif 599 { 600 private: 601 // 602 // Curiously Recurring Template interface. 603 // 604 Derived& derived() 605 { 606 return *static_cast<Derived*>(this); 607 } 608 609 Derived const& derived() const 610 { 611 return *static_cast<Derived const*>(this); 612 } 613 614 typedef boost::detail::iterator_facade_types< 615 Value, CategoryOrTraversal, Reference, Difference 616 > associated_types; 617 618 typedef boost::detail::operator_arrow_dispatch< 619 Reference 620 , typename associated_types::pointer 621 > operator_arrow_dispatch_; 622 623 protected: 624 // For use by derived classes 625 typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_; 626 627 public: 628 629 typedef typename associated_types::value_type value_type; 630 typedef Reference reference; 631 typedef Difference difference_type; 632 633 typedef typename operator_arrow_dispatch_::result_type pointer; 634 635 typedef typename associated_types::iterator_category iterator_category; 636 637 reference operator*() const 638 { 639 return iterator_core_access::dereference(this->derived()); 640 } 641 642 pointer operator->() const 643 { 644 return operator_arrow_dispatch_::apply(*this->derived()); 645 } 646 647 typename boost::detail::operator_brackets_result<Derived,Value,reference>::type 648 operator[](difference_type n) const 649 { 650 typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy; 651 652 return boost::detail::make_operator_brackets_result<Derived>( 653 this->derived() + n 654 , use_proxy() 655 ); 656 } 657 658 Derived& operator++() 659 { 660 iterator_core_access::increment(this->derived()); 661 return this->derived(); 662 } 663 664 # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) 665 typename boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type 666 operator++(int) 667 { 668 typename boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type 669 tmp(this->derived()); 670 ++*this; 671 return tmp; 672 } 673 # endif 674 675 Derived& operator--() 676 { 677 iterator_core_access::decrement(this->derived()); 678 return this->derived(); 679 } 680 681 Derived operator--(int) 682 { 683 Derived tmp(this->derived()); 684 --*this; 685 return tmp; 686 } 687 688 Derived& operator+=(difference_type n) 689 { 690 iterator_core_access::advance(this->derived(), n); 691 return this->derived(); 692 } 693 694 Derived& operator-=(difference_type n) 695 { 696 iterator_core_access::advance(this->derived(), -n); 697 return this->derived(); 698 } 699 700 Derived operator-(difference_type x) const 701 { 702 Derived result(this->derived()); 703 return result -= x; 704 } 705 706 # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) 707 // There appears to be a bug which trashes the data of classes 708 // derived from iterator_facade when they are assigned unless we 709 // define this assignment operator. This bug is only revealed 710 // (so far) in STLPort debug mode, but it's clearly a codegen 711 // problem so we apply the workaround for all MSVC6. 712 iterator_facade& operator=(iterator_facade const&) 713 { 714 return *this; 715 } 716 # endif 717 }; 718 719 # if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) 720 template <class I, class V, class TC, class R, class D> 721 inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type 722 operator++( 723 iterator_facade<I,V,TC,R,D>& i 724 , int 725 ) 726 { 727 typename boost::detail::postfix_increment_result<I,V,R,TC>::type 728 tmp(*static_cast<I*>(&i)); 729 730 ++i; 731 732 return tmp; 733 } 734 # endif 735 736 737 // 738 // Comparison operator implementation. The library supplied operators 739 // enables the user to provide fully interoperable constant/mutable 740 // iterator types. I.e. the library provides all operators 741 // for all mutable/constant iterator combinations. 742 // 743 // Note though that this kind of interoperability for constant/mutable 744 // iterators is not required by the standard for container iterators. 745 // All the standard asks for is a conversion mutable -> constant. 746 // Most standard library implementations nowadays provide fully interoperable 747 // iterator implementations, but there are still heavily used implementations 748 // that do not provide them. (Actually it's even worse, they do not provide 749 // them for only a few iterators.) 750 // 751 // ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should 752 // enable the user to turn off mixed type operators 753 // 754 // The library takes care to provide only the right operator overloads. 755 // I.e. 756 // 757 // bool operator==(Iterator, Iterator); 758 // bool operator==(ConstIterator, Iterator); 759 // bool operator==(Iterator, ConstIterator); 760 // bool operator==(ConstIterator, ConstIterator); 761 // 762 // ... 763 // 764 // In order to do so it uses c++ idioms that are not yet widely supported 765 // by current compiler releases. The library is designed to degrade gracefully 766 // in the face of compiler deficiencies. In general compiler 767 // deficiencies result in less strict error checking and more obscure 768 // error messages, functionality is not affected. 769 // 770 // For full operation compiler support for "Substitution Failure Is Not An Error" 771 // (aka. enable_if) and boost::is_convertible is required. 772 // 773 // The following problems occur if support is lacking. 774 // 775 // Pseudo code 776 // 777 // --------------- 778 // AdaptorA<Iterator1> a1; 779 // AdaptorA<Iterator2> a2; 780 // 781 // // This will result in a no such overload error in full operation 782 // // If enable_if or is_convertible is not supported 783 // // The instantiation will fail with an error hopefully indicating that 784 // // there is no operator== for Iterator1, Iterator2 785 // // The same will happen if no enable_if is used to remove 786 // // false overloads from the templated conversion constructor 787 // // of AdaptorA. 788 // 789 // a1 == a2; 790 // ---------------- 791 // 792 // AdaptorA<Iterator> a; 793 // AdaptorB<Iterator> b; 794 // 795 // // This will result in a no such overload error in full operation 796 // // If enable_if is not supported the static assert used 797 // // in the operator implementation will fail. 798 // // This will accidently work if is_convertible is not supported. 799 // 800 // a == b; 801 // ---------------- 802 // 803 804 # ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP 805 # define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_() 806 # else 807 # define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>() 808 # endif 809 810 # define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \ 811 BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \ 812 { \ 813 /* For those compilers that do not support enable_if */ \ 814 BOOST_STATIC_ASSERT(( \ 815 is_interoperable< Derived1, Derived2 >::value \ 816 )); \ 817 return_prefix iterator_core_access::base_op( \ 818 *static_cast<Derived1 const*>(&lhs) \ 819 , *static_cast<Derived2 const*>(&rhs) \ 820 , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \ 821 ); \ 822 } 823 824 # define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \ 825 BOOST_ITERATOR_FACADE_INTEROP( \ 826 op \ 827 , boost::detail::always_bool2 \ 828 , return_prefix \ 829 , base_op \ 830 ) 831 832 BOOST_ITERATOR_FACADE_RELATION(==, return, equal) 833 BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal) 834 835 BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from) 836 BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from) 837 BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from) 838 BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from) 839 # undef BOOST_ITERATOR_FACADE_RELATION 840 841 // operator- requires an additional part in the static assertion 842 BOOST_ITERATOR_FACADE_INTEROP( 843 - 844 , boost::detail::choose_difference_type 845 , return 846 , distance_from 847 ) 848 # undef BOOST_ITERATOR_FACADE_INTEROP 849 # undef BOOST_ITERATOR_FACADE_INTEROP_HEAD 850 851 # define BOOST_ITERATOR_FACADE_PLUS(args) \ 852 BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \ 853 { \ 854 Derived tmp(static_cast<Derived const&>(i)); \ 855 return tmp += n; \ 856 } 857 858 BOOST_ITERATOR_FACADE_PLUS(( 859 iterator_facade<Derived, V, TC, R, D> const& i 860 , typename Derived::difference_type n 861 )) 862 863 BOOST_ITERATOR_FACADE_PLUS(( 864 typename Derived::difference_type n 865 , iterator_facade<Derived, V, TC, R, D> const& i 866 )) 867 # undef BOOST_ITERATOR_FACADE_PLUS 868 # undef BOOST_ITERATOR_FACADE_PLUS_HEAD 869 870 } // namespace boost 871 872 #include <boost/iterator/detail/config_undef.hpp> 873 874 #endif // BOOST_ITERATOR_FACADE_23022003THW_HPP 875
