forked from boostorg/iterator
bb7ac6bd84
for handling vc6/7 deficiencies with iterator_traits. Fixed a bug in iterator_facade which was causing incomplete types to be passed through is_convertible. Reinstated libs/utility/iterator_traits_test.cpp [SVN r19840]
640 lines
21 KiB
C++
640 lines
21 KiB
C++
// (C) Copyright David Abrahams 2002.
|
|
// (C) Copyright Jeremy Siek 2002.
|
|
// (C) Copyright Thomas Witt 2002.
|
|
// Permission to copy, use, modify,
|
|
// sell and distribute this software is granted provided this
|
|
// copyright notice appears in all copies. This software is provided
|
|
// "as is" without express or implied warranty, and with no claim as
|
|
// to its suitability for any purpose.
|
|
#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
|
|
#define BOOST_ITERATOR_FACADE_23022003THW_HPP
|
|
|
|
#include <boost/static_assert.hpp>
|
|
|
|
#include <boost/iterator.hpp>
|
|
#include <boost/iterator/iterator_categories.hpp>
|
|
#include <boost/iterator/interoperable.hpp>
|
|
#include <boost/iterator/detail/enable_if.hpp>
|
|
|
|
#include <boost/type_traits/is_same.hpp>
|
|
#include <boost/type_traits/is_convertible.hpp>
|
|
|
|
#include <boost/iterator/iterator_traits.hpp>
|
|
|
|
#include <boost/mpl/apply_if.hpp>
|
|
#include <boost/mpl/or.hpp>
|
|
|
|
#include <boost/iterator/detail/config_def.hpp> // this goes last
|
|
|
|
namespace boost
|
|
{
|
|
// This forward declaration is required for the friend declaration
|
|
// in iterator_core_access
|
|
template <class I, class V, class AC, class TC, class R, class D> class iterator_facade;
|
|
|
|
// Used as a default template argument internally, merely to
|
|
// indicate "use the default", this can also be passed by users
|
|
// explicitly in order to specify that the default should be used.
|
|
struct use_default;
|
|
|
|
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
// the incompleteness of use_default causes massive problems for
|
|
// is_convertible (naturally). This workaround is fortunately not
|
|
// needed for vc6/vc7.
|
|
template<class To>
|
|
struct is_convertible<use_default,To>
|
|
: mpl::false_ {};
|
|
# endif
|
|
|
|
namespace detail
|
|
{
|
|
//
|
|
// enable if for use in operator implementation.
|
|
//
|
|
// enable_if_interoperable falls back to always enabled for compilers
|
|
// that don't support enable_if or is_convertible.
|
|
//
|
|
template <
|
|
class Facade1
|
|
, class Facade2
|
|
, class Return
|
|
>
|
|
struct enable_if_interoperable
|
|
#ifndef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
|
: ::boost::iterators::enable_if<
|
|
mpl::or_<
|
|
is_convertible<Facade1, Facade2>
|
|
, is_convertible<Facade2, Facade1>
|
|
>
|
|
, Return
|
|
>
|
|
#endif
|
|
{
|
|
#ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
|
|
typedef Return type;
|
|
#endif
|
|
};
|
|
|
|
|
|
//
|
|
// Add const qualification for iterators which are not writable
|
|
//
|
|
template<class Value, class AccessCategory>
|
|
struct const_qualified_ref :
|
|
mpl::if_< is_tag< writable_iterator_tag, AccessCategory >,
|
|
Value&,
|
|
Value const& >
|
|
{};
|
|
|
|
// The apparent duplication here works around a Borland problem
|
|
template<class Value, class AccessCategory>
|
|
struct const_qualified_ptr :
|
|
mpl::if_< is_tag< writable_iterator_tag, AccessCategory >,
|
|
Value*,
|
|
Value const* >
|
|
{};
|
|
|
|
//
|
|
// Generates the associated types for an iterator_facade with the
|
|
// given parameters. Additionally generates a 'base' type for
|
|
// compiler/library combinations which require user-defined
|
|
// iterators to inherit from std::iterator.
|
|
//
|
|
template <
|
|
class Value
|
|
, class AccessCategory
|
|
, class TraversalCategory
|
|
, class Reference
|
|
, class Difference
|
|
>
|
|
struct iterator_facade_types
|
|
{
|
|
typedef iterator_tag<AccessCategory, TraversalCategory> iterator_category;
|
|
|
|
typedef typename remove_cv<Value>::type value_type;
|
|
|
|
typedef Difference difference_type;
|
|
|
|
typedef typename const_qualified_ptr<Value, AccessCategory>::type pointer;
|
|
|
|
// The use_default support is needed for iterator_adaptor.
|
|
// For practical reasons iterator_adaptor needs to specify
|
|
// a fixed number of template arguments of iterator_facade.
|
|
// So use_default is its way to say: "What I really mean
|
|
// is your default parameter".
|
|
typedef typename mpl::if_<
|
|
is_same<Reference, use_default>
|
|
, typename const_qualified_ref<Value, AccessCategory>::type
|
|
, Reference
|
|
>::type reference;
|
|
|
|
# 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_type, pointer, reference>
|
|
base;
|
|
# endif
|
|
};
|
|
|
|
|
|
// 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 a (constant) lvalue to which a pointer can be formed. We do that by
|
|
// returning an instantiation of this special proxy class template.
|
|
|
|
template <class T>
|
|
struct operator_arrow_proxy
|
|
{
|
|
operator_arrow_proxy(T const* px) : m_value(*px) {}
|
|
const T* operator->() const { return &m_value; }
|
|
// This function is needed for MWCW and BCC, which won't call operator->
|
|
// again automatically per 13.3.1.2 para 8
|
|
operator const T*() const { return &m_value; }
|
|
T m_value;
|
|
};
|
|
|
|
// A metafunction that gets the result type for operator->. Also
|
|
// has a static function make() which builds the result from a
|
|
// Reference
|
|
template <class Value, class Category, class Reference, class Pointer>
|
|
struct operator_arrow_result
|
|
{
|
|
// CWPro8.3 won't accept "operator_arrow_result::type", and we
|
|
// need that type below, so metafunction forwarding would be a
|
|
// losing proposition here.
|
|
typedef typename mpl::if_<
|
|
is_tag<
|
|
readable_lvalue_iterator_tag
|
|
, typename access_category_tag<Category,Reference>::type
|
|
>
|
|
, Pointer
|
|
, operator_arrow_proxy<Value>
|
|
>::type type;
|
|
|
|
static type make(Reference x)
|
|
{
|
|
return type(&x);
|
|
}
|
|
};
|
|
|
|
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
|
// Deal with ETI
|
|
template<>
|
|
struct operator_arrow_result<int, int, int, int>
|
|
{
|
|
typedef int type;
|
|
};
|
|
# endif
|
|
|
|
//
|
|
// Facade is actually an iterator. We require Facade here
|
|
// so that we do not have to go through iterator_traits
|
|
// to access the traits
|
|
//
|
|
template <class Iterator>
|
|
class operator_brackets_proxy
|
|
{
|
|
typedef typename Iterator::reference reference;
|
|
typedef typename Iterator::value_type value_type;
|
|
|
|
public:
|
|
operator_brackets_proxy(Iterator const& iter)
|
|
: m_iter(iter)
|
|
{}
|
|
|
|
operator reference()
|
|
{
|
|
return *m_iter;
|
|
}
|
|
|
|
operator_brackets_proxy& operator=(value_type const& val)
|
|
{
|
|
*m_iter = val;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
Iterator m_iter;
|
|
};
|
|
|
|
template <class Iterator, class ValueType, class Category, class Reference>
|
|
struct operator_brackets_result
|
|
{
|
|
typedef typename access_category_tag<Category,Reference>::type access_category;
|
|
|
|
typedef is_tag<writable_iterator_tag, access_category> use_proxy;
|
|
|
|
typedef typename mpl::if_<
|
|
use_proxy
|
|
, operator_brackets_proxy<Iterator>
|
|
, ValueType
|
|
>::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;
|
|
}
|
|
|
|
} // namespace detail
|
|
|
|
|
|
// Macros which describe the declarations of binary operators
|
|
# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
|
|
template < \
|
|
class Derived1, class V1, class AC1, class TC1, class R1, class D1 \
|
|
, class Derived2, class V2, class AC2, class TC2, class R2, class D2 \
|
|
> \
|
|
prefix typename detail::enable_if_interoperable< \
|
|
Derived1, Derived2, result_type \
|
|
>::type \
|
|
operator op( \
|
|
iterator_facade<Derived1, V1, AC1, TC1, R1, D1> const& lhs \
|
|
, iterator_facade<Derived2, V2, AC2, TC2, R2, D2> const& rhs)
|
|
|
|
# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \
|
|
template <class Derived, class V, class AC, class TC, class R, class D> \
|
|
prefix Derived 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) \
|
|
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
|
// 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 AC, class TC, class R, class D> friend class iterator_facade;
|
|
|
|
# define BOOST_ITERATOR_FACADE_RELATION(op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, bool);
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(==)
|
|
BOOST_ITERATOR_FACADE_RELATION(!=)
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(<)
|
|
BOOST_ITERATOR_FACADE_RELATION(>)
|
|
BOOST_ITERATOR_FACADE_RELATION(<=)
|
|
BOOST_ITERATOR_FACADE_RELATION(>=)
|
|
# undef BOOST_ITERATOR_FACADE_RELATION
|
|
|
|
BOOST_ITERATOR_FACADE_INTEROP_HEAD(
|
|
friend, -, typename Derived1::difference_type)
|
|
;
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS_HEAD(
|
|
friend
|
|
, (iterator_facade<Derived, V, AC, TC, R, D> const&
|
|
, typename Derived::difference_type)
|
|
)
|
|
;
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS_HEAD(
|
|
friend
|
|
, (typename Derived::difference_type
|
|
, iterator_facade<Derived, V, AC, 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)
|
|
{
|
|
return f1.equal(f2);
|
|
}
|
|
|
|
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_to(
|
|
Facade1 const& f1, Facade2 const& f2)
|
|
{
|
|
return f1.distance_to(f2);
|
|
}
|
|
|
|
private:
|
|
// objects of this class are useless
|
|
iterator_core_access(); //undefined
|
|
};
|
|
|
|
//
|
|
// 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 AccessCategory
|
|
, class TraversalCategory
|
|
, class Reference = BOOST_DEDUCED_TYPENAME detail::const_qualified_ref<Value, AccessCategory>::type
|
|
, class Difference = std::ptrdiff_t
|
|
>
|
|
class iterator_facade
|
|
# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
|
|
: public detail::iterator_facade_types<
|
|
Value, AccessCategory, TraversalCategory, Reference, Difference
|
|
>::base
|
|
# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
|
|
# endif
|
|
{
|
|
private:
|
|
typedef typename
|
|
detail::iterator_facade_types<Value, AccessCategory, TraversalCategory, Reference, Difference>
|
|
types;
|
|
|
|
//
|
|
// Curiously Recursive Template interface.
|
|
//
|
|
typedef Derived derived_t;
|
|
|
|
Derived& derived()
|
|
{
|
|
return static_cast<Derived&>(*this);
|
|
}
|
|
|
|
Derived const& derived() const
|
|
{
|
|
return static_cast<Derived const&>(*this);
|
|
}
|
|
|
|
public:
|
|
|
|
typedef typename types::value_type value_type;
|
|
typedef typename types::reference reference;
|
|
typedef typename types::difference_type difference_type;
|
|
typedef typename types::pointer pointer;
|
|
typedef typename types::iterator_category iterator_category;
|
|
|
|
reference operator*() const
|
|
{
|
|
return iterator_core_access::dereference(this->derived());
|
|
}
|
|
|
|
typename detail::operator_arrow_result<
|
|
value_type
|
|
, iterator_category
|
|
, reference
|
|
, pointer
|
|
>::type
|
|
operator->() const
|
|
{
|
|
return detail::operator_arrow_result<
|
|
value_type
|
|
, iterator_category
|
|
, reference
|
|
, pointer
|
|
>::make(*this->derived());
|
|
}
|
|
|
|
typename detail::operator_brackets_result<Derived,value_type,iterator_category,reference>::type
|
|
operator[](difference_type n) const
|
|
{
|
|
typedef typename
|
|
detail::operator_brackets_result<Derived,value_type,iterator_category,reference>::use_proxy
|
|
use_proxy;
|
|
|
|
return detail::make_operator_brackets_result<Derived>(this->derived() + n, use_proxy());
|
|
}
|
|
|
|
Derived& operator++()
|
|
{
|
|
iterator_core_access::increment(this->derived());
|
|
return this->derived();
|
|
}
|
|
|
|
Derived operator++(int)
|
|
{
|
|
Derived tmp(this->derived());
|
|
++*this;
|
|
return tmp;
|
|
}
|
|
|
|
Derived& operator--()
|
|
{
|
|
iterator_core_access::decrement(this->derived());
|
|
return this->derived();
|
|
}
|
|
|
|
Derived operator--(int)
|
|
{
|
|
Derived tmp(this->derived());
|
|
--*this;
|
|
return tmp;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
|
|
// There appears to be a bug which trashes the data of classes
|
|
// derived from iterator_facade when they are assigned unless we
|
|
// define this assignment operator. This bug is only revealed
|
|
// (so far) in STLPort debug mode, but it's clearly a codegen
|
|
// problem so we apply the workaround for all MSVC6.
|
|
iterator_facade& operator=(iterator_facade const&)
|
|
{
|
|
return *this;
|
|
}
|
|
# endif
|
|
};
|
|
|
|
//
|
|
// 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;
|
|
// ----------------
|
|
//
|
|
|
|
# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, condition, 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 \
|
|
&& condition \
|
|
)); \
|
|
return_prefix iterator_core_access::base_op( \
|
|
static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); \
|
|
}
|
|
|
|
# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
|
|
BOOST_ITERATOR_FACADE_INTEROP( \
|
|
op \
|
|
, bool \
|
|
, true \
|
|
, return_prefix \
|
|
, base_op \
|
|
)
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
|
|
BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
|
|
|
|
BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_to)
|
|
BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_to)
|
|
BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_to)
|
|
BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_to)
|
|
# undef BOOST_ITERATOR_FACADE_RELATION
|
|
|
|
// operator- requires an additional part in the static assertion
|
|
BOOST_ITERATOR_FACADE_INTEROP(
|
|
-
|
|
, typename Derived1::difference_type
|
|
, (is_same<
|
|
BOOST_DEDUCED_TYPENAME Derived1::difference_type
|
|
, BOOST_DEDUCED_TYPENAME Derived2::difference_type
|
|
>::value)
|
|
, return
|
|
, distance_to )
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP
|
|
# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
|
|
|
|
# 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, AC, TC, R, D> const& i
|
|
, typename Derived::difference_type n
|
|
))
|
|
|
|
BOOST_ITERATOR_FACADE_PLUS((
|
|
typename Derived::difference_type n
|
|
, iterator_facade<Derived, V, AC, TC, R, D> const& i
|
|
))
|
|
# undef BOOST_ITERATOR_FACADE_PLUS
|
|
# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
|
|
|
|
} // namespace boost
|
|
|
|
#include <boost/iterator/detail/config_undef.hpp>
|
|
|
|
#endif // BOOST_ITERATOR_FACADE_23022003THW_HPP
|