/*
 * $Rev: 6060 $
 * Author: Jesse Perla (c) 2010
 * Use, modification and distribution are subject to 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)
*/

#pragma once
#include <boost/numeric/ublas/vector_expression.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>

#ifndef BOOST_ASSIGN_MAX_SIZE
#	define  BOOST_ASSIGN_MAX_SIZE 20
#endif

namespace boost{ namespace numeric { namespace ublas {

	//Using dispatching to ensure no assignment happens with boost::mpl::void_ types.
	template<std::size_t Index, typename T> struct assign_helper;
	template<std::size_t Index, typename T> struct assign_helper
	{
		template<typename Vector> //Assigns a member of a vector to t1
		void assign(T& t1, const Vector& v)
		{
			t1 = v[Index]; //Assumes assignable between types.  Accessing the static index within the vector expression.
		}		
	};

	template<std::size_t Index>
	struct assign_helper<Index, boost::mpl::void_>
	{
		template<typename T1, typename Vector>
		void assign(T1& t1, const Vector& t2)
		{ //Does nothing.  This is an mpl::void_
		}
	};

	//Object used to tie the references to the objects prior to assignment.
	template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ASSIGN_MAX_SIZE, typename T, boost::mpl::void_)>
	struct tie_helper
	{
		//Generate something like:
		//T0& t0_;
		//T1& t1_;

#define UBLAS_ASSIGN_DATA_MEMBER(z, n, unused) T##n & t##n##_; \

		BOOST_PP_REPEAT(BOOST_ASSIGN_MAX_SIZE, UBLAS_ASSIGN_DATA_MEMBER, ~)

		//Constructor stores references.  Is this kosher for creating with boost::mpl::void_ objects as default arguments then keeping references to them?  Seems to compile.
		//Generating something like:
		//tie_helper(T0& t0 = T0(), T1& t1 = T1(), T2& t2 = T2()) : t0_(t0), t1_(t1), t2_(t2) {};

#define UBLAS_ASSIGN_CONSTRUCTOR_ARGUMENTS(z, n, unused)  BOOST_PP_COMMA_IF(n) T##n & t##n = T##n ()
#define UBLAS_ASSIGN_CONSTRUCTOR_INITIALIZATION(z, n, unused)  BOOST_PP_COMMA_IF(n) t##n##_ ( t##n  )

		tie_helper(BOOST_PP_REPEAT(BOOST_ASSIGN_MAX_SIZE, UBLAS_ASSIGN_CONSTRUCTOR_ARGUMENTS, ~)) : BOOST_PP_REPEAT(BOOST_ASSIGN_MAX_SIZE, UBLAS_ASSIGN_CONSTRUCTOR_INITIALIZATION, ~)
		{};

		//Assignment
		template<typename VectorT>
		void operator= (const ublas::vector_expression<VectorT>& v)
		{
			//Instead of assigning directly, this is using the assign_helper dispatcher to prevent assignment for boost::mpl::void_ types.
			//Generate something like:
			//assign_helper<T0>().assign(t0_, v(), 0);
			//assign_helper<T1>().assign(t1_, v(), 1);

#define UBLAS_ASSIGN_ASSIGN_VALUE(z, n, unused) assign_helper<n, T##n##>().assign(t##n##_, v()); \

		BOOST_PP_REPEAT(BOOST_ASSIGN_MAX_SIZE, UBLAS_ASSIGN_ASSIGN_VALUE, ~)
		}
	};


//Generate constuction functions such as:
//template<typename T0, typename T1>
//tie_helper<T0, T1> tie(T0& t0, T1& t1)
//{
//	return tie_helper<T0, T1>(t0, t1);
//}

#define UBLAS_ASSIGN_HELPER(z, n, unused) \
	template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
	tie_helper<BOOST_PP_ENUM_PARAMS(n, T)> tie(BOOST_PP_ENUM_BINARY_PARAMS(n, T, & t)) \
	{ \
		return tie_helper<BOOST_PP_ENUM_PARAMS(n, T)>(BOOST_PP_ENUM_PARAMS(n, t)); \
	}


//Vertical repetition
#define BOOST_PP_LOCAL_MACRO(n) UBLAS_ASSIGN_HELPER(~, n, ~)
#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_SIZE)

#include BOOST_PP_LOCAL_ITERATE()

} } }

//Remove local macros
#undef UBLAS_ASSIGN_DATA_MEMBER
#undef UBLAS_ASSIGN_CONSTRUCTOR_ARGUMENTS
#undef UBLAS_ASSIGN_CONSTRUCTOR_INITIALIZATION
#undef UBLAS_ASSIGN_ASSIGN_VALUE
#undef UBLAS_ASSIGN_HELPER