feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

flatten/flatten_view/ref

Browse Source
This commit is contained in:
Jamboree
2014-04-04 14:38:38 +08:00
parent efad85a925
commit fd3a18ce1a
17 changed files with 872 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/boost/fusion/view/flatten_view.hpp Normal file
View File

@ -0,0 +1,15 @@
/*//////////////////////////////////////////////////////////////////////////////
Copyright (c) 2013 Jamboree
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//////////////////////////////////////////////////////////////////////////////*/
#ifndef BOOST_FUSION_SEQUENCE_FLATTEN_VIEW_HPP_INCLUDED
#define BOOST_FUSION_SEQUENCE_FLATTEN_VIEW_HPP_INCLUDED
#include <boost/fusion/view/flatten_view/flatten_view.hpp>
#include <boost/fusion/view/flatten_view/flatten_view_iterator.hpp>
#endif

127
include/boost/fusion/view/flatten_view/flatten_view.hpp Normal file
View File

@ -0,0 +1,127 @@
/*//////////////////////////////////////////////////////////////////////////////
Copyright (c) 2013 Jamboree
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//////////////////////////////////////////////////////////////////////////////*/
#ifndef BOOST_FUSION_FLATTEN_VIEW_HPP_INCLUDED
#define BOOST_FUSION_FLATTEN_VIEW_HPP_INCLUDED
#include <boost/mpl/bool.hpp>
#include <boost/mpl/single_view.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/support/is_view.hpp>
#include <boost/fusion/support/category_of.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/view/flatten_view/flatten_view_iterator.hpp>
namespace boost { namespace fusion
{
struct forward_traversal_tag;
struct flatten_view_tag;
template <typename Sequence>
struct flatten_view
: sequence_base<flatten_view<Sequence> >
{
typedef flatten_view_tag fusion_tag;
typedef fusion_sequence_tag tag; // this gets picked up by MPL
typedef mpl::true_ is_view;
typedef forward_traversal_tag category;
typedef Sequence sequence_type;
typedef typename result_of::begin<Sequence>::type first_type;
typedef typename result_of::end<Sequence>::type last_type;
explicit flatten_view(Sequence& seq)
: seq(seq)
{}
first_type first() const { return fusion::begin(seq); }
last_type last() const { return fusion::end(seq); }
typename mpl::if_<traits::is_view<Sequence>, Sequence, Sequence&>::type seq;
};
}}
namespace boost { namespace fusion { namespace extension
{
template<>
struct begin_impl<flatten_view_tag>
{
template<typename Sequence>
struct apply
{
typedef typename Sequence::first_type first_type;
typedef typename
result_of::begin<
mpl::single_view<
typename Sequence::sequence_type> >::type
root_iterator;
typedef
detail::seek_descent<root_iterator, first_type>
seek_descent;
typedef typename seek_descent::type type;
static inline
type call(Sequence& seq)
{
return seek_descent::apply(root_iterator(), seq.first());
}
};
};
template<>
struct end_impl<flatten_view_tag>
{
template<typename Sequence>
struct apply
{
typedef typename Sequence::last_type last_type;
typedef typename
result_of::end<
mpl::single_view<
typename Sequence::sequence_type> >::type
type;
static inline
type call(Sequence&)
{
return type();
}
};
};
template<>
struct size_impl<flatten_view_tag>
{
template <typename Sequence>
struct apply
: result_of::distance
<
typename result_of::begin<Sequence>::type
, typename result_of::end<Sequence>::type
>
{};
};
template<>
struct empty_impl<flatten_view_tag>
{
template <typename Sequence>
struct apply
: result_of::empty<typename Sequence::sequence_type>
{};
};
}}}
#endif

199
include/boost/fusion/view/flatten_view/flatten_view_iterator.hpp Normal file
View File

