// (C) Copyright David Abrahams 2002.

// (C) Copyright Jeremy Siek    2002.

// (C) Copyright Thomas Witt    2002.

// Distributed under 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 BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

#define BOOST_TRANSFORM_ITERATOR_23022003THW_HPP

#include <boost/function.hpp>

#include <boost/iterator.hpp>

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

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_categories.hpp>

#include <boost/mpl/not.hpp>

#include <boost/mpl/bool.hpp>

#include <boost/type_traits/function_traits.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/is_class.hpp>

#include <boost/type_traits/is_function.hpp>

#include <boost/type_traits/is_reference.hpp>

#include <boost/type_traits/remove_const.hpp>

#include <boost/type_traits/remove_reference.hpp>

#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))

# include <boost/type_traits/is_base_and_derived.hpp>

#endif 

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

namespace boost

{

  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>

  class transform_iterator;

  namespace detail 

  {

    template <class UnaryFunction>

    struct function_object_result

    {

      typedef typename UnaryFunction::result_type type;

    };

#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

    template <class Return, class Argument>

    struct function_object_result<Return(*)(Argument)>

    {

      typedef Return type;

    };

#endif

    // Compute the iterator_adaptor instantiation to be used for transform_iterator

    template <class UnaryFunction, class Iterator, class Reference, class Value>

    struct transform_iterator_base

    {

     private:

        // By default, dereferencing the iterator yields the same as

        // the function.  Do we need to adjust the way

        // function_object_result is computed for the standard

        // proposal (e.g. using Doug's result_of)?

        typedef typename ia_dflt_help<

            Reference

          , function_object_result<UnaryFunction>

        >::type reference;

        // To get the default for Value: remove any reference on the

        // result type, but retain any constness to signal

        // non-writability.  Note that if we adopt Thomas' suggestion

        // to key non-writability *only* on the Reference argument,

        // we'd need to strip constness here as well.

        typedef typename ia_dflt_help<

            Value

          , remove_reference<reference>

        >::type cv_value_type;

     public:

        typedef iterator_adaptor<

            transform_iterator<UnaryFunction, Iterator, Reference, Value>

          , Iterator

          , cv_value_type

          , use_default    // Leave the traversal category alone

          , reference

        > type;

    };

  }

  template <class UnaryFunction, class Iterator, class Reference, class Value>

  class transform_iterator

    : public detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type

  {

    typedef typename

    detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type

    super_t;

    friend class iterator_core_access;

  public:

    transform_iterator() { }

    transform_iterator(Iterator const& x, UnaryFunction f)

      : super_t(x), m_f(f) { }

    explicit transform_iterator(Iterator const& x)

      : super_t(x)

    {

        // Pro8 is a little too aggressive about instantiating the

        // body of this function.

#if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))

        // don't provide this constructor if UnaryFunction is a

        // function pointer type, since it will be 0.  Too dangerous.

        BOOST_STATIC_ASSERT(is_class<UnaryFunction>::value);

#endif 

    }

    template<

        class OtherUnaryFunction

      , class OtherIterator

      , class OtherReference

      , class OtherValue>

    transform_iterator(

         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t

       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0

#if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)

       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunction>::type* = 0

#endif 

    )

      : super_t(t.base()), m_f(t.functor())

   {}

    UnaryFunction functor() const

      { return m_f; }

  private:

    typename super_t::reference dereference() const

    { return m_f(*this->base()); }

    // Probably should be the initial base class so it can be

    // optimized away via EBO if it is an empty class.

    UnaryFunction m_f;

  };

  template <class UnaryFunction, class Iterator>

  transform_iterator<UnaryFunction, Iterator>

  make_transform_iterator(Iterator it, UnaryFunction fun)

  {

      return transform_iterator<UnaryFunction, Iterator>(it, fun);

  }

  // Version which allows explicit specification of the UnaryFunction

  // type.

  //

  // This generator is not provided if UnaryFunction is a function

  // pointer type, because it's too dangerous: the default-constructed

  // function pointer in the iterator be 0, leading to a runtime

  // crash.

  template <class UnaryFunction, class Iterator>

#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

  typename mpl::if_<

#else 

  typename iterators::enable_if<

#endif 

      is_class<UnaryFunction>   // We should probably find a cheaper test than is_class<>

    , transform_iterator<UnaryFunction, Iterator>

#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

    , int[3]

#endif 

  >::type

  make_transform_iterator(Iterator it)

  {

      return transform_iterator<UnaryFunction, Iterator>(it, UnaryFunction());

  }

#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)

  template <class Return, class Argument, class Iterator>

  transform_iterator< Return (*)(Argument), Iterator, Return>

  make_transform_iterator(Iterator it, Return (*fun)(Argument))

  {

    return transform_iterator<Return (*)(Argument), Iterator, Return>(it, fun);

  }

#endif

} // namespace boost

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

#endif // BOOST_TRANSFORM_ITERATOR_23022003THW_HPP