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

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

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

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

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

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

@@ -32,14 +32,14 @@ namespace boost
template <class Traits, class Other> template <class Traits, class Other>
struct same_category_and_difference struct same_category_and_difference
: mpl::and_< : mpl::and_<
is_same< is_same<
typename Traits::iterator_category typename Traits::iterator_category
, typename Other::iterator_category , typename Other::iterator_category
> >
, is_same< , is_same<
typename Traits::iterator_category typename Traits::iterator_category
, typename Other::iterator_category , typename Other::iterator_category
> >
> >
{}; {};
@@ -110,7 +110,8 @@ namespace boost
# else # else
::boost::is_convertible<From, To> ::boost::is_convertible<From, To>
# endif # endif
,detail::enable_type >::type type; , detail::enable_type
>::type type;
# endif # endif
}; };
@@ -121,18 +122,22 @@ namespace boost
// argument ordering is different from the std::iterator template, so that default // argument ordering is different from the std::iterator template, so that default
// arguments can be used effectivly. // arguments can be used effectivly.
// //
template <class Iterator, template <
class ValueType = typename detail::iterator_traits<Iterator>::value_type, class Iterator
class Reference = ValueType&, , class ValueType = typename detail::iterator_traits<Iterator>::value_type
class Pointer = ValueType*, , class Reference = ValueType&
class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category, , class Pointer = ValueType*
class DifferenceType = typename detail::iterator_traits<Iterator>::difference_type > , class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category
, class DifferenceType = typename detail::iterator_traits<Iterator>::difference_type
>
struct iterator_traits_adaptor struct iterator_traits_adaptor
: iterator<IteratorCategory, : iterator<
ValueType, IteratorCategory
DifferenceType, , ValueType
Pointer, , DifferenceType
Reference> , Pointer
, Reference
>
{ {
}; };
@@ -141,58 +146,60 @@ namespace boost
// //
template < template <
class Derived class Derived
, class Iterator , class Iterator
, class Traits = detail::iterator_traits<Iterator> , class Traits = detail::iterator_traits<Iterator>
> >
class iterator_adaptor class iterator_adaptor
: public iterator_facade<Derived,Traits> : public iterator_facade<Derived,Traits>
{ {
friend class iterator_core_access; friend class iterator_core_access;
public: public:
iterator_adaptor() {} iterator_adaptor() {}
explicit iterator_adaptor(Iterator iter) explicit iterator_adaptor(Iterator iter)
: m_iterator(iter) : m_iterator(iter)
{ {
} }
Iterator base() const { return m_iterator; } Iterator base() const
{ return m_iterator; }
protected: protected:
// Core iterator interface for iterator_facade // Core iterator interface for iterator_facade
// //
typename Traits::reference dereference() const { return *m_iterator; } typename Traits::reference dereference() const
{ return *m_iterator; }
template < template <
class OtherDerived, class OtherIterator, class OtherTraits class OtherDerived, class OtherIterator, class OtherTraits
> >
bool equal(iterator_adaptor<OtherDerived,OtherIterator,OtherTraits> const& x) const bool equal(iterator_adaptor<OtherDerived,OtherIterator,OtherTraits> const& x) const
{ {
BOOST_STATIC_ASSERT( BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value) (detail::same_category_and_difference<Traits,OtherTraits>::value)
); );
return m_iterator == x.base(); return m_iterator == x.base();
} }
void advance(typename Traits::difference_type n) void advance(typename Traits::difference_type n)
{ {
m_iterator += n; m_iterator += n;
} }
void increment() { ++m_iterator; } void increment() { ++m_iterator; }
void decrement() { --m_iterator; } void decrement() { --m_iterator; }
template <class OtherDerived, class OtherIterator, class OtherTraits> template <class OtherDerived, class OtherIterator, class OtherTraits>
typename Traits::difference_type distance_to( typename Traits::difference_type distance_to(
iterator_adaptor<OtherDerived, OtherIterator, OtherTraits> const& y) const iterator_adaptor<OtherDerived, OtherIterator, OtherTraits> const& y) const
{ {
BOOST_STATIC_ASSERT( BOOST_STATIC_ASSERT(
(detail::same_category_and_difference<Traits,OtherTraits>::value) (detail::same_category_and_difference<Traits,OtherTraits>::value)
); );
return y.base() - m_iterator; return y.base() - m_iterator;
} }
private: // data members private: // data members
Iterator m_iterator; 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 // enable_if_interoperable falls back to always enabled for compilers
// that don't support enable_if or is_convertible. // that don't support enable_if or is_convertible.
// //
template <class Facade1, template <
class Facade2, class Facade1
class Return> , class Facade2
struct enable_if_interoperable : , class Return
::boost::detail::enable_if< is_convertible< Facade1, Facade2 > >
, Return > struct enable_if_interoperable
: ::boost::detail::enable_if<
is_convertible<Facade1, Facade2>
, Return
>
{ {
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) # if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
typedef Return type; typedef Return type;
@@ -285,155 +289,73 @@ namespace boost
// a == b; // 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(), # define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, condition, return_prefix, base_op) \
rhs.derived()); 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, # define BOOST_ITERATOR_FACADE_RELATION(op, test, base_op) \
class Traits1, BOOST_ITERATOR_FACADE_INTEROP( \
class Derived2, op \
class Traits2> , bool \
inline , true \
typename detail::enable_if_interoperable<Derived1, , return test \
Derived2, , base_op \
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(), BOOST_ITERATOR_FACADE_RELATION(==, (bool), equal)
rhs.derived()); 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, BOOST_ITERATOR_FACADE_PLUS((
class Traits1, iterator_facade<Derived, Traits> const& i
class Derived2, , typename Traits::difference_type n
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((
typename Traits::difference_type n
, iterator_facade<Derived, Traits> const& i
))
# undef BOOST_ITERATOR_FACADE_PLUS
} // namespace boost } // namespace boost
#include <boost/iterator/detail/config_undef.hpp> #include <boost/iterator/detail/config_undef.hpp>