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