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

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

@@ -23,10 +23,12 @@ namespace boost
: iterator_traits<Iterator>
{
typedef iterator_tag<
typename return_category<Iterator>::type
, minimum_category< forward_traversal_tag
,typename traversal_category<Iterator>::type >::type
> iterator_category;
typename return_category<Iterator>::type
, typename minimum_category<
forward_traversal_tag
, typename traversal_category<Iterator>::type
>::type
> iterator_category;
};
} // namespace detail
@@ -34,13 +36,13 @@ namespace boost
template <class Predicate, class Iterator>
class filter_iterator
: public iterator_adaptor<
filter_iterator<Predicate, Iterator>, Iterator
, detail::filter_iterator_traits<Iterator>
filter_iterator<Predicate, Iterator>, Iterator
, detail::filter_iterator_traits<Iterator>
>
{
typedef iterator_adaptor<
filter_iterator<Predicate, Iterator>, Iterator
, detail::filter_iterator_traits<Iterator>
filter_iterator<Predicate, Iterator>, Iterator
, detail::filter_iterator_traits<Iterator>
> super_t;
friend class iterator_core_access;

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

@@ -44,29 +44,31 @@ namespace boost
template <class T>
struct has_element_type
: mpl::bool_<
mpl::if_<
is_class<T>
, ::boost::detail::aux::has_element_type<T>
, mpl::false_
>::type::value
>
{
typedef typename mpl::if_<
is_class<T>
, aux::has_element_type<T>
, mpl::false_
>::type type;
};
# 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

2
include/boost/iterator/interoperable.hpp
View File

@@ -39,7 +39,7 @@ namespace boost
: mpl::true_
#else
: mpl::or_<
is_convertible< A, B >
is_convertible< A, B >
, is_convertible< B, A > >
#endif
{

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

@@ -32,14 +32,14 @@ namespace boost
template <class Traits, class Other>
struct same_category_and_difference
: mpl::and_<
is_same<
typename Traits::iterator_category
, typename Other::iterator_category
>
is_same<
typename Traits::iterator_category
, typename Other::iterator_category
>
, is_same<
typename Traits::iterator_category
, typename Other::iterator_category
>
typename Traits::iterator_category
, typename Other::iterator_category
>
>
{};
@@ -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
>
{
};
@@ -141,58 +146,60 @@ namespace boost
//
template <
class Derived
, class Iterator
, class Traits = detail::iterator_traits<Iterator>
, class Iterator
, class Traits = detail::iterator_traits<Iterator>
>
class iterator_adaptor
: public iterator_facade<Derived,Traits>
{
friend class iterator_core_access;
friend class iterator_core_access;
public:
iterator_adaptor() {}
public:
iterator_adaptor() {}
explicit iterator_adaptor(Iterator iter)
: m_iterator(iter)
{
}
explicit iterator_adaptor(Iterator iter)
: m_iterator(iter)
{
}
Iterator base() const { return m_iterator; }
Iterator base() const
{ return m_iterator; }
protected:
// Core iterator interface for iterator_facade
//
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
>
bool equal(iterator_adaptor<OtherDerived,OtherIterator,OtherTraits> const& x) const
{
BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value)
);
return m_iterator == x.base();
}
template <
class OtherDerived, class OtherIterator, class OtherTraits
>
bool equal(iterator_adaptor<OtherDerived,OtherIterator,OtherTraits> const& x) const
{
BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value)
);
return m_iterator == x.base();
}
void advance(typename Traits::difference_type n)
{
m_iterator += n;
}
void advance(typename Traits::difference_type n)
{
m_iterator += n;
}
void increment() { ++m_iterator; }
void decrement() { --m_iterator; }
void increment() { ++m_iterator; }
void decrement() { --m_iterator; }
template <class OtherDerived, class OtherIterator, class OtherTraits>
typename Traits::difference_type distance_to(
iterator_adaptor<OtherDerived, OtherIterator, OtherTraits> const& y) const
{
BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value)
);
return y.base() - m_iterator;
}
template <class OtherDerived, class OtherIterator, class OtherTraits>
typename Traits::difference_type distance_to(
iterator_adaptor<OtherDerived, OtherIterator, OtherTraits> const& y) const
{
BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value)
);
return y.base() - m_iterator;
}
private: // data members
Iterator m_iterator;

218
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,155 +289,73 @@ 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));
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((
iterator_facade<Derived, Traits> const& i
, typename Traits::difference_type n
))
BOOST_ITERATOR_FACADE_PLUS((
typename Traits::difference_type n
, iterator_facade<Derived, Traits> const& i
))
# undef BOOST_ITERATOR_FACADE_PLUS
} // namespace boost
#include <boost/iterator/detail/config_undef.hpp>