29,217d28
< 
< //this should probably go to boost/tuple/tuple.hpp
< namespace boost { namespace tuples{
< 
<   template<int I, class...Args>
<   struct element<I, std::tuple<Args...> > {
<     typedef typename std::tuple_element<I, std::tuple<Args...> >::type type;
<   };
<   
< }}
< 
< 
< //helper classes to work with std::tuple
< namespace helper {
< 
<   //get head of std::tuple
<   template<class T> struct head{
<     typedef decltype( std::get<0>( std::declval<T>() ) ) type;
<   };
< 
<   //get tail of std::tuple
<   template<class T> struct tail{ typedef std::tuple<> type; };
< 
<   //specialisations allow for perfect forwarding
<   template<class T, class... Args>
<   struct tail< std::tuple<T, Args...>& >{
< 
<     typedef typename std::conditional<
<       sizeof...(Args) == 0,
<       std::tuple<>,
<       std::tuple<Args...>&
<     >::type type;
<   };
< 
<   template<class T, class... Args>
<   struct tail< std::tuple<T, Args...> const& >{
<     typedef typename std::conditional<
<       sizeof...(Args) == 0,
<       std::tuple<>,
<       std::tuple<Args...> const&
<     >::type type;
<   };
< 
<   template<class T, class... Args>
<   struct tail< std::tuple<T, Args...>&& >{
<     typedef typename std::conditional<
<       sizeof...(Args) == 0,
<       std::tuple<>,
<       std::tuple<Args...> &&
<     >::type type;
<   };
< 
<   
<   //concatenate 2 tuples
<   template<class Tuple1, class Tuple2> struct concat {
< 
<     typedef decltype( std::tuple_cat(std::declval<Tuple1>(),
<                                      std::declval<Tuple2>()) )  type;
<   
<     inline static type call(Tuple1&& t1, Tuple2&& t2) {
<       return std::tuple_cat( std::forward<Tuple1>(t1),
<                              std::forward<Tuple2>(t2) );
<     }
<   };
< 
< 
<   //wrap mpl meta function to allow return type derivation via decltype
<   template<class F>
<   struct wrap {
<     typedef typename boost::mpl::lambda<F>::type Lambda;
<     
<     
<     template<class... Args>
<     struct result {
<       typedef typename Lambda::template apply<Args...>::type type;
<     };
<     
<     template<class... Args>
<     typename result<Args...>::type operator()(Args...)
<     {
<       return std::declval< typename result<Args...>::type >();
<     }
<   };
<   
<   
< 
<   // Apply unary functor to each member of tuple
<   template<class F,
<            class Tuple,
<            class Output= std::tuple<> >
<   struct apply
<   {
<     typedef typename std::result_of<F(typename head<Tuple>::type)>::type
<                      result_type;
<     
<     typedef apply< F,
<                    typename tail<Tuple>::type,
<                    typename concat<Output,
<                                    std::tuple<result_type> >::type > next;
<     
<     typedef typename next::type type;
<   
< 
<     //function to implemnt the apply functionality
<     template<int I=0, class T>
<     static typename apply<F, Tuple>::type
<     call(F f, T&& in)
<     {
<       return concat <
<                std::tuple<result_type>,
<                typename apply<
<                  F,
<                  typename tail<Tuple>::type
<                >::type
<              >::call( std::tuple<result_type>( f( std::get<I>( std::forward<T>(in) ))),
<                       next::template call<I+1>(f, std::forward<T>(in) ) );
<     }
<   };
<   
<   //Specialisation for empty tuples
<   template<class F, class Output>
<   struct apply< F, std::tuple<>, Output>
<   {
<     typedef Output type;
<   
<     template<int I=0, class T>
<     inline static typename std::tuple<> call(F, T) { return std::tuple<>(); }
<   };
<   
<   //Successively apply binary operator to tuple members
<   template<class Tuple,
<            class Op,
<            class State >
<   struct accumulate
<   {
<     typedef typename std::result_of<Op(typename head<Tuple>::type,
<                                        State)>::type               result_type;
<     
<     
<     typedef accumulate< typename tail<Tuple>::type,
<                         Op,
<                         result_type > next;
<     
<     typedef typename next::type type;
<   
<     template<int I=0, class T>
<     static type call(T&& in, Op op, State state)
<     {
<       return next::template call<I+1>(std::forward<T>(in),
<                                       op,
<                                       op( std::get<I>(std::forward<T>(in)),
<                                           state ) );
<     }
<   };//accumulate
<   
<   //Specialisation for empty tuple
<   template<class Op,
<            class State >
<   struct accumulate< std::tuple<>, Op, State>
<   {
<     typedef State type;
<   
<     template<int I=0, class T>
<     static type call(T, Op, State state) { return state; }
<   };
<   
<   
<   //for each specialisation for std::tuples
<   template<size_t I = 0, typename F, typename Tuple>
<   inline typename std::enable_if< I == std::tuple_size<Tuple>::value, F>::type
<   for_each(Tuple&, F f){ return f; }
<   
<   template<size_t I = 0, typename F, typename Tuple>
<   inline typename std::enable_if< I != std::tuple_size<Tuple>::value, F>::type
<   for_each(Tuple& t, F f)
<   {
<       f( std::get<I>(t) );
<       return for_each<I+1>(t, f);
<   }
<   
< 
< 
< }//namespace helper
< 
< 
< 
< 
< 
< 
325,348d135
< 
<       // Specialisation for std::tuple
<       template<class... Args, class UnaryMetaFun>
<       struct tuple_meta_transform< std::tuple<Args...>, UnaryMetaFun>
<       {
<          typedef typename helper::apply< helper::wrap<UnaryMetaFun>,
<                                          std::tuple<Args...> const& >::type type;
<       };
<     
<       // Specialisation for std::pair
<       template<class T1, class T2, class UnaryMetaFun>
<       struct tuple_meta_transform< std::pair<T1, T2>, UnaryMetaFun>
<       {
<         typedef std::pair<
<           typename mpl::apply1<
<             typename mpl::lambda<UnaryMetaFun>::type
<             , T1
<           >::type
<         , typename mpl::apply1<
<             typename mpl::lambda<UnaryMetaFun>::type
<           , T1
<           >::type
<         > type;
<       };
400,435d186
<       // specialisation for std::tuples
<       template<class... Args, class BinaryMetaFun, typename StartType>
<       struct tuple_meta_accumulate< std::tuple<Args...>,
<                                     BinaryMetaFun,
<                                     StartType >
<       {
<         typedef typename helper::accumulate<
<           std::tuple<Args...>,
<           helper::wrap<BinaryMetaFun>,
<           StartType
<         >::type type;
<       };
< 
<       // specialisation for std::pair
<       template<
<           typename T1
<         , typename T2
<         , class BinaryMetaFun
<         , typename StartType
<       >
<       struct tuple_meta_accumulate_impl< std::pair<T1, T2>,
<                                         BinaryMetaFun,
<                                         StartType >
<       {
<          typedef typename mpl::apply2<
<            typename mpl::lambda<BinaryMetaFun>::type,
<            mpl::identity<StartType>,
<            typename mpl::apply2<
<              typename mpl::lambda<BinaryMetaFun>::type,
<              T1,
<              T2
<            >::type
<          >::type type;
<       };
< 
<       
469,470c220,224
<       namespace detail{
<       
---
>       template<typename Fun>
>       tuples::null_type BOOST_TUPLE_ALGO(tuple_transform)
>           (tuples::null_type const&, Fun BOOST_TUPLE_ALGO_TERMINATOR)
>       { return tuples::null_type(); }
> 
472,476c226,236
<       struct tuple_transform_impl {
<         
<         static typename tuple_meta_transform<Tuple, Fun>::type
<         BOOST_TUPLE_ALGO(call)(const Tuple& t, Fun f BOOST_TUPLE_ALGO_RECURSE )
<         { 
---
>       typename tuple_meta_transform<
>           Tuple
>         , Fun
>       >::type
>       
>       BOOST_TUPLE_ALGO(tuple_transform)(
>         const Tuple& t, 
>         Fun f
>         BOOST_TUPLE_ALGO_RECURSE
>       )
>       { 
481,492c241,250
<   
<           return tuples::cons<
<               BOOST_DEDUCED_TYPENAME mpl::apply1<
<                   Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type
<                >::type
<              , transformed_tail_type
<           >( 
<               f(boost::tuples::get<0>(t)),
<               tuple_transform_impl<BOOST_DEDUCED_TYPENAME Tuple::tail_type,
<                                    Fun>::call( t.get_tail(), f)
<           );
<         }
---
> 
>         return tuples::cons<
>             BOOST_DEDUCED_TYPENAME mpl::apply1<
>                 Fun, BOOST_DEDUCED_TYPENAME Tuple::head_type
>              >::type
>            , transformed_tail_type
>         >( 
>             f(boost::tuples::get<0>(t)), tuple_transform(t.get_tail(), f)
>         );
>       }
495,499c253,265
<         static typename tuple_meta_transform<Tuple, Fun>::type
<         call(const Tuple& t, Fun f)
<         {
<           return call_impl(t, f, 1);
<         }
---
>       template<typename Tuple, typename Fun>
>       typename tuple_meta_transform<
>           Tuple
>         , Fun
>       >::type
>       
>       tuple_transform(
>         const Tuple& t, 
>         Fun f
>       )
>       {
>           return tuple_transform_impl(t, f, 1);
>       }
501,542d266
<       };//tuple_transform_impl
< 
< 
<       template<typename Fun>
<       struct tuple_transform_impl<tuples::null_type, Fun> {
<         
<         static tuples::null_type
<         BOOST_TUPLE_ALGO(call)(tuples::null_type const&,
<                                Fun BOOST_TUPLE_ALGO_TERMINATOR)
<         {
<           return tuples::null_type();
<         }
<       };
<       
<       
<       // specialisation for std::tuples
<       template<typename...Args, typename Fun>
<       struct tuple_transform_impl <std::tuple<Args...>, Fun> {
<       
<         template<class T>
<         inline static
<         typename tuple_meta_transform< std::tuple<Args...>, Fun>::type
<         call(T&& t, Fun f )
<         { 
<           return helper::apply<Fun, T&&>::template call<0>(f, std::forward<T>(t) );
<         }
<       };
< 
<       //specialisation for std::pair      
<       template<typename T1, typename T2, typename Fun>
<       struct tuple_transform_impl< std::tuple<T1, T2>, Fun> {
<         
<         static typename tuple_meta_transform<std::tuple<T1, T2>, Fun>::type
<         call(const std::tuple<T1, T2>& t, Fun f)
<         { 
<           typedef typename tuple_meta_transform<std::tuple<T1, T2>, Fun>::type
<                    return_type;
<           
<           return return_type( f(t.first), f(t.second) );
<         }
<       };
<       
545a270,277
>       template<typename Fun>
>       Fun BOOST_TUPLE_ALGO(tuple_for_each)(
>           tuples::null_type
>         , Fun f BOOST_TUPLE_ALGO_TERMINATOR
>       )
>       { return f; }
> 
>       
547,549c279,282
<       struct tuple_for_each_impl {
<         static Fun BOOST_TUPLE_ALGO(call)( Tuple& t, Fun f BOOST_TUPLE_ALGO_RECURSE)
<         { 
---
>       Fun BOOST_TUPLE_ALGO(tuple_for_each)(
>           Tuple& t
>         , Fun f BOOST_TUPLE_ALGO_RECURSE)
>       { 
551,554c284,286
<           return tuple_for_each_impl<typename Tuple::tail_type,
<                                      Fun>::call( t.get_tail(), f);
<         }
< 
---
>           return tuple_for_each(t.get_tail(), f);
>       }
>       
556c288,293
<       static Fun call(Tuple& t, Fun f)
---
>       template<typename Tuple, typename Fun>
>       Fun
>       tuple_for_each(
>         Tuple& t, 
>         Fun f
>       )
558c295
<           return call_impl(t, f, 1);
---
>           return tuple_for_each_impl(t, f, 1);
561,595d297
<       };
< 
<       template<typename Fun>
<       struct tuple_for_each_impl<tuples::null_type, Fun> {
<         inline static Fun call( tuples::null_type,
<                                 Fun f BOOST_TUPLE_ALGO_TERMINATOR)
<         { 
<           return f;
<         }
<       };
<       
< 
<       // for_each algorithm for std::tuple
<       template<typename... Args , typename Fun>
<       struct tuple_for_each_impl< std::tuple<Args...>, Fun> {
< 
<         inline static Fun call(std::tuple<Args...>& t, Fun f)
<         { 
<           return helper::for_each(t, f);
<         }
<       
<       };
< 
<       // for_each algorithm for std::pair
<       template<typename T1, typename T2 , typename Fun>
<       struct tuple_for_each_impl< std::pair<T1, T2>, Fun> {
< 
<         inline static Fun call(std::pair<T1, T2>& t, Fun f)
<         { 
<           f(t.first);
<           f(t.second);
<           return f;
<         }
<       
<       };
602,656c304,305
<       template<typename Tuple1, typename Tuple2>
<       struct tuple_equal_impl{
<         static bool call(const Tuple1& t1, const Tuple2& t2){
<           return t1.get_head() == t2.get_head() && 
<           tuple_equal(t1.get_tail(), t2.get_tail());
<         }
<       };
<       
<       template<>
<       struct tuple_equal_impl<tuples::null_type, tuples::null_type> {
<         inline static bool call(tuples::null_type, tuples::null_type){
<           return true;
<         }
<       };
<       
<       // Equality of std::tuples.
<       template<class... Args1, class... Args2>
<       struct tuple_equal_impl< std::tuple<Args1...>, std::tuple<Args2...> > {
<           
<         inline static bool call( const std::tuple<Args1...>& t1,
<                                  const std::tuple<Args2...>& t2 )
<         {
<             return t1 == t2;
<         }
<       };
<       
<       // Equality of std::pair
<       template<class T1, class T2, class U1, class U2>
<       struct tuple_equal_impl< std::pair<T1, T2>, std::pair<U1, U2> > {
<           
<         inline static bool call( const std::pair<T1, T2>& t1,
<                                  const std::pair<U1, U2>& t2 )
<         {
<             return t1 == t2;
<         }
<       };
< 
<       }//namespace detail
<       
< 
<       //Forward template functions to respective implementations
<       
<       template<class Tuple, class Fun>      
<       inline typename tuple_meta_transform<Tuple, Fun>::type
<       tuple_transform(const Tuple& t, Fun f)
<       { 
<         return detail::tuple_transform_impl<Tuple, Fun>::call(t, f);
<       }
< 
<       
<       template<typename Tuple, typename Fun>
<       inline Fun tuple_for_each(Tuple& t, Fun f)
<       { 
<         return detail::tuple_for_each_impl<Tuple, Fun>::call(t, f);
<       }
---
>       inline bool tuple_equal(tuples::null_type, tuples::null_type)
>       { return true; }
659c308,311
<       inline bool tuple_equal(Tuple1 const& t1, Tuple2 const& t2)
---
>         bool tuple_equal(
>             Tuple1 const& t1, 
>             Tuple2 const& t2
>         )
661c313,314
<         return detail::tuple_equal_impl<Tuple1, Tuple2>::call(t1, t2);
---
>           return t1.get_head() == t2.get_head() && 
>           tuple_equal(t1.get_tail(), t2.get_tail());