#ifndef NIO_PLAY_FUSION_STD_TUPLE
#define NIO_PLAY_FUSION_STD_TUPLE

// Adapting the MS STL 2010 tuple to Fusion

#include <tuple>
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/iterator/iterator_facade.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/int.hpp>

namespace boost {
	namespace fusion {
		struct std_tuple_tag;
		struct fusion_sequence_tag;
	    struct forward_traversal_tag;

		namespace detail {
			template <typename T> T&& declval();
		}

		template <typename T, unsigned I, unsigned N = std::tuple_size<T>::value>
		struct std_tuple_iterator : iterator_facade<
			std_tuple_iterator<T, I, N>,
			forward_traversal_tag>
		{
			typedef T tuple_type;
			static const unsigned index = I;
			T& tup;
			explicit std_tuple_iterator(T& in) : tup(in) {}

			template <typename Iterator>
			struct value_of : std::tuple_element<I, T> {};

			template <typename Iterator>
			struct deref {
				typedef decltype(std::get<I>(detail::declval<typename Iterator::tuple_type&>())) type;

				static type call(Iterator const& iter) {
					return std::get<I>(iter.tup);
				}
			};

			template <typename Iterator>
			struct next {
				typedef std_tuple_iterator<T, I+1, N> type;

				static type call(Iterator const& iter) {
					return type(iter.tup);
				}
			};

			template<typename I1, typename I2>
			struct distance {
				typedef boost::mpl::int_<I2::index - I1::index> type;
				static type call(const I1&, const I2&) { return type(); }
			};

			std_tuple_iterator& operator =(const std_tuple_iterator&);
		};
		template <typename T, unsigned X>
		struct std_tuple_iterator<T, X, X> : iterator_facade<
			std_tuple_iterator<T, X, X>, forward_traversal_tag>
		{
			typedef T tuple_type;
			explicit std_tuple_iterator(T&) {}
		};

		namespace traits
		{
			template <typename T0, typename T1, typename T2, typename T3, typename T4,
				typename T5, typename T6, typename T7, typename T8, typename T9>
			struct tag_of<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>
			{
				typedef std_tuple_tag type;
			};
		}

		namespace extension
		{
			template<typename Tag>
			struct is_view_impl;
			template<typename Tag>
			struct is_sequence_impl;
			template<typename T>
			struct category_of_impl;
			template<typename T>
			struct begin_impl;
			template<typename T>
			struct end_impl;
			template<typename T>
			struct size_impl;
			template<typename T>
			struct at_impl;
			template<typename T>
			struct value_at_impl;

			template<>
			struct is_view_impl<std_tuple_tag> {
				template<typename T>
				struct apply : mpl::false_ {};
			};
			template<>
			struct is_sequence_impl<std_tuple_tag> {
				template<typename Sequence>
				struct apply : mpl::true_ {};
			};
			template<>
			struct category_of_impl<std_tuple_tag> {
				template<typename T>
				struct apply {
					typedef forward_traversal_tag type;
				};
			};
			template <>
			struct begin_impl<std_tuple_tag> {
				template <typename Sequence>
				struct apply {
					typedef std_tuple_iterator<Sequence, 0> type;
					static type call(Sequence& v) {
						return type(v);
					}
				};
			};
			template <>
			struct end_impl<std_tuple_tag> {
				template <typename Sequence>
				struct apply {
					typedef std_tuple_iterator<Sequence, std::tuple_size<Sequence>::value> type;
					static type call(Sequence& v) {
						return type(v);
					}
				};
			};
			template <>
			struct size_impl<std_tuple_tag> {
				template <typename Sequence>
				struct apply : mpl::int_<std::tuple_size<Sequence>::value> {};
			};
			template <>
			struct at_impl<std_tuple_tag> {
				template <typename Sequence, typename N>
				struct apply {
					typedef decltype(std::get<N::value>(detail::declval<Sequence&>())) type;
					static type call(Sequence& seq) {
						return std::get<N::value>(seq);
					}
				};
			};
			template <>
			struct value_at_impl<std_tuple_tag> {
				template <typename Sequence, typename N>
				struct apply : std::tuple_element<N::value, Sequence> {};
			};
		}
	}
	namespace mpl {
		template <typename>
		struct sequence_tag;

		template <typename T0, typename T1, typename T2, typename T3, typename T4,
			typename T5, typename T6, typename T7, typename T8, typename T9>
		struct sequence_tag<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>>
		{
			typedef fusion::fusion_sequence_tag type;
		};
		template <typename T0, typename T1, typename T2, typename T3, typename T4,
			typename T5, typename T6, typename T7, typename T8, typename T9>
		struct sequence_tag<std::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> const>
		{
			typedef fusion::fusion_sequence_tag type;
		};
	}
}

#endif