chapter-7-zip_view.hpp

Go to the documentation of this file.

// ===-- chapter-7/chapter-7-zip_view.hpp ----------------- -*- C++ -*- --=== //
#ifndef CHAPTER_7_ZIP_VIEW
#define CHAPTER_7_ZIP_VIEW
 
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/iterator_category.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/transform.hpp>
using namespace boost::mpl::placeholders;
 
// This is work from exercise 7-2...
#ifndef FORWARD_ONLY_ZIP_VIEW
 
#include <boost/mpl/empty.hpp>
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/filter_view.hpp>
 
#include <boost/type_traits/is_same.hpp>
 
 
namespace chapter7 {
 
template <typename S>
struct extract_iterator_category
{
    typedef typename boost::mpl::begin<S>::type::category type;
};
 
template <typename S>
struct least_refined_iterator_category
{
    typedef typename boost::mpl::filter_view<
        S,
        boost::mpl::not_<
            boost::is_same<
                extract_iterator_category<_1>,
                boost::mpl::random_access_iterator_tag>
        >
    >::type non_random_access_iterators;
 
    typedef typename boost::mpl::filter_view<
        non_random_access_iterators,
        boost::mpl::not_<
            boost::is_same<
                extract_iterator_category<_1>,
                boost::mpl::bidirectional_iterator_tag>
        >
    >::type non_bidirectional_iterators;
 
    typedef typename boost::mpl::if_<
        boost::mpl::empty<non_random_access_iterators>,
        boost::mpl::random_access_iterator_tag,
        typename boost::mpl::if_<
            boost::mpl::empty<non_bidirectional_iterators>,
            boost::mpl::bidirectional_iterator_tag,
            boost::mpl::forward_iterator_tag>::type
        >::type type;
};
 
#else
 
// This is a place-holder until exercise 7-2
template <typename S>
struct least_refined_iterator_category
{
    typedef boost::mpl::forward_iterator_tag type;
};
 
#endif // !FORWARD_ONLY_ZIP_VIEW
 
template <typename IteratorSeq, typename Category>
struct zip_iterator
    : boost::mpl::transform< IteratorSeq, boost::mpl::deref<_1> >
{
    typedef IteratorSeq base;
    typedef Category category;
};
 
struct zip_view_tag { };
 
template <typename Sequences>
struct zip_view
    : boost::mpl::iterator_range<
        zip_iterator<
            typename boost::mpl::transform<
                Sequences, boost::mpl::begin<_1>
            >::type,
            typename least_refined_iterator_category<Sequences>::type
        >,
        zip_iterator<
            typename boost::mpl::transform<
                Sequences, boost::mpl::end<_1>
            >::type,
            typename least_refined_iterator_category<Sequences>::type
        >
    >
{
    typedef zip_view_tag tag;
};
 
} // namespace chapter7
 
 
#include <boost/static_assert.hpp>
#include <boost/mpl/or.hpp>
 
#include <boost/mpl/at.hpp>
 
 
namespace boost {
namespace mpl {
 
 
template <typename IteratorSeq, typename Category>
struct next< chapter7::zip_iterator<IteratorSeq, Category> >
{
    typedef chapter7::zip_iterator<
        typename transform< IteratorSeq, next<_1> >::type,
        Category
    > type;
};
 
// Begin metafunctions for exercise 7-2...
 
template <typename IteratorSeq, typename N>
struct advance<
    chapter7::zip_iterator<IteratorSeq, random_access_iterator_tag>, N >
{
    typedef chapter7::zip_iterator<
        typename transform< IteratorSeq, advance<_1, N> >::type,
        random_access_iterator_tag
    > type;
};
 
template <>
struct at_impl<chapter7::zip_view_tag>
{
    template <typename S, typename Category, typename N> struct apply_impl { };
 
    template <typename S, typename N>
    struct apply_impl<S, random_access_iterator_tag, N>
    {
        typedef chapter7::zip_iterator<
            typename transform< S, at<_1, N> >::type,
            random_access_iterator_tag> type;
    };
 
    template <typename S, typename N> struct apply { };
    template <typename S, typename N>
    struct apply< chapter7::zip_view<S>, N >
        : apply_impl<
            S,
        typename chapter7::least_refined_iterator_category<S>::type,
            N>
    { };
};
 
template <typename IteratorSeq, typename Category>
struct prior< chapter7::zip_iterator<IteratorSeq, Category> >
{
    BOOST_STATIC_ASSERT((
        boost::mpl::or_<
            boost::is_same<
                Category,
                boost::mpl::bidirectional_iterator_tag>,
            boost::is_same<
                Category,
                boost::mpl::random_access_iterator_tag>
        >::type::value));
 
    typedef chapter7::zip_iterator<
        typename transform< IteratorSeq, prior<_1> >::type,
        Category
    > type;
};
 
 
} // namespace mpl
} // namespace boost
 
#endif // CHAPTER_7_ZIP_VIEW