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

cleanups

Browse Source 
[SVN r1061]
This commit is contained in:
Dave Abrahams
2003-02-28 05:44:22 +00:00
parent 5f522787ca
commit 4ebfc5b0a2
5 changed files with 161 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/boost/iterator/filter_iterator.hpp
View File

@@ -24,8 +24,10 @@ namespace boost
{
typedef iterator_tag<
typename return_category<Iterator>::type
, minimum_category< forward_traversal_tag
,typename traversal_category<Iterator>::type >::type
, typename minimum_category<
forward_traversal_tag
, typename traversal_category<Iterator>::type
>::type
> iterator_category;
};

23
include/boost/iterator/indirect_iterator.hpp
View File

@@ -44,29 +44,31 @@ namespace boost
template <class T>
struct has_element_type
{
typedef typename mpl::if_<
: mpl::bool_<
mpl::if_<
is_class<T>
, aux::has_element_type<T>
, ::boost::detail::aux::has_element_type<T>
, mpl::false_
>::type type;
>::type::value
>
{
};
# else
template <class T>
struct has_element_type
: mpl::false_c {};
: mpl::false_ {};
template <class T>
struct has_element_type<boost::shared_ptr<T> >
: mpl::true_c {};
: mpl::true_ {};
template <class T>
struct has_element_type<boost::scoped_ptr<T> >
: mpl::true_c {};
: mpl::true_ {};
template <class T>
struct has_element_type<std::auto_ptr<T> >
: mpl::true_c {};
: mpl::true_ {};
# endif
// Metafunction returning the nested element_type typedef
@@ -86,7 +88,10 @@ namespace boost
template <class Iter>
struct indirect_defaults
: mpl::if_<
has_element_type<typename iterator_traits<Iter>::value_type>
mpl::and_<
is_class<typename iterator_traits<Iter>::value_type>
, has_element_type<typename iterator_traits<Iter>::value_type>
>
, smart_pointer_traits<typename iterator_traits<Iter>::value_type>
, iterator_traits<typename iterator_traits<Iter>::value_type>
>::type

35
include/boost/iterator/iterator_adaptor.hpp
View File

@@ -110,7 +110,8 @@ namespace boost
# else
::boost::is_convertible<From, To>
# endif
,detail::enable_type >::type type;
, detail::enable_type
>::type type;
# endif
};
@@ -121,18 +122,22 @@ namespace boost
// argument ordering is different from the std::iterator template, so that default
// arguments can be used effectivly.
//
template <class Iterator,
class ValueType = typename detail::iterator_traits<Iterator>::value_type,
class Reference = ValueType&,
class Pointer = ValueType*,
class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category,
class DifferenceType = typename detail::iterator_traits<Iterator>::difference_type >
template <
class Iterator
, class ValueType = typename detail::iterator_traits<Iterator>::value_type
, class Reference = ValueType&
, class Pointer = ValueType*
, class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category
, class DifferenceType = typename detail::iterator_traits<Iterator>::difference_type
>
struct iterator_traits_adaptor
: iterator<IteratorCategory,
ValueType,
DifferenceType,
Pointer,
Reference>
: iterator<
IteratorCategory
, ValueType
, DifferenceType
, Pointer
, Reference
>
{
};
@@ -157,13 +162,15 @@ namespace boost
{
}
Iterator base() const { return m_iterator; }
Iterator base() const
{ return m_iterator; }
protected:
// Core iterator interface for iterator_facade
//
typename Traits::reference dereference() const { return *m_iterator; }
typename Traits::reference dereference() const
{ return *m_iterator; }
template <
class OtherDerived, class OtherIterator, class OtherTraits

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

