#include <cstdlib>
#include <iostream>
#include <boost/fusion/include/is_sequence.hpp>
#include <boost/fusion/include/equal_to.hpp>
#include <boost/fusion/include/iterator_range.hpp>
#include <boost/fusion/include/iterator.hpp>
#include <boost/fusion/include/join.hpp>
#include <boost/fusion/include/find_if.hpp>
#include <boost/type_traits/remove_reference.hpp>

#include <boost/fusion/include/out.hpp>
#include <boost/fusion/include/make_vector.hpp>


namespace fs = boost::fusion;
namespace mpl = boost::mpl;
using namespace std;
    
template<class Seq>
struct result_of_flatten;


template<class B, class P, class E, bool not_found = fs::result_of::equal_to<P, E>::value>
struct result_of_flatten_impl
{
    typedef fs::iterator_range<B, E> type;
    
    static inline
    type call(B const& b, P const&, E const& e)
    {
        return type(b, e);
    }
};

template<class B, class P, class E>
struct result_of_flatten_impl<B, P, E, false>
{
    typedef
        fs::iterator_range<typename fs::result_of::next<P>::type, E>
    rest_range;
    
    typedef
        result_of_flatten
        <
            typename fs::result_of::join
            <
                typename boost::remove_reference<typename fs::result_of::deref<P>::type>::type
              , const rest_range
            >::type
        >
    result_of_flatten;
    
    typedef typename  
        fs::result_of::join
        <
            const fs::iterator_range<B, P>
          , const typename result_of_flatten::type
        >::type
    type;
    
    static inline
    type call(B const& b, P const& p, E const& e)
    {       
        return
            fs::join
            (
                fs::iterator_range<B, P>(b, p)
              , result_of_flatten::call(fs::join(fs::deref(p), rest_range(fs::next(p), e)))
            );
    }
};


template<class Seq>
struct result_of_flatten
{
    typedef typename
        fs::result_of::begin<Seq>::type
    begin;
    
    typedef typename
        fs::result_of::end<Seq>::type
    end;
    
    typedef fs::traits::is_sequence<mpl::_1> pred;
    
    typedef typename
        fs::result_of::find_if<Seq, pred>::type
    pos_to_flatten;
    
    typedef
        result_of_flatten_impl<begin, pos_to_flatten, end>
    impl;
    
    typedef typename impl::type type;
    
    static inline
    type call(Seq const& s)
    {
        return impl::call(fs::begin(s), fs::find_if<pred>(s), fs::end(s));
    }
};
    

////////////////////////////

template<class Seq>
inline
typename result_of_flatten<Seq const>::type
flatten(Seq const& seq)
{
    return result_of_flatten<Seq const>::call(seq);
}



int main(int argc, char *argv[])
{
    cout << flatten(fs::make_vector(fs::make_vector(10, 11, fs::make_vector(12, 13)), fs::make_vector(14), 15)) << endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}