ceph/src/boost/libs/iterator/include/boost/iterator/detail/config_def.hpp

   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(__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(__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(__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