@@ -31,12 +31,16 @@ namespace boost
// 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 :
::boost::detail::enable_if< is_convertible< Facade1, Facade2 >
, Return >
template <
class Facade1
, class Facade2
, class Return
>
struct enable_if_interoperable
: ::boost::detail::enable_if<
is_convertible<Facade1, Facade2>
, Return
>
{
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
typedef Return type;
@@ -285,154 +289,72 @@ namespace boost
// a == b;
// ----------------
//
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator==(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
return iterator_core_access::equal(lhs.derived(),
rhs.derived());
# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, condition, return_prefix, base_op) \
template <class Derived1, class Traits1, class Derived2, class Traits2> \
inline typename detail::enable_if_interoperable< \
Derived1, Derived2, result_type \
>::type \
operator op( \
iterator_facade<Derived1, Traits1> const& lhs \
, iterator_facade<Derived2, Traits2> const& rhs) \
{ \
/* 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( \
rhs.derived(), lhs.derived()); \
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator!=(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
# define BOOST_ITERATOR_FACADE_RELATION(op, test, base_op) \
BOOST_ITERATOR_FACADE_INTEROP( \
op \
, bool \
, true \
, return test \
, base_op \
)
return !iterator_core_access::equal(lhs.derived(),
rhs.derived());
BOOST_ITERATOR_FACADE_RELATION(==, (bool), equal)
BOOST_ITERATOR_FACADE_RELATION(!=, !, equal)
BOOST_ITERATOR_FACADE_RELATION(<, 0>, distance_to)
BOOST_ITERATOR_FACADE_RELATION(>, 0<, distance_to)
BOOST_ITERATOR_FACADE_RELATION(<=, 0>=, distance_to)
BOOST_ITERATOR_FACADE_RELATION(>=, 0<=, distance_to)
# undef BOOST_ITERATOR_FACADE_RELATION
BOOST_ITERATOR_FACADE_INTEROP(
-
, typename Traits1::difference_type
, (is_same<
BOOST_ARG_DEP_TYPENAME Traits1::difference_type
, BOOST_ARG_DEP_TYPENAME Traits2::difference_type
>::value)
, return
, distance_to )
# undef BOOST_ITERATOR_FACADE_INTEROP
# define BOOST_ITERATOR_FACADE_PLUS(args) \
template <class Derived, class Traits> \
inline Derived operator+ args \
{ \
Derived tmp(i.derived()); \
return tmp += n; \
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator<(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
BOOST_ITERATOR_FACADE_PLUS((
iterator_facade<Derived, Traits> const& i
, typename Traits::difference_type n
))
return iterator_core_access::distance_to(lhs.derived(),
rhs.derived()) > 0;
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator>(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
return iterator_core_access::distance_to(lhs.derived(),
rhs.derived()) < 0;
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator<=(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
return iterator_core_access::distance_to(lhs.derived(),
rhs.derived()) >= 0;
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
bool>::type
operator>=(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
return iterator_core_access::distance_to(lhs.derived(),
rhs.derived()) <= 0;
}
template <class Derived,
class Traits>
inline
Derived operator+(iterator_facade<Derived, Traits> const& i,
typename Traits::difference_type n)
{
Derived tmp(i.derived());
return tmp += n;
}
template <class Derived,
class Traits>
inline
Derived operator+(typename Traits::difference_type n,
iterator_facade<Derived, Traits> const& i)
{
Derived tmp(i.derived());
return tmp += n;
}
template <class Derived1,
class Traits1,
class Derived2,
class Traits2>
inline
typename detail::enable_if_interoperable<Derived1,
Derived2,
typename Traits1::difference_type>::type
operator-(iterator_facade<Derived1, Traits1> const& lhs,
iterator_facade<Derived2, Traits2> const& rhs)
{
// For those compilers that do not support enable_if
BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
BOOST_STATIC_ASSERT((is_same<BOOST_ARG_DEP_TYPENAME Traits1::difference_type,
BOOST_ARG_DEP_TYPENAME Traits2::difference_type>::value));
return iterator_core_access::distance_to(rhs.derived(),
lhs.derived());
}
BOOST_ITERATOR_FACADE_PLUS((
typename Traits::difference_type n
, iterator_facade<Derived, Traits> const& i
))
# undef BOOST_ITERATOR_FACADE_PLUS
} // namespace boost