981 lines
35 KiB
Plaintext
981 lines
35 KiB
Plaintext
// (C) Copyright David Abrahams 2002.
|
|
// (C) Copyright Jeremy Siek 2002.
|
|
// (C) Copyright Thomas Witt 2002.
|
|
// 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)
|
|
#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
|
|
#define BOOST_ITERATOR_FACADE_23022003THW_HPP
|
|
|
|
#include <boost/config.hpp>
|
|
#include <boost/iterator.hpp>
|
|
#include <boost/iterator/interoperable.hpp>
|
|
#include <boost/iterator/iterator_traits.hpp>
|
|
#include <boost/iterator/iterator_categories.hpp>
|
|
|
|
#include <boost/iterator/detail/facade_iterator_category.hpp>
|
|
#include <boost/iterator/detail/enable_if.hpp>
|
|
|
|
#include <boost/static_assert.hpp>
|
|
#include <boost/utility/addressof.hpp>
|
|
|
|
#include <boost/type_traits/is_same.hpp>
|
|
#include <boost/type_traits/add_const.hpp>
|
|
#include <boost/type_traits/add_pointer.hpp>
|
|
#include <boost/type_traits/add_lvalue_reference.hpp>
|
|
#include <boost/type_traits/remove_const.hpp>
|
|
#include <boost/type_traits/remove_reference.hpp>
|
|
#include <boost/type_traits/is_convertible.hpp>
|
|
#include <boost/type_traits/is_pod.hpp>
|
|
|
|
#include <boost/mpl/eval_if.hpp>
|
|
#include <boost/mpl/if.hpp>
|
|
#include <boost/mpl/or.hpp>
|
|
#include <boost/mpl/and.hpp>
|
|
#include <boost/mpl/not.hpp>
|
|
#include <boost/mpl/always.hpp>
|
|
#include <boost/mpl/apply.hpp>
|
|
#include <boost/mpl/identity.hpp>
|
|
|
|
#include <boost/iterator/detail/config_def.hpp> // this goes last
|
|
|
|
namespace boost {
|
|
namespace iterators {
|
|
|
|
// This forward declaration is required for the friend declaration
|
|
// in iterator_core_access
|
|
template <class I, class V, class TC, class R, class D> class iterator_facade;
|
|
|
|
namespace detail
|
|
{
|
|
// A binary metafunction class that always returns bool. VC6
|
|
// ICEs on mpl::always<bool>, probably because of the default
|
|
// parameters.
|
|
struct always_bool2
|
|
{
|
|
template <class T, class U>
|
|
struct apply
|
|
{
|
|
typedef bool type;
|
|
};
|
|
};
|
|
|
|
// The type trait checks if the category or traversal is at least as advanced as the specified required traversal
|
|
template< typename CategoryOrTraversal, typename Required >
|
|
struct is_traversal_at_least :
|
|
public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
|
|
{};
|
|
|
|
//
|
|
// enable if for use in operator implementation.
|
|
//
|
|
template <
|
|
class Facade1
|
|
, class Facade2
|
|
, class Return
|
|
>
|
|
struct enable_if_interoperable :
|
|
public boost::iterators::enable_if<
|
|
is_interoperable< Facade1, Facade2 >
|
|
, Return
|
|
>
|
|
{};
|
|
|
|
//
|
|
// enable if for use in implementation of operators specific for random access traversal.
|
|
//
|
|
template <
|
|
class Facade1
|
|
, class Facade2
|
|
, class Return
|
|
>
|
|
struct enable_if_interoperable_and_random_access_traversal :
|
|
public boost::iterators::enable_if<
|
|
mpl::and_<
|
|
is_interoperable< Facade1, Facade2 >
|
|
, is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
|
|
, is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
|
|
>
|
|
, Return
|
|
>
|
|
{};
|
|
|
|
//
|
|
// Generates associated types for an iterator_facade with the
|
|
// given parameters.
|
|
//
|
|
template <
|
|
class ValueParam
|
|
, class CategoryOrTraversal
|
|
, class Reference
|
|
, class Difference
|
|
>
|
|
struct iterator_facade_types
|
|
{
|
|
typedef typename facade_iterator_category<
|
|
CategoryOrTraversal, ValueParam, Reference
|
|
>::type iterator_category;
|
|
|
|
typedef typename remove_const<ValueParam>::type value_type;
|
|
|
|
// Not the real associated pointer type
|
|
typedef typename mpl::eval_if<
|
|
boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
|
|
, add_pointer<const value_type>
|
|
, add_pointer<value_type>
|
|
>::type pointer;
|
|
|
|
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
|
&& (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \
|
|
|| BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \
|
|
|| BOOST_WORKAROUND(BOOST_RWSTD_VER, BOOST_TESTED_AT(0x20101)) \
|
|
|| BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, <= 310)
|
|
|
|
// To interoperate with some broken library/compiler
|
|
// combinations, user-defined iterators must be derived from
|
|
// std::iterator. It is possible to implement a standard
|
|
// library for broken compilers without this limitation.
|
|
# define BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE 1
|
|
|
|
typedef
|
|
iterator<iterator_category, value_type, Difference, pointer, Reference>
|
|
base;
|
|
# endif
|
|
};
|
|
|
|
// iterators whose dereference operators reference the same value
|
|
// for all iterators into the same sequence (like many input
|
|
// iterators) need help with their postfix ++: the referenced
|
|
// value must be read and stored away before the increment occurs
|
|
// so that *a++ yields the originally referenced element and not
|
|
// the next one.
|
|
template <class Iterator>
|
|
class postfix_increment_proxy
|
|
{
|
|
typedef typename iterator_value<Iterator>::type value_type;
|
|
public:
|
|
explicit postfix_increment_proxy(Iterator const& x)
|
|
: stored_value(*x)
|
|
{}
|
|
|
|
// Returning a mutable reference allows nonsense like
|
|
// (*r++).mutate(), but it imposes fewer assumptions about the
|
|
// behavior of the value_type. In particular, recall that
|
|
// (*r).mutate() is legal if operator* returns by value.
|
|
value_type&
|
|
operator*() const
|
|
{
|
|
return this->stored_value;
|
|
}
|
|
private:
|
|
mutable value_type stored_value;
|
|
};
|
|
|
|
//
|
|
// In general, we can't determine that such an iterator isn't
|
|
// writable -- we also need to store a copy of the old iterator so
|
|
// that it can be written into.
|
|
template <class Iterator>
|
|
class writable_postfix_increment_proxy
|
|
{
|
|
typedef typename iterator_value<Iterator>::type value_type;
|
|
public:
|
|
explicit writable_postfix_increment_proxy(Iterator const& x)
|
|
: stored_value(*x)
|
|
, stored_iterator(x)
|
|
{}
|
|
|
|
// Dereferencing must return a proxy so that both *r++ = o and
|
|
// value_type(*r++) can work. In this case, *r is the same as
|
|
// *r++, and the conversion operator below is used to ensure
|
|
// readability.
|
|
writable_postfix_increment_proxy const&
|
|
operator*() const
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
// Provides readability of *r++
|
|
operator value_type&() const
|
|
{
|
|
return stored_value;
|
|
}
|
|
|
|
// Provides writability of *r++
|
|
template <class T>
|
|
T const& operator=(T const& x) const
|
|
{
|
|
*this->stored_iterator = x;
|
|
return x;
|
|
}
|
|
|
|
// This overload just in case only non-const objects are writable
|
|
template <class T>
|
|
T& operator=(T& x) const
|
|
{
|
|
*this->stored_iterator = x;
|
|
return x;
|
|
}
|
|
|
|
// Provides X(r++)
|
|
operator Iterator const&() const
|
|
{
|
|
return stored_iterator;
|
|
}
|
|
|
|
private:
|
|
mutable value_type stored_value;
|
|
Iterator stored_iterator;
|
|
};
|
|
|
|
# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
|
|
template <class Reference, class Value>
|
|
struct is_non_proxy_reference_impl
|
|
{
|
|
static Reference r;
|
|
|
|
template <class R>
|
|
static typename mpl::if_<
|
|
is_convertible<
|
|
R const volatile*
|
|
, Value const volatile*
|
|
>
|
|
, char[1]
|
|
, char[2]
|
|
>::type& helper(R const&);
|
|
|
|
BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
|
|
};
|
|
|
|
template <class Reference, class Value>
|
|
struct is_non_proxy_reference
|
|
: mpl::bool_<
|
|
is_non_proxy_reference_impl<Reference, Value>::value
|
|
>
|
|
{};
|
|
# else
|
|
template <class Reference, class Value>
|
|
struct is_non_proxy_reference
|
|
: is_convertible<
|
|
typename remove_reference<Reference>::type
|
|
const volatile*
|
|
, Value const volatile*
|
|
>
|
|
{};
|
|
# endif
|
|
|
|
// A metafunction to choose the result type of postfix ++
|
|
//
|
|
// Because the C++98 input iterator requirements say that *r++ has
|
|
// type T (value_type), implementations of some standard
|
|
// algorithms like lexicographical_compare may use constructions
|
|
// like:
|
|
//
|
|
// *r++ < *s++
|
|
//
|
|
// If *r++ returns a proxy (as required if r is writable but not
|
|
// multipass), this sort of expression will fail unless the proxy
|
|
// supports the operator<. Since there are any number of such
|
|
// operations, we're not going to try to support them. Therefore,
|
|
// even if r++ returns a proxy, *r++ will only return a proxy if
|
|
// *r also returns a proxy.
|
|
template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
|
|
struct postfix_increment_result
|
|
: mpl::eval_if<
|
|
mpl::and_<
|
|
// A proxy is only needed for readable iterators
|
|
is_convertible<
|
|
Reference
|
|
// Use add_lvalue_reference to form `reference to Value` due to
|
|
// some (strict) C++03 compilers (e.g. `gcc -std=c++03`) reject
|
|
// 'reference-to-reference' in the template which described in CWG
|
|
// DR106.
|
|
// http://www.open-std.org/Jtc1/sc22/wg21/docs/cwg_defects.html#106
|
|
, typename add_lvalue_reference<Value const>::type
|
|
>
|
|
|
|
// No multipass iterator can have values that disappear
|
|
// before positions can be re-visited
|
|
, mpl::not_<
|
|
is_convertible<
|
|
typename iterator_category_to_traversal<CategoryOrTraversal>::type
|
|
, forward_traversal_tag
|
|
>
|
|
>
|
|
>
|
|
, mpl::if_<
|
|
is_non_proxy_reference<Reference,Value>
|
|
, postfix_increment_proxy<Iterator>
|
|
, writable_postfix_increment_proxy<Iterator>
|
|
>
|
|
, mpl::identity<Iterator>
|
|
>
|
|
{};
|
|
|
|
// operator->() needs special support for input iterators to strictly meet the
|
|
// standard's requirements. If *i is not a reference type, we must still
|
|
// produce an lvalue to which a pointer can be formed. We do that by
|
|
// returning a proxy object containing an instance of the reference object.
|
|
template <class Reference, class Pointer>
|
|
struct operator_arrow_dispatch // proxy references
|
|
{
|
|
struct proxy
|
|
{
|
|
explicit proxy(Reference const & x) : m_ref(x) {}
|
|
Reference* operator->() { return boost::addressof(m_ref); }
|
|
// This function is needed for MWCW and BCC, which won't call
|
|
// operator-> again automatically per 13.3.1.2 para 8
|
|
operator Reference*() { return boost::addressof(m_ref); }
|
|
Reference m_ref;
|
|
};
|
|
typedef proxy result_type;
|
|
static result_type apply(Reference const & x)
|
|
{
|
|
return result_type(x);
|
|
}
|
|
};
|
|
|
|
template <class T, class Pointer>
|
|
struct operator_arrow_dispatch<T&, Pointer> // "real" references
|
|
{
|
|
typedef Pointer result_type;
|
|
static result_type apply(T& x)
|
|
{
|
|
return boost::addressof(x);
|
|
}
|
|
};
|
|
|
|
// A proxy return type for operator[], needed to deal with
|
|
// iterators that may invalidate referents upon destruction.
|
|
// Consider the temporary iterator in *(a + n)
|
|
template <class Iterator>
|
|
class operator_brackets_proxy
|
|
{
|
|
// Iterator is actually an iterator_facade, so we do not have to
|
|
// go through iterator_traits to access the traits.
|
|
typedef typename Iterator::reference reference;
|
|
typedef typename Iterator::value_type value_type;
|
|
|
|
public:
|
|
operator_brackets_proxy(Iterator const& iter)
|
|
: m_iter(iter)
|
|
{}
|
|
|
|
operator reference() const
|
|
{
|
|
return *m_iter;
|
|
}
|
|
|
|
operator_brackets_proxy& operator=(value_type const& val)
|
|
{
|
|
*m_iter = val;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
Iterator m_iter;
|
|
};
|
|
|
|
// A metafunction that determines whether operator[] must return a
|
|
// proxy, or whether it can simply return a copy of the value_type.
|
|
template <class ValueType, class Reference>
|
|
struct use_operator_brackets_proxy
|
|
: mpl::not_<
|
|
mpl::and_<
|
|
// Really we want an is_copy_constructible trait here,
|
|
// but is_POD will have to suffice in the meantime.
|
|
boost::is_POD<ValueType>
|
|
, iterator_writability_disabled<ValueType,Reference>
|
|
>
|
|
>
|
|
{};
|
|
|
|
template <class Iterator, class Value, class Reference>
|
|
struct operator_brackets_result
|
|
{
|
|
typedef typename mpl::if_<
|
|
use_operator_brackets_proxy<Value,Reference>
|
|
, operator_brackets_proxy<Iterator>
|
|
, Value
|
|
>::type type;
|
|
};
|
|
|
|
template <class Iterator>
|
|
operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
|
|
{
|
|
return operator_brackets_proxy<Iterator>(iter);
|
|
}
|
|
|
|
template <class Iterator>
|
|
typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
|
|
{
|
|
return *iter;
|
|
}
|
|
|
|
struct choose_difference_type
|
|
{
|
|
template <class I1, class I2>
|
|
struct apply
|
|
:
|
|
# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
|
|
iterator_difference<I1>
|
|
# else
|
|
mpl::eval_if<
|
|
is_convertible<I2,I1>
|
|
, iterator_difference<I1>
|
|
, iterator_difference<I2>
|
|
>
|
|
# endif
|
|
{};
|
|
|
|
};
|
|
|
|
template <
|
|
class Derived
|
|
, class Value
|
|
, class CategoryOrTraversal
|
|
, class Reference
|
|
, class Difference
|
|
, bool IsBidirectionalTraversal
|
|
, bool IsRandomAccessTraversal
|
|
>
|
|
class iterator_facade_base;
|
|
|
|
} // namespace detail
|
|
|
|
|
|
// Macros which describe the declarations of binary operators
|
|
# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
|
|
template < \
|
|
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
|
|
, class Derived2, class V2, class TC2, class Reference2, class Difference2 \
|
|
> \
|
|
prefix typename mpl::apply2<result_type,Derived1,Derived2>::type \
|
|
operator op( \
|
|
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
|
|
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
|
|
# else
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
|
|
template < \
|
|
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
|
|
, class Derived2, class V2, class TC2, class Reference2, class Difference2 \
|
|
> \
|
|
prefix typename enabler< \
|
|
Derived1, Derived2 \
|
|
, typename mpl::apply2<result_type,Derived1,Derived2>::type \
|
|
>::type \
|
|
operator op( \
|
|
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
|
|
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
|
|
# endif
|
|
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
|
|
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
|
|
|
|
# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \
|
|
template <class Derived, class V, class TC, class R, class D> \
|
|
prefix typename boost::iterators::enable_if< \
|
|
boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, \
|
|
Derived \
|
|
>::type operator+ args
|
|
|
|
//
|
|
// Helper class for granting access to the iterator core interface.
|
|
//
|
|
// The simple core interface is used by iterator_facade. The core
|
|
// interface of a user/library defined iterator type should not be made public
|
|
// so that it does not clutter the public interface. Instead iterator_core_access
|
|
// should be made friend so that iterator_facade can access the core
|
|
// interface through iterator_core_access.
|
|
//
|
|
class iterator_core_access
|
|
{
|
|
# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
|
|
// Tasteless as this may seem, making all members public allows member templates
|
|
// to work in the absence of member template friends.
|
|
public:
|
|
# else
|
|
|
|
template <class I, class V, class TC, class R, class D> friend class iterator_facade;
|
|
template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
|
|
friend class detail::iterator_facade_base;
|
|
|
|
# define BOOST_ITERATOR_FACADE_RELATION(op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(==)
|
|
BOOST_ITERATOR_FACADE_RELATION(!=)
|
|
|
|
# undef BOOST_ITERATOR_FACADE_RELATION
|
|
|
|
# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
|
|
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)
|
|
|
|
# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
|
|
|
|
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
|
|
friend, -, boost::iterators::detail::choose_difference_type)
|
|
;
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS_HEAD(
|
|
friend inline
|
|
, (iterator_facade<Derived, V, TC, R, D> const&
|
|
, typename Derived::difference_type)
|
|
)
|
|
;
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS_HEAD(
|
|
friend inline
|
|
, (typename Derived::difference_type
|
|
, iterator_facade<Derived, V, TC, R, D> const&)
|
|
)
|
|
;
|
|
|
|
# endif
|
|
|
|
template <class Facade>
|
|
static typename Facade::reference dereference(Facade const& f)
|
|
{
|
|
return f.dereference();
|
|
}
|
|
|
|
template <class Facade>
|
|
static void increment(Facade& f)
|
|
{
|
|
f.increment();
|
|
}
|
|
|
|
template <class Facade>
|
|
static void decrement(Facade& f)
|
|
{
|
|
f.decrement();
|
|
}
|
|
|
|
template <class Facade1, class Facade2>
|
|
static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
|
|
{
|
|
return f1.equal(f2);
|
|
}
|
|
|
|
template <class Facade1, class Facade2>
|
|
static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
|
|
{
|
|
return f2.equal(f1);
|
|
}
|
|
|
|
template <class Facade>
|
|
static void advance(Facade& f, typename Facade::difference_type n)
|
|
{
|
|
f.advance(n);
|
|
}
|
|
|
|
template <class Facade1, class Facade2>
|
|
static typename Facade1::difference_type distance_from(
|
|
Facade1 const& f1, Facade2 const& f2, mpl::true_)
|
|
{
|
|
return -f1.distance_to(f2);
|
|
}
|
|
|
|
template <class Facade1, class Facade2>
|
|
static typename Facade2::difference_type distance_from(
|
|
Facade1 const& f1, Facade2 const& f2, mpl::false_)
|
|
{
|
|
return f2.distance_to(f1);
|
|
}
|
|
|
|
//
|
|
// Curiously Recurring Template interface.
|
|
//
|
|
template <class I, class V, class TC, class R, class D>
|
|
static I& derived(iterator_facade<I,V,TC,R,D>& facade)
|
|
{
|
|
return *static_cast<I*>(&facade);
|
|
}
|
|
|
|
template <class I, class V, class TC, class R, class D>
|
|
static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
|
|
{
|
|
return *static_cast<I const*>(&facade);
|
|
}
|
|
|
|
// objects of this class are useless
|
|
BOOST_DELETED_FUNCTION(iterator_core_access())
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
// Implementation for forward traversal iterators
|
|
template <
|
|
class Derived
|
|
, class Value
|
|
, class CategoryOrTraversal
|
|
, class Reference
|
|
, class Difference
|
|
>
|
|
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
|
|
# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
|
|
: public boost::iterators::detail::iterator_facade_types<
|
|
Value, CategoryOrTraversal, Reference, Difference
|
|
>::base
|
|
# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
|
|
# endif
|
|
{
|
|
private:
|
|
typedef boost::iterators::detail::iterator_facade_types<
|
|
Value, CategoryOrTraversal, Reference, Difference
|
|
> associated_types;
|
|
|
|
typedef boost::iterators::detail::operator_arrow_dispatch<
|
|
Reference
|
|
, typename associated_types::pointer
|
|
> operator_arrow_dispatch_;
|
|
|
|
public:
|
|
typedef typename associated_types::value_type value_type;
|
|
typedef Reference reference;
|
|
typedef Difference difference_type;
|
|
|
|
typedef typename operator_arrow_dispatch_::result_type pointer;
|
|
|
|
typedef typename associated_types::iterator_category iterator_category;
|
|
|
|
public:
|
|
reference operator*() const
|
|
{
|
|
return iterator_core_access::dereference(this->derived());
|
|
}
|
|
|
|
pointer operator->() const
|
|
{
|
|
return operator_arrow_dispatch_::apply(*this->derived());
|
|
}
|
|
|
|
Derived& operator++()
|
|
{
|
|
iterator_core_access::increment(this->derived());
|
|
return this->derived();
|
|
}
|
|
|
|
protected:
|
|
//
|
|
// Curiously Recurring Template interface.
|
|
//
|
|
Derived& derived()
|
|
{
|
|
return *static_cast<Derived*>(this);
|
|
}
|
|
|
|
Derived const& derived() const
|
|
{
|
|
return *static_cast<Derived const*>(this);
|
|
}
|
|
};
|
|
|
|
// Implementation for bidirectional traversal iterators
|
|
template <
|
|
class Derived
|
|
, class Value
|
|
, class CategoryOrTraversal
|
|
, class Reference
|
|
, class Difference
|
|
>
|
|
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
|
|
public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
|
|
{
|
|
public:
|
|
Derived& operator--()
|
|
{
|
|
iterator_core_access::decrement(this->derived());
|
|
return this->derived();
|
|
}
|
|
|
|
Derived operator--(int)
|
|
{
|
|
Derived tmp(this->derived());
|
|
--*this;
|
|
return tmp;
|
|
}
|
|
};
|
|
|
|
// Implementation for random access traversal iterators
|
|
template <
|
|
class Derived
|
|
, class Value
|
|
, class CategoryOrTraversal
|
|
, class Reference
|
|
, class Difference
|
|
>
|
|
class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
|
|
public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
|
|
{
|
|
private:
|
|
typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
|
|
|
|
public:
|
|
typedef typename base_type::reference reference;
|
|
typedef typename base_type::difference_type difference_type;
|
|
|
|
public:
|
|
typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
|
|
operator[](difference_type n) const
|
|
{
|
|
typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
|
|
|
|
return boost::iterators::detail::make_operator_brackets_result<Derived>(
|
|
this->derived() + n
|
|
, use_proxy()
|
|
);
|
|
}
|
|
|
|
Derived& operator+=(difference_type n)
|
|
{
|
|
iterator_core_access::advance(this->derived(), n);
|
|
return this->derived();
|
|
}
|
|
|
|
Derived& operator-=(difference_type n)
|
|
{
|
|
iterator_core_access::advance(this->derived(), -n);
|
|
return this->derived();
|
|
}
|
|
|
|
Derived operator-(difference_type x) const
|
|
{
|
|
Derived result(this->derived());
|
|
return result -= x;
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
//
|
|
// iterator_facade - use as a public base class for defining new
|
|
// standard-conforming iterators.
|
|
//
|
|
template <
|
|
class Derived // The derived iterator type being constructed
|
|
, class Value
|
|
, class CategoryOrTraversal
|
|
, class Reference = Value&
|
|
, class Difference = std::ptrdiff_t
|
|
>
|
|
class iterator_facade :
|
|
public detail::iterator_facade_base<
|
|
Derived,
|
|
Value,
|
|
CategoryOrTraversal,
|
|
Reference,
|
|
Difference,
|
|
detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
|
|
detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
|
|
>
|
|
{
|
|
protected:
|
|
// For use by derived classes
|
|
typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
|
|
};
|
|
|
|
template <class I, class V, class TC, class R, class D>
|
|
inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
|
|
operator++(
|
|
iterator_facade<I,V,TC,R,D>& i
|
|
, int
|
|
)
|
|
{
|
|
typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
|
|
tmp(*static_cast<I*>(&i));
|
|
|
|
++i;
|
|
|
|
return tmp;
|
|
}
|
|
|
|
|
|
//
|
|
// Comparison operator implementation. The library supplied operators
|
|
// enables the user to provide fully interoperable constant/mutable
|
|
// iterator types. I.e. the library provides all operators
|
|
// for all mutable/constant iterator combinations.
|
|
//
|
|
// Note though that this kind of interoperability for constant/mutable
|
|
// iterators is not required by the standard for container iterators.
|
|
// All the standard asks for is a conversion mutable -> constant.
|
|
// Most standard library implementations nowadays provide fully interoperable
|
|
// iterator implementations, but there are still heavily used implementations
|
|
// that do not provide them. (Actually it's even worse, they do not provide
|
|
// them for only a few iterators.)
|
|
//
|
|
// ?? Maybe a BOOST_ITERATOR_NO_FULL_INTEROPERABILITY macro should
|
|
// enable the user to turn off mixed type operators
|
|
//
|
|
// The library takes care to provide only the right operator overloads.
|
|
// I.e.
|
|
//
|
|
// bool operator==(Iterator, Iterator);
|
|
// bool operator==(ConstIterator, Iterator);
|
|
// bool operator==(Iterator, ConstIterator);
|
|
// bool operator==(ConstIterator, ConstIterator);
|
|
//
|
|
// ...
|
|
//
|
|
// In order to do so it uses c++ idioms that are not yet widely supported
|
|
// by current compiler releases. The library is designed to degrade gracefully
|
|
// in the face of compiler deficiencies. In general compiler
|
|
// deficiencies result in less strict error checking and more obscure
|
|
// error messages, functionality is not affected.
|
|
//
|
|
// For full operation compiler support for "Substitution Failure Is Not An Error"
|
|
// (aka. enable_if) and boost::is_convertible is required.
|
|
//
|
|
// The following problems occur if support is lacking.
|
|
//
|
|
// Pseudo code
|
|
//
|
|
// ---------------
|
|
// AdaptorA<Iterator1> a1;
|
|
// AdaptorA<Iterator2> a2;
|
|
//
|
|
// // This will result in a no such overload error in full operation
|
|
// // If enable_if or is_convertible is not supported
|
|
// // The instantiation will fail with an error hopefully indicating that
|
|
// // there is no operator== for Iterator1, Iterator2
|
|
// // The same will happen if no enable_if is used to remove
|
|
// // false overloads from the templated conversion constructor
|
|
// // of AdaptorA.
|
|
//
|
|
// a1 == a2;
|
|
// ----------------
|
|
//
|
|
// AdaptorA<Iterator> a;
|
|
// AdaptorB<Iterator> b;
|
|
//
|
|
// // This will result in a no such overload error in full operation
|
|
// // If enable_if is not supported the static assert used
|
|
// // in the operator implementation will fail.
|
|
// // This will accidently work if is_convertible is not supported.
|
|
//
|
|
// a == b;
|
|
// ----------------
|
|
//
|
|
|
|
# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
|
|
# define BOOST_ITERATOR_CONVERTIBLE(a,b) mpl::true_()
|
|
# else
|
|
# define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
|
|
# endif
|
|
|
|
# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, return_prefix, base_op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) \
|
|
{ \
|
|
/* For those compilers that do not support enable_if */ \
|
|
BOOST_STATIC_ASSERT(( \
|
|
is_interoperable< Derived1, Derived2 >::value \
|
|
)); \
|
|
return_prefix iterator_core_access::base_op( \
|
|
*static_cast<Derived1 const*>(&lhs) \
|
|
, *static_cast<Derived2 const*>(&rhs) \
|
|
, BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \
|
|
); \
|
|
}
|
|
|
|
# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP( \
|
|
op \
|
|
, boost::iterators::detail::always_bool2 \
|
|
, return_prefix \
|
|
, base_op \
|
|
)
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
|
|
BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
|
|
|
|
# undef BOOST_ITERATOR_FACADE_RELATION
|
|
|
|
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \
|
|
{ \
|
|
/* For those compilers that do not support enable_if */ \
|
|
BOOST_STATIC_ASSERT(( \
|
|
is_interoperable< Derived1, Derived2 >::value && \
|
|
boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
|
|
boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \
|
|
)); \
|
|
return_prefix iterator_core_access::base_op( \
|
|
*static_cast<Derived1 const*>(&lhs) \
|
|
, *static_cast<Derived2 const*>(&rhs) \
|
|
, BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \
|
|
); \
|
|
}
|
|
|
|
# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( \
|
|
op \
|
|
, boost::iterators::detail::always_bool2 \
|
|
, return_prefix \
|
|
, base_op \
|
|
)
|
|
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from)
|
|
BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from)
|
|
|
|
# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
|
|
|
|
// operator- requires an additional part in the static assertion
|
|
BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(
|
|
-
|
|
, boost::iterators::detail::choose_difference_type
|
|
, return
|
|
, distance_from
|
|
)
|
|
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS
|
|
|
|
# define BOOST_ITERATOR_FACADE_PLUS(args) \
|
|
BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \
|
|
{ \
|
|
Derived tmp(static_cast<Derived const&>(i)); \
|
|
return tmp += n; \
|
|
}
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS((
|
|
iterator_facade<Derived, V, TC, R, D> const& i
|
|
, typename Derived::difference_type n
|
|
))
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS((
|
|
typename Derived::difference_type n
|
|
, iterator_facade<Derived, V, TC, R, D> const& i
|
|
))
|
|
|
|
# undef BOOST_ITERATOR_FACADE_PLUS
|
|
# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
|
|
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL
|
|
|
|
} // namespace iterators
|
|
|
|
using iterators::iterator_core_access;
|
|
using iterators::iterator_facade;
|
|
|
|
} // namespace boost
|
|
|
|
#include <boost/iterator/detail/config_undef.hpp>
|
|
|
|
#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP
|