text: #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
  