feedc0de/boost_iterator
1
0
Fork 0
forked from boostorg/iterator
Code Pull Requests Activity

merged from trunk

Browse Source 
[SVN r21801]
This commit is contained in:
Dave Abrahams
2004-01-18 16:21:14 +00:00
parent 5d71ddeec4
commit c90b123e7a
2 changed files with 90 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
include/boost/iterator/iterator_archetypes.hpp
View File

@@ -19,6 +19,8 @@
#include <boost/type_traits/remove_const.hpp> #include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/remove_cv.hpp>
#include <boost/concept_archetype.hpp>
#include <boost/mpl/aux_/msvc_eti_base.hpp> #include <boost/mpl/aux_/msvc_eti_base.hpp>
#include <boost/mpl/bitand.hpp> #include <boost/mpl/bitand.hpp>
#include <boost/mpl/int.hpp> #include <boost/mpl/int.hpp>
@@ -80,26 +82,26 @@ namespace detail
template <class T> template <class T>
struct assign_proxy struct assign_proxy
{ {
assign_proxy& operator=(T); assign_proxy& operator=(T) { return *this; }
}; };
template <class T> template <class T>
struct read_proxy struct read_proxy
{ {
operator T(); operator T() { return static_object<T>::get(); }
}; };
template <class T> template <class T>
struct read_write_proxy struct read_write_proxy
: assign_proxy<T> : read_proxy<T> // Use to inherit from assign_proxy, but that doesn't work. -JGS
, read_proxy<T>
{ {
read_write_proxy& operator=(T) { return *this; }
}; };
template <class T> template <class T>
struct arrow_proxy struct arrow_proxy
{ {
T const* operator->() const; T const* operator->() const { return 0; }
}; };
struct no_operator_brackets {}; struct no_operator_brackets {};
@@ -107,13 +109,13 @@ namespace detail
template <class ValueType> template <class ValueType>
struct readable_operator_brackets struct readable_operator_brackets
{ {
read_proxy<ValueType> operator[](std::ptrdiff_t n) const; read_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_proxy<ValueType>(); }
}; };
template <class ValueType> template <class ValueType>
struct writable_operator_brackets struct writable_operator_brackets
{ {
read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const; read_write_proxy<ValueType> operator[](std::ptrdiff_t n) const { return read_write_proxy<ValueType>(); }
}; };
template <class Value, class AccessCategory, class TraversalCategory> template <class Value, class AccessCategory, class TraversalCategory>
@@ -147,12 +149,26 @@ namespace detail
template <class Derived,class Value> struct archetype; template <class Derived,class Value> struct archetype;
}; };
// Constructor argument for those iterators that
// are not default constructible
struct ctor_arg {};
template <class Derived, class Value, class TraversalCategory> template <class Derived, class Value, class TraversalCategory>
struct traversal_archetype_ struct traversal_archetype_
: mpl::aux::msvc_eti_base< : mpl::aux::msvc_eti_base<
typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value> typename traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
>::type >::type
{}; {
typedef typename
traversal_archetype_impl<TraversalCategory>::template archetype<Derived,Value>
base;
traversal_archetype_() {}
traversal_archetype_(ctor_arg arg)
: base(arg)
{}
};
template <> template <>
struct traversal_archetype_impl<incrementable_traversal_tag> struct traversal_archetype_impl<incrementable_traversal_tag>
@@ -160,10 +176,13 @@ namespace detail
template<class Derived, class Value> template<class Derived, class Value>
struct archetype struct archetype
{ {
typedef void difference_type; explicit archetype(ctor_arg) {}
Derived& operator++(); struct bogus { }; // This use to be void, but that causes trouble for iterator_facade. Need more research. -JGS
Derived operator++(int) const; typedef bogus difference_type;
Derived& operator++() { return (Derived&)static_object<Derived>::get(); }
Derived operator++(int) const { return (Derived&)static_object<Derived>::get(); }
}; };
}; };
@@ -175,18 +194,21 @@ namespace detail
: public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >, : public equality_comparable< traversal_archetype_<Derived, Value, single_pass_traversal_tag> >,
public traversal_archetype_<Derived, Value, incrementable_traversal_tag> public traversal_archetype_<Derived, Value, incrementable_traversal_tag>
{ {
explicit archetype(ctor_arg arg)
: traversal_archetype_<Derived, Value, incrementable_traversal_tag>(arg)
{}
}; };
}; };
template <class Derived, class Value> template <class Derived, class Value>
bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&, bool operator==(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&); traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
// doesn't seem to pick up != from equality_comparable // doesn't seem to pick up != from equality_comparable
template <class Derived, class Value> template <class Derived, class Value>
bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&, bool operator!=(traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&,
traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&); traversal_archetype_<Derived, Value, single_pass_traversal_tag> const&) { return true; }
#endif #endif
template <> template <>
struct traversal_archetype_impl<forward_traversal_tag> struct traversal_archetype_impl<forward_traversal_tag>
@@ -195,6 +217,9 @@ namespace detail
struct archetype struct archetype
: public traversal_archetype_<Derived, Value, single_pass_traversal_tag> : public traversal_archetype_<Derived, Value, single_pass_traversal_tag>
{ {
archetype()
: traversal_archetype_<Derived, Value, single_pass_traversal_tag>(ctor_arg())
{}
typedef std::ptrdiff_t difference_type; typedef std::ptrdiff_t difference_type;
}; };
}; };
@@ -206,8 +231,8 @@ namespace detail
struct archetype struct archetype
: public traversal_archetype_<Derived, Value, forward_traversal_tag> : public traversal_archetype_<Derived, Value, forward_traversal_tag>
{ {
Derived& operator--(); Derived& operator--() { return static_object<Derived>::get(); }
Derived operator--(int) const; Derived operator--(int) const { return static_object<Derived>::get(); }
}; };
}; };
@@ -219,30 +244,34 @@ namespace detail
: public partially_ordered<traversal_archetype_<Derived, Value, random_access_traversal_tag> >, : public partially_ordered<traversal_archetype_<Derived, Value, random_access_traversal_tag> >,
public traversal_archetype_<Derived, Value, bidirectional_traversal_tag> public traversal_archetype_<Derived, Value, bidirectional_traversal_tag>
{ {
Derived& operator+=(std::ptrdiff_t); Derived& operator+=(std::ptrdiff_t) { return static_object<Derived>::get(); }
Derived& operator-=(std::ptrdiff_t); Derived& operator-=(std::ptrdiff_t) { return static_object<Derived>::get(); }
}; };
}; };
template <class Derived, class Value> template <class Derived, class Value>
Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, Derived& operator+(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
std::ptrdiff_t); std::ptrdiff_t) { return static_object<Derived>::get(); }
template <class Derived, class Value> template <class Derived, class Value>
Derived& operator+(std::ptrdiff_t, Derived& operator+(std::ptrdiff_t,
traversal_archetype_<Derived, Value, random_access_traversal_tag> const&); traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
{ return static_object<Derived>::get(); }
template <class Derived, class Value> template <class Derived, class Value>
Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, Derived& operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
std::ptrdiff_t); std::ptrdiff_t)
{ return static_object<Derived>::get(); }
template <class Derived, class Value> template <class Derived, class Value>
std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, std::ptrdiff_t operator-(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
traversal_archetype_<Derived, Value, random_access_traversal_tag> const&); traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
{ return 0; }
template <class Derived, class Value> template <class Derived, class Value>
bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&, bool operator<(traversal_archetype_<Derived, Value, random_access_traversal_tag> const&,
traversal_archetype_<Derived, Value, random_access_traversal_tag> const&); traversal_archetype_<Derived, Value, random_access_traversal_tag> const&)
{ return true; }
struct bogus_type; struct bogus_type;
@@ -286,9 +315,9 @@ struct iterator_access_archetype_impl<
typedef Value reference; typedef Value reference;
typedef Value* pointer; typedef Value* pointer;
value_type operator*() const; value_type operator*() const { return static_object<value_type>::get(); }
detail::arrow_proxy<Value> operator->() const; detail::arrow_proxy<Value> operator->() const { return detail::arrow_proxy<Value>(); }
}; };
}; };
@@ -307,7 +336,7 @@ struct iterator_access_archetype_impl<
typedef void reference; typedef void reference;
typedef void pointer; typedef void pointer;
detail::assign_proxy<Value> operator*() const; detail::assign_proxy<Value> operator*() const { return detail::assign_proxy<Value>(); }
}; };
}; };
@@ -324,7 +353,7 @@ struct iterator_access_archetype_impl<
{ {
typedef detail::read_write_proxy<Value> reference; typedef detail::read_write_proxy<Value> reference;
detail::read_write_proxy<Value> operator*() const; detail::read_write_proxy<Value> operator*() const { return detail::read_write_proxy<Value>(); }
}; };
}; };
@@ -339,8 +368,8 @@ struct iterator_access_archetype_impl<iterator_archetypes::readable_lvalue_itera
{ {
typedef Value& reference; typedef Value& reference;
Value& operator*() const; Value& operator*() const { return static_object<Value>::get(); }
Value* operator->() const; Value* operator->() const { return 0; }
}; };
}; };
@@ -443,13 +472,27 @@ struct iterator_archetype
typedef typename base::iterator_category iterator_category; typedef typename base::iterator_category iterator_category;
# endif # endif
iterator_archetype(); iterator_archetype() { }
iterator_archetype(iterator_archetype const&); iterator_archetype(iterator_archetype const& x)
: detail::iterator_archetype_base<
Value
, AccessCategory
, TraversalCategory
>(x)
{}
iterator_archetype& operator=(iterator_archetype const&); iterator_archetype& operator=(iterator_archetype const&)
{ return *this; }
# if 0
// Optional conversion from mutable // Optional conversion from mutable
// iterator_archetype(iterator_archetype<typename detail::convertible_type<Value>::type, AccessCategory, TraversalCategory> const&); iterator_archetype(
iterator_archetype<
typename detail::convertible_type<Value>::type
, AccessCategory
, TraversalCategory> const&
);
# endif
}; };
} // namespace boost } // namespace boost

22
include/boost/iterator/iterator_facade.hpp
View File

@@ -31,6 +31,10 @@
#include <boost/mpl/always.hpp> #include <boost/mpl/always.hpp>
#include <boost/mpl/apply.hpp> #include <boost/mpl/apply.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
# include <boost/mpl/if.hpp>
#endif
#include <boost/iterator/detail/config_def.hpp> // this goes last #include <boost/iterator/detail/config_def.hpp> // this goes last
namespace boost namespace boost
@@ -223,16 +227,20 @@ namespace boost
{ {
template <class I1, class I2> template <class I1, class I2>
struct apply struct apply
: mpl::apply_if< :
is_convertible<I2,I1>
# if BOOST_WORKAROUND(BOOST_MSVC, == 1200) # if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
, typename I1::difference_type mpl::if_<
, typename I2::difference_type is_convertible<I2,I1>
, typename I1::difference_type
, typename I2::difference_type
>
# else # else
, iterator_difference<I1> mpl::apply_if<
, iterator_difference<I2> is_convertible<I2,I1>
, iterator_difference<I1>
, iterator_difference<I2>
>
# endif # endif
>
{}; {};
}; };