//

 // Boost.Pointer Container

 //

 //  Copyright Thorsten Ottosen 2003-2005. 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)

 //

 // For more information, see http://www.boost.org/libs/ptr_container/

 //

 #ifndef BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP

 #define BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP

 #if defined(_MSC_VER) && (_MSC_VER >= 1200)

 # pragma once

 #endif

 #include <boost/config.hpp>

 #include <boost/iterator/iterator_adaptor.hpp>

 #include <utility>

 namespace boost

 { 

     namespace ptr_container_detail

     {

         template< class F, class S >

         struct ref_pair

         {

             typedef F first_type;

             typedef S second_type;

             const F& first;

             S        second;

             template< class F2, class S2 >

             ref_pair( const std::pair<F2,S2>& p )

             : first(p.first), second(static_cast<S>(p.second))

             { }

             template< class RP >

             ref_pair( const RP* rp )

             : first(rp->first), second(rp->second)

             { }

             const ref_pair* const operator->() const

             {

                 return this;

             }

         };

     }

     template< 

               class I, // base iterator 

               class F, // first type, key type

               class S  // second type, mapped type

             > 

     class ptr_map_iterator : 

         public boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 

                                         ptr_container_detail::ref_pair<F,S>, 

                                         use_default, 

                                         ptr_container_detail::ref_pair<F,S> >

     {

         typedef boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 

                                          ptr_container_detail::ref_pair<F,S>,

                                          use_default, 

                                          ptr_container_detail::ref_pair<F,S> > 

             base_type;

     public:

         ptr_map_iterator() : base_type()                                 

         { }

         explicit ptr_map_iterator( const I& i ) : base_type(i)

         { }

         template< class I2, class F2, class S2 >

             ptr_map_iterator( const ptr_map_iterator<I2,F2,S2>& r ) 

          : base_type(r.base())

         { }

    }; // class 'ptr_map_iterator'

 }

 #endif