// Copyright David Abrahams 2003. Use, modification and distribution is

// subject to the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef IS_LVALUE_ITERATOR_DWA2003112_HPP

# define IS_LVALUE_ITERATOR_DWA2003112_HPP

#include <boost/iterator.hpp>

#include <boost/detail/workaround.hpp>

#include <boost/detail/iterator.hpp>

#include <boost/iterator/detail/any_conversion_eater.hpp>

// should be the last #includes

#include <boost/type_traits/detail/bool_trait_def.hpp>

#include <boost/iterator/detail/config_def.hpp>

#ifndef BOOST_NO_IS_CONVERTIBLE

namespace boost {

namespace detail

{

#ifndef BOOST_NO_LVALUE_RETURN_DETECTION

  // Calling lvalue_preserver( <expression>, 0 ) returns a reference

  // to the expression's result if <expression> is an lvalue, or

  // not_an_lvalue() otherwise.

  struct not_an_lvalue {};

  template <class T>

  T& lvalue_preserver(T&, int);

  template <class U>

  not_an_lvalue lvalue_preserver(U const&, ...);

# define BOOST_LVALUE_PRESERVER(expr) detail::lvalue_preserver(expr,0)

#else

# define BOOST_LVALUE_PRESERVER(expr) expr

#endif 

  // Guts of is_lvalue_iterator.  Value is the iterator's value_type

  // and the result is computed in the nested rebind template.

  template <class Value>

  struct is_lvalue_iterator_impl

  {

      // Eat implicit conversions so we don't report true for things

      // convertible to Value const&

      struct conversion_eater

      {

          conversion_eater(Value&);

      };

      static char tester(conversion_eater, int);

      static char (& tester(any_conversion_eater, ...) )[2];

      template <class It>

      struct rebind

      {

          static It& x;

          BOOST_STATIC_CONSTANT(

              bool

            , value = (

                sizeof(

                    is_lvalue_iterator_impl<Value>::tester(

                        BOOST_LVALUE_PRESERVER(*x), 0

                    )

                ) == 1

            )

          );

      };

  };

#undef BOOST_LVALUE_PRESERVER

  //

  // void specializations to handle std input and output iterators

  //

  template <>

  struct is_lvalue_iterator_impl<void>

  {

      template <class It>

      struct rebind : boost::mpl::false_

      {};

  };

#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS

  template <>

  struct is_lvalue_iterator_impl<const void>

  {

      template <class It>

      struct rebind : boost::mpl::false_

      {};

  };

  template <>

  struct is_lvalue_iterator_impl<volatile void>

  {

      template <class It>

      struct rebind : boost::mpl::false_

      {};

  };

  template <>

  struct is_lvalue_iterator_impl<const volatile void>

  {

      template <class It>

      struct rebind : boost::mpl::false_

      {};

  };

#endif

  //

  // This level of dispatching is required for Borland.  We might save

  // an instantiation by removing it for others.

  //

  template <class It>

  struct is_readable_lvalue_iterator_impl

    : is_lvalue_iterator_impl<

          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type const

      >::template rebind<It>

  {};

  template <class It>

  struct is_non_const_lvalue_iterator_impl

    : is_lvalue_iterator_impl<

          BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<It>::value_type

      >::template rebind<It>

  {};

} // namespace detail

// Define the trait with full mpl lambda capability and various broken

// compiler workarounds

BOOST_TT_AUX_BOOL_TRAIT_DEF1(

    is_lvalue_iterator,T,::boost::detail::is_readable_lvalue_iterator_impl<T>::value)

BOOST_TT_AUX_BOOL_TRAIT_DEF1(

    is_non_const_lvalue_iterator,T,::boost::detail::is_non_const_lvalue_iterator_impl<T>::value)

} // namespace boost

#endif

#include <boost/iterator/detail/config_undef.hpp>

#include <boost/type_traits/detail/bool_trait_undef.hpp>

#endif // IS_LVALUE_ITERATOR_DWA2003112_HPP