boost_mirror/iterator
1
0
Fork 0
mirror of https://github.com/boostorg/iterator.git synced 2025-05-12 14:01:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed all pair generator's except for projection and

Browse Source 
some const adaptor generators.

Added make_xxx_iterator() helper functions for remaining
iterator adaptors.

Removed some traits template parameters where they
where no longer needed thanks to detail::iterator_traits.

Moved some of the compile-time logic into enums for
EDG compatibility.


[SVN r9024]
This commit is contained in:
Jeremy Siek 2001-02-08 03:07:33 +00:00
parent 762e603013
commit ee9f140fae
1 changed files with 162 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
include/boost/iterator_adaptors.hpp
View File

@ -12,7 +12,20 @@
// //
// Revision History: // Revision History:
// 07 Feb 2001 // 07 Feb 2001 Jeremy Siek
// Removed all pair generator's except for projection and
// some const adaptor generators.
//
// Added make_xxx_iterator() helper functions for remaining
// iterator adaptors.
//
// Removed some traits template parameters where they
// where no longer needed thanks to detail::iterator_traits.
//
// Moved some of the compile-time logic into enums for
// EDG compatibility.
//
// 07 Feb 2001 David Abrahams
// Removed iterator_adaptor_pair_generator and // Removed iterator_adaptor_pair_generator and
// reverse_iterator_pair_generator (more such culling to come) // reverse_iterator_pair_generator (more such culling to come)
// //
@ -24,7 +37,7 @@
// //
// Fixed naming convention of non-template parameter names // Fixed naming convention of non-template parameter names
// //
// 06 Feb 2001 // 06 Feb 2001 David Abrahams
// Produce operator-> proxy objects for InputIterators // Produce operator-> proxy objects for InputIterators
// //
// Added static assertions to do some basic concept checks // Added static assertions to do some basic concept checks
@ -321,10 +334,9 @@ namespace detail {
typedef typename Traits::iterator_category category; typedef typename Traits::iterator_category category;
typedef operator_arrow_proxy<typename Traits::value_type> proxy; typedef operator_arrow_proxy<typename Traits::value_type> proxy;
typedef typename Traits::pointer pointer; typedef typename Traits::pointer pointer;
typedef typename boost::detail::if_true<( enum { is_input_iter = boost::is_convertible<category,std::input_iterator_tag>::value
boost::is_convertible<category,std::input_iterator_tag>::value & !boost::is_convertible<category,std::forward_iterator_tag>::value };
& !boost::is_convertible<category,std::forward_iterator_tag>::value typedef typename boost::detail::if_true<(is_input_iter)>::template
)>::template
then< then<
proxy, proxy,
// else // else
@ -382,14 +394,19 @@ public:
typedef typename Traits::iterator_category iterator_category; typedef typename Traits::iterator_category iterator_category;
typedef Iterator iterator_type; typedef Iterator iterator_type;
enum { is_input_or_output_iter =
boost::is_convertible<iterator_category,std::input_iterator_tag>::value
|| boost::is_convertible<iterator_category,std::output_iterator_tag>::value };
// Iterators should satisfy one of the known categories // Iterators should satisfy one of the known categories
BOOST_STATIC_ASSERT((boost::is_convertible<iterator_category,std::input_iterator_tag>::value BOOST_STATIC_ASSERT(is_input_or_output_iter);
|| boost::is_convertible<iterator_category,std::output_iterator_tag>::value));
// Iterators >= ForwardIterator must produce real references. // Iterators >= ForwardIterator must produce real references.
BOOST_STATIC_ASSERT((!boost::is_convertible<iterator_category,std::forward_iterator_tag>::value enum { forward_iter_with_real_reference =
|| boost::is_same<reference,value_type&>::value (!boost::is_convertible<iterator_category,std::forward_iterator_tag>::value
|| boost::is_same<reference,const value_type&>::value)); || boost::is_same<reference,value_type&>::value
|| boost::is_same<reference,const value_type&>::value) };
BOOST_STATIC_ASSERT(forward_iter_with_real_reference);
iterator_adaptor() { } iterator_adaptor() { }
@ -566,30 +583,22 @@ struct transform_iterator_policies : public default_iterator_policies
AdaptableUnaryFunction m_f; AdaptableUnaryFunction m_f;
}; };
template <class AdaptableUnaryFunction, class IteratorTraits> template <class AdaptableUnaryFunction, class Iterator>
struct transform_iterator_traits { class transform_iterator_generator
typedef typename AdaptableUnaryFunction::result_type value_type;
typedef value_type reference;
typedef value_type* pointer;
typedef typename IteratorTraits::difference_type difference_type;
typedef std::input_iterator_tag iterator_category;
};
template <class AdaptableUnaryFunction,
class Iterator,
class Traits = boost::detail::iterator_traits<Iterator>
>
struct transform_iterator_generator
{ {
typedef transform_iterator_traits<AdaptableUnaryFunction,Traits> typedef typename boost::detail::iterator_traits<Iterator>::difference_type
transform_traits; difference_type;
typedef typename AdaptableUnaryFunction::result_type value_type;
public:
typedef boost::iterator<std::input_iterator_tag,
value_type, difference_type, value_type*, value_type> transform_traits;
typedef iterator_adaptor<Iterator, typedef iterator_adaptor<Iterator,
transform_iterator_policies<AdaptableUnaryFunction>, transform_traits> transform_iterator_policies<AdaptableUnaryFunction>, transform_traits>
type; type;
}; };
template <class AdaptableUnaryFunction, class Iterator> template <class AdaptableUnaryFunction, class Iterator>
typename transform_iterator_generator<AdaptableUnaryFunction,Iterator>::type inline typename transform_iterator_generator<AdaptableUnaryFunction,Iterator>::type
make_transform_iterator( make_transform_iterator(
const Iterator& base, const Iterator& base,
const AdaptableUnaryFunction& f = AdaptableUnaryFunction()) const AdaptableUnaryFunction& f = AdaptableUnaryFunction())
@ -620,52 +629,44 @@ struct indirect_iterator_policies : public default_iterator_policies
{ return **x; } { return **x; }
}; };
template <class OuterIterator,
class InnerIterator = typename boost::detail::iterator_traits<OuterIterator>::value_type,
class InnerTraits = boost::detail::iterator_traits<InnerIterator>,
class OuterTraits = boost::detail::iterator_traits<OuterIterator> // never needed (?)
>
struct indirect_traits
{
typedef typename OuterTraits::difference_type difference_type;
typedef typename InnerTraits::value_type value_type;
typedef typename InnerTraits::pointer pointer;
typedef typename InnerTraits::reference reference;
typedef typename OuterTraits::iterator_category iterator_category;
};
template <class OuterIterator, // Mutable or Immutable, does not matter template <class OuterIterator, // Mutable or Immutable, does not matter
// Mutable -> mutable indirect iterator; Immutable -> immutable indirect iterator // Mutable -> mutable indirect iterator; Immutable -> immutable indirect iterator
class InnerIterator = typename boost::detail::iterator_traits<OuterIterator>::value_type, class InnerIterator = typename boost::detail::iterator_traits<OuterIterator>::value_type,
class InnerTraits = boost::detail::iterator_traits<InnerIterator>, class InnerTraits = boost::detail::iterator_traits<InnerIterator>
class OuterTraits = boost::detail::iterator_traits<OuterIterator> // never needed (?) >
> class indirect_iterator_generator
struct indirect_iterator_generator
{ {
typedef iterator_adaptor<OuterIterator, typedef boost::detail::iterator_traits<OuterIterator> OuterTraits;
indirect_iterator_policies, typedef typename OuterTraits::difference_type difference_type;
indirect_traits<OuterIterator, InnerIterator, typedef typename OuterTraits::iterator_category iterator_category;
InnerTraits, OuterTraits>
> type; typedef typename InnerTraits::value_type value_type;
typedef typename InnerTraits::pointer pointer;
typedef typename InnerTraits::reference reference;
public:
typedef boost::iterator<iterator_category, value_type, difference_type, pointer, reference> indirect_traits;
typedef iterator_adaptor<OuterIterator, indirect_iterator_policies, indirect_traits> type;
}; };
template <class OuterIterator, // Mutable or Immutable, does not matter template <class OuterIterator, class InnerIterator, class InnerTraits>
class ConstInnerIterator, // Immutable inline typename indirect_iterator_generator<OuterIterator, InnerIterator, InnerTraits>::type
class ConstInnerTraits = boost::detail::iterator_traits<ConstInnerIterator>, make_indirect_iterator(OuterIterator outer, InnerIterator, InnerTraits)
class InnerIterator = typename boost::detail::iterator_traits<OuterIterator>::value_type,
class InnerTraits = boost::detail::iterator_traits<InnerIterator>,
class OuterTraits = boost::detail::iterator_traits<OuterIterator> // never needed (?)
>
struct indirect_iterator_pair_generator
{ {
typedef iterator_adaptor<OuterIterator, typedef typename indirect_iterator_generator
indirect_traits<OuterIterator, InnerIterator, InnerTraits, OuterTraits>, <OuterIterator, InnerIterator, InnerTraits>::type result_t;
indirect_iterator_policies> iterator; return result_t(outer);
}
typedef iterator_adaptor<OuterIterator,
indirect_traits<OuterIterator, ConstInnerIterator, ConstInnerTraits, OuterTraits>, #if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
indirect_iterator_policies> const_iterator; template <class OuterIterator>
}; inline typename indirect_iterator_generator<OuterIterator>::type
make_indirect_iterator(OuterIterator outer)
{
typedef typename indirect_iterator_generator
<OuterIterator>::type result_t;
return result_t(outer);
}
#endif
//============================================================================= //=============================================================================
@ -712,14 +713,23 @@ struct reverse_iterator_generator
Traits> type; Traits> type;
}; };
template <class ConstIterator, template <class Iterator, class Traits>
class ConstTraits = boost::detail::iterator_traits<ConstIterator> inline typename reverse_iterator_generator<Iterator, Traits>::type
> make_reverse_iterator(Iterator iter, Traits)
struct const_reverse_iterator_generator
{ {
typedef iterator_adaptor<ConstIterator, reverse_iterator_policies, typedef typename reverse_iterator_generator<Iterator, Traits>::type result_t;
ConstTraits> type; return result_t(iter);
}; }
#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
template <class Iterator>
inline typename reverse_iterator_generator<Iterator>::type
make_reverse_iterator(Iterator iter)
{
typedef typename reverse_iterator_generator<Iterator>::type result_t;
return result_t(iter);
}
#endif
//============================================================================= //=============================================================================
// Projection Iterators Adaptor // Projection Iterators Adaptor
@ -738,101 +748,119 @@ struct projection_iterator_policies : public default_iterator_policies
AdaptableUnaryFunction m_f; AdaptableUnaryFunction m_f;
}; };
template <class AdaptableUnaryFunction, class Traits> template <class AdaptableUnaryFunction, class Iterator>
struct projection_iterator_traits { class projection_iterator_generator {
typedef boost::detail::iterator_traits<Iterator> Traits;
typedef typename AdaptableUnaryFunction::result_type value_type; typedef typename AdaptableUnaryFunction::result_type value_type;
typedef value_type& reference; typedef boost::iterator<typename Traits::iterator_category,
typedef value_type* pointer; value_type, typename Traits::difference_type, value_type*, value_type&>
typedef typename Traits::difference_type difference_type;
typedef typename Traits::iterator_category iterator_category;
};
template <class AdaptableUnaryFunction, class Traits>
struct const_projection_iterator_traits {
typedef typename AdaptableUnaryFunction::result_type value_type;
typedef value_type const& reference;
typedef value_type const* pointer;
typedef typename Traits::difference_type difference_type;
typedef typename Traits::iterator_category iterator_category;
};
template <class AdaptableUnaryFunction, class Iterator,
class Traits = boost::detail::iterator_traits<Iterator>
>
struct projection_iterator_generator {
typedef projection_iterator_traits<AdaptableUnaryFunction, Traits>
projection_traits; projection_traits;
public:
typedef iterator_adaptor<Iterator, typedef iterator_adaptor<Iterator,
projection_iterator_policies<AdaptableUnaryFunction>, projection_iterator_policies<AdaptableUnaryFunction>,
projection_traits> type; projection_traits> type;
}; };
template <class AdaptableUnaryFunction, class Iterator, template <class AdaptableUnaryFunction, class Iterator>
class Traits = boost::detail::iterator_traits<Iterator> class const_projection_iterator_generator {
> typedef boost::detail::iterator_traits<Iterator> Traits;
struct const_projection_iterator_generator { typedef typename AdaptableUnaryFunction::result_type value_type;
typedef const_projection_iterator_traits<AdaptableUnaryFunction, typedef boost::iterator<typename Traits::iterator_category,
Traits> projection_traits; value_type, typename Traits::difference_type, const value_type*, const value_type&>
projection_traits;
public:
typedef iterator_adaptor<Iterator, typedef iterator_adaptor<Iterator,
projection_iterator_policies<AdaptableUnaryFunction>, projection_iterator_policies<AdaptableUnaryFunction>,
projection_traits> type; projection_traits> type;
}; };
template <class AdaptableUnaryFunction, class Iterator, class ConstIterator, template <class AdaptableUnaryFunction, class Iterator, class ConstIterator>
class Traits = boost::detail::iterator_traits<Iterator>,
class ConstTraits = boost::detail::iterator_traits<ConstIterator>
>
struct projection_iterator_pair_generator { struct projection_iterator_pair_generator {
typedef projection_iterator_traits<AdaptableUnaryFunction, Traits> typedef typename projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type iterator;
projection_traits; typedef typename const_projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type const_iterator;
typedef const_projection_iterator_traits<AdaptableUnaryFunction,
ConstTraits> const_projection_traits;
typedef iterator_adaptor<Iterator, projection_iterator_policies<AdaptableUnaryFunction>,
projection_traits> iterator;
typedef iterator_adaptor<ConstIterator, projection_iterator_policies<AdaptableUnaryFunction>,
const_projection_traits > const_iterator;
}; };
template <class AdaptableUnaryFunction, class Iterator>
inline typename projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type
make_projection_iterator(Iterator iter, AdaptableUnaryFunction f)
{
typedef typename projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type result_t;
return result_t(iter, f);
}
template <class AdaptableUnaryFunction, class Iterator>
inline typename const_projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type
make_const_projection_iterator(Iterator iter, AdaptableUnaryFunction f)
{
typedef typename const_projection_iterator_generator<AdaptableUnaryFunction, Iterator>::type result_t;
return result_t(iter, f);
}
//============================================================================= //=============================================================================
// Filter Iterator Adaptor // Filter Iterator Adaptor
template <class Predicate, class Iterator> template <class Predicate, class Iterator>
class filter_iterator_policies : public default_iterator_policies { class filter_iterator_policies : public default_iterator_policies {
public: public:
filter_iterator_policies() { } filter_iterator_policies() { }
filter_iterator_policies(const Predicate& p, const Iterator& end) filter_iterator_policies(const Predicate& p, const Iterator& end)
: m_predicate(p), m_end(end) { } : m_predicate(p), m_end(end) { }
void initialize(Iterator& x) { void initialize(Iterator& x) {
advance(x); advance(x);
} }
// dwa 2/4/01 - The Iter template argument neccessary for compatibility with // dwa 2/4/01 - The Iter template argument neccessary for compatibility with
// a MWCW bug workaround // a MWCW bug workaround
template <class Iter> template <class Iter>
void increment(Iter& x) { void increment(Iter& x) {
++x; ++x;
advance(x); advance(x);
} }
private: private:
void advance(Iterator& iter) void advance(Iterator& iter)
{ {
while (m_end != iter && !m_predicate(*iter)) while (m_end != iter && !m_predicate(*iter))
++iter; ++iter;
} }
Predicate m_predicate; Predicate m_predicate;
Iterator m_end; Iterator m_end;
}; };
template <class Predicate, class Iterator, template <class Predicate, class Iterator,
class Traits = boost::detail::iterator_traits<Iterator> class Traits = boost::detail::iterator_traits<Iterator>
> >
class filter_iterator_generator { class filter_iterator_generator {
typedef filter_iterator_policies<Predicate, Iterator> Policies; typedef filter_iterator_policies<Predicate, Iterator> Policies;
public: public:
typedef filter_iterator_policies<Predicate, Iterator> policies_type;
typedef iterator_adaptor<Iterator, Policies, Traits> type; typedef iterator_adaptor<Iterator, Policies, Traits> type;
}; };
template <class Predicate, class Iterator, class Traits>
inline typename filter_iterator_generator<Predicate, Iterator, Traits>::type
make_filter_iterator(Iterator first, Iterator last, Predicate p, Traits)
{
typedef filter_iterator_generator<Predicate, Iterator, Traits> Gen;
typedef typename Gen::policies_type policies_t;
typedef typename Gen::type result_t;
return result_t(first, policies_t(p, last));
}
#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
template <class Predicate, class Iterator>
inline typename filter_iterator_generator<Predicate, Iterator>::type
make_filter_iterator(Iterator first, Iterator last, Predicate p)
{
typedef filter_iterator_generator<Predicate, Iterator> Gen;
typedef typename Gen::policies_type policies_t;
typedef typename Gen::type result_t;
return result_t(first, policies_t(p, last));
}
#endif
} // namespace boost } // namespace boost