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(BOOST_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_BORLANDC, BOOST_TESTED_AT(0x5A0)) \ 50 || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \ 51 || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \ 52 || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) 53 54 # define BOOST_NO_LVALUE_RETURN_DETECTION 55 56 # if 0 // test code 57 struct v {}; 58 59 typedef char (&no)[3]; 60 61 template <class T> 62 no foo(T const&, ...); 63 64 template <class T> 65 char foo(T&, int); 66 67 68 struct value_iterator 69 { 70 v operator*() const; 71 }; 72 73 template <class T> 74 struct lvalue_deref_helper 75 { 76 static T& x; 77 enum { value = (sizeof(foo(*x,0)) == 1) }; 78 }; 79 80 int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1]; 81 int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ]; 82 # endif 83 84 #endif 85 86 #if BOOST_WORKAROUND(__MWERKS__, <=0x2407) 87 # define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types" 88 #endif 89 90 #if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \ 91 || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x551)) 92 # define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile: 93 94 # if 0 // test code 95 #include <boost/type_traits/is_convertible.hpp> 96 template <class T> 97 struct foo 98 { 99 foo(T); 100 101 template <class U> 102 foo(foo<U> const& other) : p(other.p) { } 103 104 T p; 105 }; 106 107 bool x = boost::is_convertible<foo<int const*>, foo<int*> >::value; 108 # endif 109 110 #endif 111 112 113 #if !defined(BOOST_MSVC) && (defined(BOOST_NO_SFINAE) || defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_IS_CONVERTIBLE_TEMPLATE)) 114 # define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY 115 #endif 116 117 # if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) 118 119 // GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion 120 // operators in convertibility checks, causing premature errors. 121 // 122 // Borland's problems are harder to diagnose due to lack of an 123 // instantiation stack backtrace. They may be due in part to the fact 124 // that it drops cv-qualification willy-nilly in templates. 125 # define BOOST_NO_ONE_WAY_ITERATOR_INTEROP 126 # endif 127 128 // no include guard; multiple inclusion intended 129