epoc32/include/stdapis/boost/iterator/detail/config_def.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
     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(0x531))                   \
    51     || (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
    52     || BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
    53 # define BOOST_NO_LVALUE_RETURN_DETECTION
    54 
    55 # if 0 // test code
    56   struct v  {};
    57 
    58   typedef  char (&no)[3];
    59 
    60   template <class T>
    61   no foo(T const&, ...);
    62 
    63   template <class T>
    64   char foo(T&, int);
    65 
    66 
    67   struct value_iterator
    68   {
    69       v operator*() const;
    70   };
    71 
    72   template <class T>
    73   struct lvalue_deref_helper
    74   {
    75       static T& x;
    76       enum { value = (sizeof(foo(*x,0)) == 1) };
    77   };
    78 
    79   int z2[(lvalue_deref_helper<v*>::value == 1) ? 1 : -1];
    80   int z[(lvalue_deref_helper<value_iterator>::value) == 1 ? -1 : 1 ];
    81 # endif 
    82 
    83 #endif
    84 
    85 #if BOOST_WORKAROUND(__MWERKS__, <=0x2407)
    86 #  define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
    87 #endif
    88 
    89 #if BOOST_WORKAROUND(__GNUC__, == 2)                                                                            \
    90     || 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(BOOST_MSVC, <= 1300)
   118 #  define BOOST_ARG_DEPENDENT_TYPENAME typename
   119 # else
   120 #  define BOOST_ARG_DEPENDENT_TYPENAME
   121 # endif
   122 
   123 # if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
   124     || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
   125 
   126 // GCC-2.95 eagerly instantiates templated constructors and conversion
   127 // operators in convertibility checks, causing premature errors.
   128 //
   129 // Borland's problems are harder to diagnose due to lack of an
   130 // instantiation stack backtrace.  They may be due in part to the fact
   131 // that it drops cv-qualification willy-nilly in templates.
   132 #  define BOOST_NO_ONE_WAY_ITERATOR_INTEROP
   133 # endif 
   134 
   135 // no include guard; multiple inclusion intended