@ -0,0 +1,199 @@
/*//////////////////////////////////////////////////////////////////////////////
Copyright (c) 2013 Jamboree
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//////////////////////////////////////////////////////////////////////////////*/
#ifndef BOOST_FUSION_FLATTEN_VIEW_ITERATOR_HPP_INCLUDED
#define BOOST_FUSION_FLATTEN_VIEW_ITERATOR_HPP_INCLUDED
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/container/list/cons.hpp>
#include <boost/fusion/support/unused.hpp>
#include <boost/fusion/include/equal_to.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/value_of.hpp>
namespace boost { namespace fusion
{
struct forward_traversal_tag;
struct flatten_view_iterator_tag;
template<class First, class Base>
struct flatten_view_iterator
: iterator_base<flatten_view_iterator<First, Base> >
{
typedef flatten_view_iterator_tag fusion_tag;
typedef forward_traversal_tag category;
typedef convert_iterator<First> first_converter;
typedef typename first_converter::type first_type;
typedef Base base_type;
flatten_view_iterator(First const& first, Base const& base)
: first(first), base(base)
{}
first_type first;
base_type base;
};
}}
namespace boost { namespace fusion { namespace detail
{
template<class Iterator, class = void>
struct make_descent_cons
{
typedef cons<Iterator> type;
static inline type apply(Iterator const& it)
{
return type(it);
}
};
template<class Iterator>
struct make_descent_cons<Iterator,
typename enable_if<traits::is_sequence<
typename result_of::value_of<Iterator>::type> >::type>
{
// we use 'value_of' above for convenience, assuming the value won't be reference,
// while we must use the regular 'deref' here for const issues...
typedef typename
remove_reference<typename result_of::deref<Iterator>::type>::type
sub_sequence;
typedef typename
result_of::begin<sub_sequence>::type
sub_begin;
typedef cons<Iterator, typename make_descent_cons<sub_begin>::type> type;
static inline type apply(Iterator const& it)
{
return type(it, make_descent_cons<sub_begin>::apply(
fusion::begin(*it)));
}
};
template<class Cons, class Base>
struct build_flatten_view_iterator;
template<class Car, class Base>
struct build_flatten_view_iterator<cons<Car>, Base>
{
typedef flatten_view_iterator<Car, Base> type;
static inline type apply(cons<Car> const& cons, Base const& base)
{
return type(cons.car, base);
}
};
template<class Car, class Cdr, class Base>
struct build_flatten_view_iterator<cons<Car, Cdr>, Base>
{
typedef flatten_view_iterator<Car, Base> next_base;
typedef build_flatten_view_iterator<Cdr, next_base> next;
typedef typename next::type type;
static inline type apply(cons<Car, Cdr> const& cons, Base const& base)
{
return next::apply(cons.cdr, next_base(cons.car, base));
}
};
template<class Base, class Iterator, class = void>
struct seek_descent
{
typedef make_descent_cons<Iterator> make_descent_cons_;
typedef typename make_descent_cons_::type cons_type;
typedef
build_flatten_view_iterator<cons_type, Base>
build_flatten_view_iterator_;
typedef typename build_flatten_view_iterator_::type type;
static inline type apply(Base const& base, Iterator const& it)
{
return build_flatten_view_iterator_::apply(
make_descent_cons_::apply(it), base);
}
};
template<class Base, class Iterator>
struct seek_descent<Base, Iterator,
typename enable_if<
result_of::equal_to<Iterator, typename result_of::end<
typename result_of::value_of<Base>::type>::type> >::type>
{
typedef typename result_of::next<Base>::type type;
static inline type apply(Base const& base, Iterator const&)
{
return fusion::next(base);
}
};
}}}
namespace boost { namespace fusion { namespace extension
{
template<>
struct next_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename Iterator::first_type first_type;
typedef typename Iterator::base_type base_type;
typedef typename result_of::next<first_type>::type next_type;
typedef detail::seek_descent<base_type, next_type> seek_descent;
typedef typename seek_descent::type type;
static inline
type call(Iterator const& it)
{
return seek_descent::apply(it.base, fusion::next(it.first));
}
};
};
template<>
struct deref_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename
result_of::deref<typename Iterator::first_type>::type
type;
static inline
type call(Iterator const& it)
{
return *it.first;
}
};
};
template<>
struct value_of_impl<flatten_view_iterator_tag>
{
template<typename Iterator>
struct apply
{
typedef typename
result_of::value_of<typename Iterator::first_type>::type
type;
};
};
}}}
#endif