#ifndef BOOST_RANGE_MFC_HPP

#define BOOST_RANGE_MFC_HPP

// Boost.Range MFC Extension

//

// Copyright Shunsuke Sogame 2005-2006.

// 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)

// config

//

#include <afx.h> // _MFC_VER

#if !defined(BOOST_RANGE_MFC_NO_CPAIR)

    #if (_MFC_VER < 0x0700) // dubious

        #define BOOST_RANGE_MFC_NO_CPAIR

    #endif

#endif

#if !defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)

    #if (_MFC_VER < 0x0700) // dubious

        #define BOOST_RANGE_MFC_HAS_LEGACY_STRING

    #endif

#endif

// A const collection of old MFC doesn't return const reference.

//

#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)

    #if (_MFC_VER < 0x0700) // dubious

        #define BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF

    #endif

#endif

// forward declarations

//

template< class Type, class ArgType >

class CArray;

template< class Type, class ArgType >

class CList;

template< class Key, class ArgKey, class Mapped, class ArgMapped >

class CMap;

template< class BaseClass, class PtrType >

class CTypedPtrArray;

template< class BaseClass, class PtrType >

class CTypedPtrList;

template< class BaseClass, class KeyPtrType, class MappedPtrType >

class CTypedPtrMap;

// extended customizations

//

#include <cstddef> // ptrdiff_t

#include <utility> // pair

#include <boost/assert.hpp>

#include <boost/mpl/if.hpp>

#include <boost/range/atl.hpp>

#include <boost/range/begin.hpp>

#include <boost/range/const_iterator.hpp>

#include <boost/range/detail/microsoft.hpp>

#include <boost/range/end.hpp>

#include <boost/iterator/iterator_adaptor.hpp>

#include <boost/iterator/iterator_categories.hpp>

#include <boost/iterator/iterator_facade.hpp>

#include <boost/iterator/transform_iterator.hpp>

#include <boost/type_traits/is_const.hpp>

#include <boost/type_traits/remove_pointer.hpp>

#include <boost/utility/addressof.hpp>

#include <afx.h> // legacy CString

#include <afxcoll.h> // CXXXArray, CXXXList, CMapXXXToXXX

#include <tchar.h>

namespace boost { namespace range_detail_microsoft {

    // mfc_ptr_array_iterator

    //

    // 'void **' is not convertible to 'void const **',

    // so we define...

    //

    template< class ArrayT, class PtrType >

    struct mfc_ptr_array_iterator;

    template< class ArrayT, class PtrType >

    struct mfc_ptr_array_iterator_super

    {

        typedef iterator_adaptor<

            mfc_ptr_array_iterator<ArrayT, PtrType>,

            std::ptrdiff_t, // Base!

            PtrType,        // Value

            random_access_traversal_tag,

            use_default,

            std::ptrdiff_t  // Difference

        > type;

    };

    template< class ArrayT, class PtrType >

    struct mfc_ptr_array_iterator :

        mfc_ptr_array_iterator_super<ArrayT, PtrType>::type

    {

    private:

        typedef mfc_ptr_array_iterator self_t;

        typedef typename mfc_ptr_array_iterator_super<ArrayT, PtrType>::type super_t;

        typedef typename super_t::reference ref_t;

    public:

        explicit mfc_ptr_array_iterator()

        { }

        explicit mfc_ptr_array_iterator(ArrayT& arr, INT_PTR index) :

            super_t(index), m_parr(boost::addressof(arr))

        { }

    template< class, class > friend struct mfc_ptr_array_iterator;

        template< class ArrayT_, class PtrType_ >

        mfc_ptr_array_iterator(mfc_ptr_array_iterator<ArrayT_, PtrType_> const& other) :

            super_t(other.base()), m_parr(other.m_parr)

        { }

    private:

        ArrayT *m_parr;

    friend class iterator_core_access;

        ref_t dereference() const

        {

            BOOST_ASSERT(0 <= this->base() && this->base() < m_parr->GetSize() && "out of range");

            return *( m_parr->GetData() + this->base() );

        }

        bool equal(self_t const& other) const

        {

            BOOST_ASSERT(m_parr == other.m_parr && "iterators incompatible");

            return this->base() == other.base();

        }

    };

