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 8 // no include guard multiple inclusion intended 9 10 // 11 // This is a temporary workaround until the bulk of this is 12 // available in boost config. 13 // 23/02/03 thw 14 // 15 16 #include <boost/config.hpp> // for prior 17 #include <boost/detail/workaround.hpp> 18 19 #ifdef BOOST_ITERATOR_CONFIG_DEF 20 # error you have nested config_def #inclusion. 21 #else 22 # define BOOST_ITERATOR_CONFIG_DEF 23 #endif 24 25 // We enable this always now. Otherwise, the simple case in 26 // libs/iterator/test/constant_iterator_arrow.cpp fails to compile 27 // because the operator-> return is improperly deduced as a non-const 28 // pointer. 29 #if 1 || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 30 || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x531)) 31 32 // Recall that in general, compilers without partial specialization 33 // can't strip constness. Consider counting_iterator, which normally 34 // passes a const Value to iterator_facade. As a result, any code 35 // which makes a std::vector of the iterator's value_type will fail 36 // when its allocator declares functions overloaded on reference and 37 // const_reference (the same type). 38 // 39 // Furthermore, Borland 5.5.1 drops constness in enough ways that we 40 // end up using a proxy for operator[] when we otherwise shouldn't. 41 // Using reference constness gives it an extra hint that it can 42 // return the value_type from operator[] directly, but is not 43 // strictly necessary. Not sure how best to resolve this one. 44 45 # define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1 46 47 #endif 48 49 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 50 || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \ 51 || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ 52 || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \ 53 || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) 54 55 # define BOOST_NO_LVALUE_RETURN_DETECTION 56 57 # if 0 // test code 58 struct v {}; 59 60 typedef char (&no)[3]; 61 62 template <class T> 63 no foo(T const&, ...); 64 65 template <class T> 66 char foo(T&, int); 67 68 69 struct value_iterator 70 { 71 v operator*() const; 72 }; 73 74 template <class T> 75 struct lvalue_deref_helper 76 { 77 static T& x; 78 enum { value = (sizeof(foo(*x,0)) == 1) }; 79 }; 80 81 int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1]; 82 int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ]; 83 # endif 84 85 #endif 86 87 #if BOOST_WORKAROUND(__MWERKS__, <=0x2407) 88 # define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types" 89 #endif 90 91 #if BOOST_WORKAROUND(__GNUC__, == 2) \ 92 || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \ 93 || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) 94 # define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: 95 96 # if 0 // test code 97 #include <boost/type_traits/is_convertible.hpp> 98 template <class T> 99 struct foo 100 { 101 foo(T); 102 103 template <class U> 104 foo(foo<U> const& other) : p(other.p) { } 105 106 T p; 107 }; 108 109 bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value; 110 # endif 111 112 #endif 113 114 115 #if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)) 116 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY 117 #endif 118 119 # if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 120 # define BOOST_ARG_DEPENDENT_TYPENAME typename 121 # else 122 # define BOOST_ARG_DEPENDENT_TYPENAME 123 # endif 124 125 # if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \ 126 || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) 127 128 // GCC-2.95 eagerly instantiates templated constructors and conversion 129 // operators in convertibility checks, causing premature errors. 130 // 131 // Borland's problems are harder to diagnose due to lack of an 132 // instantiation stack backtrace. They may be due in part to the fact 133 // that it drops cv-qualification willy-nilly in templates. 134 # define BOOST_NO_ONE_WAY_ITERATOR_INTEROP 135 # endif 136 137 // no include guard; multiple inclusion intended 138