985 lines
24 KiB
C++
Executable File
985 lines
24 KiB
C++
Executable File
#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
|