[ceph.git] / ceph / src / boost / libs / bimap / include / boost / bimap / detail / map_view_iterator.hpp

// Boost.Bimap
//
// Copyright (c) 2006-2007 Matias Capeletto
//
// 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)

/// \file detail/map_view_iterator.hpp
/// \brief Iterator adaptors from multi-index to bimap.

#ifndef BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
#define BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/config.hpp>

// Boost

#ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
  #include <boost/serialization/nvp.hpp>
#endif // BOOST_BIMAP_DISABLE_SERIALIZATION

#include <boost/iterator/detail/enable_if.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/bimap/relation/support/pair_by.hpp>

// check
#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
#include <boost/bimap/relation/detail/static_access_builder.hpp>

namespace boost {
namespace bimaps {
namespace detail {

/** \brief Map View Iterator adaptors from multi index to bimap.

These classes are based on transform iterators from Boost.Iterator.
                                                                         **/

template< class Tag, class BimapCore > struct       map_view_iterator ;
template< class Tag, class BimapCore > struct const_map_view_iterator ;

template< class Tag, class BimapCore > struct       reverse_map_view_iterator ;
template< class Tag, class BimapCore > struct const_reverse_map_view_iterator ;

template< class Tag, class BimapCore > struct       local_map_view_iterator ;
template< class Tag, class BimapCore > struct const_local_map_view_iterator ;


#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES

#ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
/*===========================================================================*/
#define BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT                   \
    BOOST_SERIALIZATION_SPLIT_MEMBER()                                        \
                                                                              \
    friend class ::boost::serialization::access;                              \
                                                                              \
    template< class Archive >                                                 \
    void save(Archive & ar, const unsigned int) const                         \
    {                                                                         \
        ar << ::boost::serialization::make_nvp("mi_iterator",this->base());   \
    }                                                                         \
                                                                              \
    template< class Archive >                                                 \
    void load(Archive & ar, const unsigned int)                               \
    {                                                                         \
        BOOST_DEDUCED_TYPENAME base_::base_type iter;                         \
        ar >> ::boost::serialization::make_nvp("mi_iterator",iter);           \
        this->base_reference() = iter;                                        \
    }
/*===========================================================================*/
#else
#define BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT // None
#endif // BOOST_BIMAP_DISABLE_SERIALIZATION

/*===========================================================================*/
#define BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( METANAME, ITERATOR )       \
BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER( METANAME, BimapCore,             \
    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE\
        index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag>                     \
            ::type::ITERATOR type,                                            \
    typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE\
        index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag>                    \
            ::type::ITERATOR type                                             \
)
/*===========================================================================*/


BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( core_iterator_type_by
                                         , iterator )

BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( reverse_core_iterator_type_by
                                         , reverse_iterator )

BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( local_core_iterator_type_by
                                         , local_iterator )


// map_view_iterator

template< class Tag, class BimapCore >
struct map_view_iterator_adaptor {
    typedef iterator_adaptor<
        map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME core_iterator_type_by<Tag,BimapCore>::type,
        BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct map_view_iterator : 
    public map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    public:

