/*//////////////////////////////////////////////////////////////////////////////
    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/single_view.hpp>
#include <boost/fusion/view/transform_view.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;
        
        explicit flatten_view(Sequence& seq)
          : seq(seq)
        {}
        
        typename mpl::if_<traits::is_view<Sequence>, Sequence, Sequence&>::type seq;
    };
}}

namespace boost { namespace fusion { namespace detail
{
    struct wrap_flatten
    {
        template<class>
        struct result;
        
        template<class This, class T>
        struct result<This(T)>
        {
            typedef typename remove_reference<T>::type value_type;
            typedef typename
                mpl::if_<traits::is_sequence<value_type>,
                    flatten_view<value_type>, single_view<T> >::type
            type;    
        };

        template<class T>
        typename result<wrap_flatten(T&)>::type operator()(T& elem) const
        {
            return typename result<wrap_flatten(T&)>::type(elem);
        }
    };
}}}

namespace boost { namespace fusion { namespace extension
{
    template <>
    struct is_segmented_impl<flatten_view_tag>
    {
        template <typename Sequence>
        struct apply : mpl::true_ {};
    };
    
    template <>
    struct segments_impl<flatten_view_tag>
    {
        template <typename Sequence>
        struct apply
        {
            typedef
                transform_view<typename Sequence::sequence_type, detail::wrap_flatten>
            type;
    
            static inline
            type call(Sequence &seq)
            {
               return type(seq.seq, detail::wrap_flatten());
            }
       };
    };
}}}


#endif