    struct mfc_ptr_array_functions

    {

        template< class Iterator, class X >

        Iterator begin(X& x)

        {

            return Iterator(x, 0);

        }

        template< class Iterator, class X >

        Iterator end(X& x)

        {

            return Iterator(x, x.GetSize());

        }

    };

    // arrays

    //

    template< >

    struct customization< ::CByteArray > :

        array_functions

    {

        template< class X >

        struct meta

        {

            typedef BYTE val_t;

            typedef val_t *mutable_iterator;

            typedef val_t const *const_iterator;

        };

    };

    template< >

    struct customization< ::CDWordArray > :

        array_functions

    {

        template< class X >

        struct meta

        {

            typedef DWORD val_t;

            typedef val_t *mutable_iterator;

            typedef val_t const *const_iterator;

        };

    };

    template< >

    struct customization< ::CObArray > :

        mfc_ptr_array_functions

    {

        template< class X >

        struct meta

        {

            typedef mfc_ptr_array_iterator<X, CObject *> mutable_iterator;

            typedef mfc_ptr_array_iterator<X const, CObject const *> const_iterator;

        };

    };

    template< >

    struct customization< ::CPtrArray > :

        mfc_ptr_array_functions

    {

        template< class X >

        struct meta

        {

            typedef mfc_ptr_array_iterator<X, void *> mutable_iterator;

            typedef mfc_ptr_array_iterator<X const, void const *> const_iterator;

        };

    };

    template< >

    struct customization< ::CStringArray > :

        array_functions

    {

        template< class X >

        struct meta

        {

            typedef ::CString val_t;

            typedef val_t *mutable_iterator;

            typedef val_t const *const_iterator;

        };

    };

    template< >

    struct customization< ::CUIntArray > :

        array_functions

    {

        template< class X >

        struct meta

        {

            typedef UINT val_t;

            typedef val_t *mutable_iterator;

            typedef val_t const *const_iterator;

        };

    };

    template< >

    struct customization< ::CWordArray > :

        array_functions

    {

        template< class X >

        struct meta

        {

            typedef WORD val_t;

            typedef val_t *mutable_iterator;

            typedef val_t const *const_iterator;

        };

    };

    // lists

    //

    template< >

    struct customization< ::CObList > :

        list_functions

    {

        template< class X >

        struct meta

        {

            typedef list_iterator<X, ::CObject *> mutable_iterator;

    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)

            typedef list_iterator<X const, ::CObject const *> const_iterator;

    #else

            typedef list_iterator<X const, ::CObject const * const, ::CObject const * const> const_iterator;

    #endif

        };

    };

    template< >

    struct customization< ::CPtrList > :

        list_functions

