Ticket #4436: tie.hpp

/*
 * $Rev: 6074 $
 * 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