--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imgtools/imglib/boostlibrary/boost/range/mfc.hpp Tue Oct 27 16:36:35 2009 +0000
@@ -0,0 +1,984 @@
+#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)
+
+
+ // maps
+ //
+
+ template< >
+ struct customization< ::CMapPtrToWord > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef void *key_t;
+ typedef WORD mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapPtrToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef void *key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToOb > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString key_t;
+ typedef ::CObject *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToString > :
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ mfc_cpair_map_functions
+ #else
+ mfc_map_functions
+ #endif
+ {
+ template< class X >
+ struct meta
+ {
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ typedef typename X::CPair pair_t;
+
+ typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+ typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+ #else
+ typedef ::CString key_t;
+ typedef ::CString mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ #endif
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapWordToOb > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef WORD key_t;
+ typedef ::CObject *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapWordToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef WORD key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ // templates
+ //
+
+ template< class Type, class ArgType >
+ struct customization< ::CArray<Type, ArgType> > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef Type val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< class Type, class ArgType >
+ struct customization< ::CList<Type, ArgType> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef Type 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
+ };
+ };
+
+
+ template< class Key, class ArgKey, class Mapped, class ArgMapped >
+ struct customization< ::CMap<Key, ArgKey, Mapped, ArgMapped> > :
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ mfc_cpair_map_functions
+ #else
+ mfc_map_functions
+ #endif
+ {
+ template< class X >
+ struct meta
+ {
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ typedef typename X::CPair pair_t;
+
+ typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+ typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+ #else
+ typedef Key key_t;
+ typedef Mapped mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ #endif
+ };
+ };
+
+
+ template< class BaseClass, class PtrType >
+ struct customization< ::CTypedPtrArray<BaseClass, PtrType> >
+ {
+ template< class X >
+ struct fun
+ {
+ typedef typename remove_pointer<PtrType>::type val_t;
+
+ typedef typename mpl::if_< is_const<X>,
+ val_t const,
+ val_t
+ >::type val_t_;
+
+ typedef val_t_ * const result_type;
+
+ template< class PtrType_ >
+ result_type operator()(PtrType_ p) const
+ {
+ return static_cast<result_type>(p);
+ }
+ };
+
+ template< class X >
+ struct meta
+ {
+ typedef typename compatible_mutable_iterator<BaseClass>::type miter_t;
+ typedef typename range_const_iterator<BaseClass>::type citer_t;
+
+ typedef transform_iterator<fun<X>, miter_t> mutable_iterator;
+ typedef transform_iterator<fun<X const>, citer_t> const_iterator;
+ };
+
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(boost::begin<BaseClass>(x), fun<X>());
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(boost::end<BaseClass>(x), fun<X>());
+ }
+ };
+
+
+ template< class BaseClass, class PtrType >
+ struct customization< ::CTypedPtrList<BaseClass, PtrType> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef typename remove_pointer<PtrType>::type val_t;
+
+ // not l-value
+ typedef list_iterator<X, val_t * const, val_t * const> mutable_iterator;
+ typedef list_iterator<X const, val_t const * const, val_t const * const> const_iterator;
+ };
+ };
+
+
+ template< class BaseClass, class KeyPtrType, class MappedPtrType >
+ struct customization< ::CTypedPtrMap<BaseClass, KeyPtrType, MappedPtrType> > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef mfc_map_iterator<X, KeyPtrType, MappedPtrType> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ // strings
+ //
+
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+ template< >
+ struct customization< ::CString >
+ {
+ template< class X >
+ struct meta
+ {
+ // LPTSTR/LPCTSTR is not always defined in <tchar.h>.
+ typedef TCHAR *mutable_iterator;
+ typedef TCHAR const *const_iterator;
+ };
+
+ template< class Iterator, class X >
+ typename mutable_<Iterator, X>::type begin(X& x)
+ {
+ return x.GetBuffer(0);
+ }
+
+ template< class Iterator, class X >
+ Iterator begin(X const& x)
+ {
+ return x;
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return begin<Iterator>(x) + x.GetLength();
+ }
+ };
+
+#endif // defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// range customizations
+//
+
+
+// arrays
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CByteArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CDWordArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CStringArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CUIntArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CWordArray
+)
+
+
+// lists
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CObList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CPtrList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CStringList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CObArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CPtrArray
+)
+
+
+// maps
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapPtrToWord
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapPtrToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToString
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapWordToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapWordToPtr
+)
+
+
+// templates
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMap, 4
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrMap, 3
+)
+
+
+// strings
+//
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CString
+ )
+
+#endif
+
+
+
+
+#endif