    {

        template< class X >

        struct meta

        {

            typedef list_iterator<X, void *> mutable_iterator;

    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)

            typedef list_iterator<X const, void const *> const_iterator;

    #else

            typedef list_iterator<X const, void const * const, void const * const> const_iterator;

    #endif

        };

    };

    template< >

    struct customization< ::CStringList > :

        list_functions

    {

        template< class X >

        struct meta

        {

            typedef ::CString val_t;

            typedef list_iterator<X, val_t> mutable_iterator;

    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)

            typedef list_iterator<X const, val_t const> const_iterator;

    #else

            typedef list_iterator<X const, val_t const, val_t const> const_iterator;

    #endif

        };

    };

    // mfc_map_iterator

    //

    template< class MapT, class KeyT, class MappedT >

    struct mfc_map_iterator;

    template< class MapT, class KeyT, class MappedT >

    struct mfc_map_iterator_super

    {

        typedef iterator_facade<

            mfc_map_iterator<MapT, KeyT, MappedT>,

            std::pair<KeyT, MappedT>,

            forward_traversal_tag,

            std::pair<KeyT, MappedT> const

        > type;

    };

    template< class MapT, class KeyT, class MappedT >

    struct mfc_map_iterator :

        mfc_map_iterator_super<MapT, KeyT, MappedT>::type

    {

    private:

        typedef mfc_map_iterator self_t;

        typedef typename mfc_map_iterator_super<MapT, KeyT, MappedT>::type super_t;

        typedef typename super_t::reference ref_t;

    public:

        explicit mfc_map_iterator()

        { }

        explicit mfc_map_iterator(MapT const& map, POSITION pos) :

            m_pmap(boost::addressof(map)), m_posNext(pos)

        {

            increment();

        }

        explicit mfc_map_iterator(MapT const& map) :

            m_pmap(&map), m_pos(0) // end iterator

        { }

    template< class, class, class > friend struct mfc_map_iterator;

        template< class MapT_, class KeyT_, class MappedT_>

        mfc_map_iterator(mfc_map_iterator<MapT_, KeyT_, MappedT_> const& other) :

            m_pmap(other.m_pmap),

            m_pos(other.m_pos), m_posNext(other.m_posNext),

            m_key(other.m_key), m_mapped(other.m_mapped)

        { }

    private:

        MapT const *m_pmap;

        POSITION m_pos, m_posNext;

        KeyT m_key; MappedT m_mapped;

    friend class iterator_core_access;

        ref_t dereference() const

        {

            BOOST_ASSERT(m_pos != 0 && "out of range");

            return std::make_pair(m_key, m_mapped);

        }

        void increment()

        {

            BOOST_ASSERT(m_pos != 0 && "out of range");

            if (m_posNext == 0) {

                m_pos = 0;

                return;

            }

            m_pos = m_posNext;

            m_pmap->GetNextAssoc(m_posNext, m_key, m_mapped);

        }

        bool equal(self_t const& other) const

        {

            BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");

            return m_pos == other.m_pos;

        }

    };

    struct mfc_map_functions

    {

        template< class Iterator, class X >

        Iterator begin(X& x)

        {

            return Iterator(x, x.GetStartPosition());

        }

        template< class Iterator, class X >

        Iterator end(X& x)

        {

            return Iterator(x);

        }

    };

#if !defined(BOOST_RANGE_MFC_NO_CPAIR)

    // mfc_cpair_map_iterator

    //

    // used by ::CMap and ::CMapStringToString

    //

    template< class MapT, class PairT >

    struct mfc_cpair_map_iterator;

    template< class MapT, class PairT >

    struct mfc_pget_map_iterator_super

    {

        typedef iterator_facade<

            mfc_cpair_map_iterator<MapT, PairT>,

            PairT,

            forward_traversal_tag

        > type;

    };

    template< class MapT, class PairT >

    struct mfc_cpair_map_iterator :

        mfc_pget_map_iterator_super<MapT, PairT>::type

    {

    private:

        typedef mfc_cpair_map_iterator self_t;

        typedef typename mfc_pget_map_iterator_super<MapT, PairT>::type super_t;

        typedef typename super_t::reference ref_t;

    public:

        explicit mfc_cpair_map_iterator()

        { }

        explicit mfc_cpair_map_iterator(MapT& map, PairT *pp) :

            m_pmap(boost::addressof(map)), m_pp(pp)

        { }

    template< class, class > friend struct mfc_cpair_map_iterator;

        template< class MapT_, class PairT_>

        mfc_cpair_map_iterator(mfc_cpair_map_iterator<MapT_, PairT_> const& other) :

            m_pmap(other.m_pmap), m_pp(other.m_pp)

        { }

    private:

        MapT  *m_pmap;

        PairT *m_pp;

    friend class iterator_core_access;

        ref_t dereference() const

        {

            BOOST_ASSERT(m_pp != 0 && "out of range");

            return *m_pp;

        }

        void increment()

        {

            BOOST_ASSERT(m_pp != 0 && "out of range");

            m_pp = m_pmap->PGetNextAssoc(m_pp);

        }

        bool equal(self_t const& other) const

        {

            BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");

            return m_pp == other.m_pp;

        }

    };

    struct mfc_cpair_map_functions

    {

        template< class Iterator, class X >

        Iterator begin(X& x)

        {

            // Workaround:

            // Assertion fails if empty.

            // MFC document is wrong.

    #if !defined(NDEBUG)

            if (x.GetCount() == 0) 

                return Iterator(x, 0);

    #endif

            return Iterator(x, x.PGetFirstAssoc());

        }

        template< class Iterator, class X >

        Iterator end(X& x)

        {

            return Iterator(x, 0);

        }

    };

#endif // !defined(BOOST_RANGE_MFC_NO_CPAIR)