    map_view_iterator() {}
    map_view_iterator(BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    map_view_iterator(map_view_iterator const & iter)
      : base_(iter.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(
            *const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type*>(
                &(*this->base())
            )
        );
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};


template< class Tag, class BimapCore >
struct const_map_view_iterator_adaptor {
    typedef iterator_adaptor<
        const_map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME core_iterator_type_by<Tag,BimapCore>::type,
        const BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct const_map_view_iterator : 
    public const_map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        const_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    public:

    const_map_view_iterator() {}
    const_map_view_iterator(
            BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    const_map_view_iterator(const_map_view_iterator const & iter)
      : base_(iter.base()) {}
	const_map_view_iterator(map_view_iterator<Tag,BimapCore> i)
      : base_(i.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};


// reverse_map_view_iterator

template< class Tag, class BimapCore >
struct reverse_map_view_iterator_adaptor {
    typedef iterator_adaptor<
        reverse_map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME 
            reverse_core_iterator_type_by<Tag,BimapCore>::type,
        BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct reverse_map_view_iterator :
    public reverse_map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        reverse_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    public:

    reverse_map_view_iterator() {}
    reverse_map_view_iterator(
            BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    reverse_map_view_iterator(reverse_map_view_iterator const & iter)
      : base_(iter.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(
            *const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type*>(
                &(*this->base())
            )
        );
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};

template< class Tag, class BimapCore >
struct const_reverse_map_view_iterator_adaptor {
    typedef iterator_adaptor<
        const_reverse_map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME 
            reverse_core_iterator_type_by<Tag,BimapCore>::type,
        const BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct const_reverse_map_view_iterator :
    public const_reverse_map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        const_reverse_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    
    public:

    const_reverse_map_view_iterator() {}
    const_reverse_map_view_iterator(
            BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    const_reverse_map_view_iterator(const_reverse_map_view_iterator const & iter)
      : base_(iter.base()) {}
	const_reverse_map_view_iterator(reverse_map_view_iterator<Tag,BimapCore> i)
      : base_(i.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};


// local_map_view_iterator

template< class Tag, class BimapCore >
struct local_map_view_iterator_adaptor {
    typedef iterator_adaptor<
        local_map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME 
            local_core_iterator_type_by<Tag,BimapCore>::type,
        BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct local_map_view_iterator :
    public local_map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        local_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    public:

    local_map_view_iterator() {}
    local_map_view_iterator(
            BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    local_map_view_iterator(local_map_view_iterator const & iter)
      : base_(iter.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(
            *const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type*>(
                &(*this->base())
            )
        );
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};

template< class Tag, class BimapCore >
struct const_local_map_view_iterator_adaptor {
    typedef iterator_adaptor<
        const_local_map_view_iterator<Tag,BimapCore>,
        BOOST_DEDUCED_TYPENAME 
            local_core_iterator_type_by<Tag,BimapCore>::type,
        const BOOST_DEDUCED_TYPENAME 
            ::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
    > type;
};
template< class Tag, class BimapCore >
struct const_local_map_view_iterator :
    public const_local_map_view_iterator_adaptor<Tag,BimapCore>::type
{
    typedef BOOST_DEDUCED_TYPENAME 
        const_local_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
    public:

    const_local_map_view_iterator() {}
    const_local_map_view_iterator(
            BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
      : base_(iter) {}
    const_local_map_view_iterator(const_local_map_view_iterator const & iter)
      : base_(iter.base()) {}
	const_local_map_view_iterator(local_map_view_iterator<Tag,BimapCore> i)
      : base_(i.base()) {}

    BOOST_DEDUCED_TYPENAME base_::reference dereference() const
    {
        return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
    }
    private:
    friend class iterator_core_access;
    BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
};

#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES

} // namespace detail
} // namespace bimaps
} // namespace boost

#endif // BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
Commit	Line	Data
7c673cae FG	1	// Boost.Bimap
	2	//
	3	// Copyright (c) 2006-2007 Matias Capeletto
	4	//
	5	// Distributed under the Boost Software License, Version 1.0.
	6	// (See accompanying file LICENSE_1_0.txt or copy at
	7	// http://www.boost.org/LICENSE_1_0.txt)
	8
	9	/// \file detail/map_view_iterator.hpp
	10	/// \brief Iterator adaptors from multi-index to bimap.
	11
	12	#ifndef BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
	13	#define BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
	14
	15	#if defined(_MSC_VER)
	16	#pragma once
	17	#endif
	18
	19	#include <boost/config.hpp>
	20
	21	// Boost
	22
	23	#ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
	24	#include <boost/serialization/nvp.hpp>
	25	#endif // BOOST_BIMAP_DISABLE_SERIALIZATION
	26
	27	#include <boost/iterator/detail/enable_if.hpp>
	28	#include <boost/iterator/iterator_adaptor.hpp>
	29	#include <boost/bimap/relation/support/pair_by.hpp>
	30
	31	// check
	32	#include <boost/bimap/relation/detail/metadata_access_builder.hpp>
	33	#include <boost/bimap/relation/detail/static_access_builder.hpp>
	34
	35	namespace boost {
	36	namespace bimaps {
	37	namespace detail {
	38
	39	/** \brief Map View Iterator adaptors from multi index to bimap.
	40
	41	These classes are based on transform iterators from Boost.Iterator.
	42	**/
	43
	44	template< class Tag, class BimapCore > struct map_view_iterator ;
	45	template< class Tag, class BimapCore > struct const_map_view_iterator ;
	46
	47	template< class Tag, class BimapCore > struct reverse_map_view_iterator ;
	48	template< class Tag, class BimapCore > struct const_reverse_map_view_iterator ;
	49
	50	template< class Tag, class BimapCore > struct local_map_view_iterator ;
	51	template< class Tag, class BimapCore > struct const_local_map_view_iterator ;
	52
	53
	54	#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
	55
	56	#ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
	57	/===========================================================================/
	58	#define BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT \
	59	BOOST_SERIALIZATION_SPLIT_MEMBER() \
	60	\
	61	friend class ::boost::serialization::access; \
	62	\
	63	template< class Archive > \
	64	void save(Archive & ar, const unsigned int) const \
65	{ \
66	ar << ::boost::serialization::make_nvp("mi_iterator",this->base()); \
67	} \
68	\
69	template< class Archive > \
70	void load(Archive & ar, const unsigned int) \
71	{ \
72	BOOST_DEDUCED_TYPENAME base_::base_type iter; \
73	ar >> ::boost::serialization::make_nvp("mi_iterator",iter); \
74	this->base_reference() = iter; \
75	}
76	/===========================================================================/
77	#else
78	#define BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT // None
79	#endif // BOOST_BIMAP_DISABLE_SERIALIZATION
80
81	/===========================================================================/
82	#define BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( METANAME, ITERATOR ) \
83	BOOST_BIMAP_SYMMETRIC_STATIC_ACCESS_BUILDER( METANAME, BimapCore, \
84	typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE\
85	index<BOOST_DEDUCED_TYPENAME BimapCore::left_tag> \
86	::type::ITERATOR type, \
87	typedef BOOST_DEDUCED_TYPENAME BimapCore::core_type::BOOST_NESTED_TEMPLATE\
88	index<BOOST_DEDUCED_TYPENAME BimapCore::right_tag> \
89	::type::ITERATOR type \
90	)
91	/===========================================================================/
92
93
94	BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( core_iterator_type_by
95	, iterator )
96
97	BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( reverse_core_iterator_type_by
98	, reverse_iterator )
99
100	BOOST_BIMAP_CORE_ITERATOR_TYPE_BY_BUILDER( local_core_iterator_type_by
101	, local_iterator )
102
103
104	// map_view_iterator
105
106	template< class Tag, class BimapCore >
107	struct map_view_iterator_adaptor {
108	typedef iterator_adaptor<
109	map_view_iterator<Tag,BimapCore>,
110	BOOST_DEDUCED_TYPENAME core_iterator_type_by<Tag,BimapCore>::type,
111	BOOST_DEDUCED_TYPENAME
112	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
113	> type;
114	};
115	template< class Tag, class BimapCore >
116	struct map_view_iterator :
117	public map_view_iterator_adaptor<Tag,BimapCore>::type
118	{
119	typedef BOOST_DEDUCED_TYPENAME
120	map_view_iterator_adaptor<Tag,BimapCore>::type base_;
121	public:
122
123	map_view_iterator() {}
124	map_view_iterator(BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
125	: base_(iter) {}
126	map_view_iterator(map_view_iterator const & iter)
127	: base_(iter.base()) {}
128
129	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
130	{
131	return ::boost::bimaps::relation::support::pair_by<Tag>(
132	const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type>(
133	&(*this->base())
134	)
135	);
136	}
137	private:
138	friend class iterator_core_access;
139	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
140	};
141
142
143	template< class Tag, class BimapCore >
144	struct const_map_view_iterator_adaptor {
145	typedef iterator_adaptor<
146	const_map_view_iterator<Tag,BimapCore>,
147	BOOST_DEDUCED_TYPENAME core_iterator_type_by<Tag,BimapCore>::type,
148	const BOOST_DEDUCED_TYPENAME
149	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
150	> type;
151	};
152	template< class Tag, class BimapCore >
153	struct const_map_view_iterator :
154	public const_map_view_iterator_adaptor<Tag,BimapCore>::type
155	{
156	typedef BOOST_DEDUCED_TYPENAME
157	const_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
158	public:
159
160	const_map_view_iterator() {}
161	const_map_view_iterator(
162	BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
163	: base_(iter) {}
164	const_map_view_iterator(const_map_view_iterator const & iter)
165	: base_(iter.base()) {}
166	const_map_view_iterator(map_view_iterator<Tag,BimapCore> i)
167	: base_(i.base()) {}
168
169	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
170	{
171	return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
172	}
173	private:
174	friend class iterator_core_access;
175	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
176	};
177
178
179	// reverse_map_view_iterator
180
181	template< class Tag, class BimapCore >
182	struct reverse_map_view_iterator_adaptor {
183	typedef iterator_adaptor<
184	reverse_map_view_iterator<Tag,BimapCore>,
185	BOOST_DEDUCED_TYPENAME
186	reverse_core_iterator_type_by<Tag,BimapCore>::type,
187	BOOST_DEDUCED_TYPENAME
188	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
189	> type;
190	};
191	template< class Tag, class BimapCore >
192	struct reverse_map_view_iterator :
193	public reverse_map_view_iterator_adaptor<Tag,BimapCore>::type
194	{
195	typedef BOOST_DEDUCED_TYPENAME
196	reverse_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
197	public:
198
199	reverse_map_view_iterator() {}
200	reverse_map_view_iterator(
201	BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
202	: base_(iter) {}
203	reverse_map_view_iterator(reverse_map_view_iterator const & iter)
204	: base_(iter.base()) {}
205
206	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
207	{
208	return ::boost::bimaps::relation::support::pair_by<Tag>(
209	const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type>(
210	&(*this->base())
211	)
212	);
213	}
214	private:
215	friend class iterator_core_access;
216	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
217	};
218
219	template< class Tag, class BimapCore >
220	struct const_reverse_map_view_iterator_adaptor {
221	typedef iterator_adaptor<
222	const_reverse_map_view_iterator<Tag,BimapCore>,
223	BOOST_DEDUCED_TYPENAME
224	reverse_core_iterator_type_by<Tag,BimapCore>::type,
225	const BOOST_DEDUCED_TYPENAME
226	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
227	> type;
228	};
229	template< class Tag, class BimapCore >
230	struct const_reverse_map_view_iterator :
231	public const_reverse_map_view_iterator_adaptor<Tag,BimapCore>::type
232	{
233	typedef BOOST_DEDUCED_TYPENAME
234	const_reverse_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
235
236	public:
237
238	const_reverse_map_view_iterator() {}
239	const_reverse_map_view_iterator(
240	BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
241	: base_(iter) {}
242	const_reverse_map_view_iterator(const_reverse_map_view_iterator const & iter)
243	: base_(iter.base()) {}
244	const_reverse_map_view_iterator(reverse_map_view_iterator<Tag,BimapCore> i)
245	: base_(i.base()) {}
246
247	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
248	{
249	return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
250	}
251	private:
252	friend class iterator_core_access;
253	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
254	};
255
256
257	// local_map_view_iterator
258
259	template< class Tag, class BimapCore >
260	struct local_map_view_iterator_adaptor {
261	typedef iterator_adaptor<
262	local_map_view_iterator<Tag,BimapCore>,
263	BOOST_DEDUCED_TYPENAME
264	local_core_iterator_type_by<Tag,BimapCore>::type,
265	BOOST_DEDUCED_TYPENAME
266	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
267	> type;
268	};
269	template< class Tag, class BimapCore >
270	struct local_map_view_iterator :
271	public local_map_view_iterator_adaptor<Tag,BimapCore>::type
272	{
273	typedef BOOST_DEDUCED_TYPENAME
274	local_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
275	public:
276
277	local_map_view_iterator() {}
278	local_map_view_iterator(
279	BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
280	: base_(iter) {}
281	local_map_view_iterator(local_map_view_iterator const & iter)
282	: base_(iter.base()) {}
283
284	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
285	{
286	return ::boost::bimaps::relation::support::pair_by<Tag>(
287	const_cast<BOOST_DEDUCED_TYPENAME base_::base_type::value_type>(
288	&(*this->base())
289	)
290	);
291	}
292	private:
293	friend class iterator_core_access;
294	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
295	};
296
297	template< class Tag, class BimapCore >
298	struct const_local_map_view_iterator_adaptor {
299	typedef iterator_adaptor<
300	const_local_map_view_iterator<Tag,BimapCore>,
301	BOOST_DEDUCED_TYPENAME
302	local_core_iterator_type_by<Tag,BimapCore>::type,
303	const BOOST_DEDUCED_TYPENAME
304	::boost::bimaps::support::value_type_by<Tag,BimapCore>::type
305	> type;
306	};
307	template< class Tag, class BimapCore >
308	struct const_local_map_view_iterator :
309	public const_local_map_view_iterator_adaptor<Tag,BimapCore>::type
310	{
311	typedef BOOST_DEDUCED_TYPENAME
312	const_local_map_view_iterator_adaptor<Tag,BimapCore>::type base_;
313	public:
314
315	const_local_map_view_iterator() {}
316	const_local_map_view_iterator(
317	BOOST_DEDUCED_TYPENAME base_::base_type const& iter)
318	: base_(iter) {}
319	const_local_map_view_iterator(const_local_map_view_iterator const & iter)
320	: base_(iter.base()) {}
321	const_local_map_view_iterator(local_map_view_iterator<Tag,BimapCore> i)
322	: base_(i.base()) {}
323
324	BOOST_DEDUCED_TYPENAME base_::reference dereference() const
325	{
326	return ::boost::bimaps::relation::support::pair_by<Tag>(*this->base());
327	}
328	private:
329	friend class iterator_core_access;
330	BOOST_BIMAP_MAP_VIEW_ITERATOR_SERIALIZATION_SUPPORT
331	};
332
333	#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES
334
335	} // namespace detail
336	} // namespace bimaps
337	} // namespace boost
338
339	#endif // BOOST_BIMAP_DETAIL_MAP_VIEW_ITERATOR_HPP
340
341