[Boost-users] [fusion] deduce type of resulting vector from a transformation

Subject: [Boost-users] [fusion] deduce type of resulting vector from a transformation
From: alfC (alfredo.correa_at_[hidden])
Date: 2010-10-10 06:02:02

Hi,

 (I keep struggling with Boos.Fusion.)

 How do I deduce the type of the vector resulting from the
transformation of another vector?

I have a source vector of different types, e.g.
vector<quantity<si::length>, quantity<si::mass>, 	quantity<si::time>
>

and I have a transformation that is well defined and returns another
type depending on the original type.
The question is how do I generate a vector type that is the result of
the given transformation. I though that
result_of::transform was the function to obtain the result but it
turns not because it returns a type transform_view instead of a
vector.

vector< ... > v1;
T? v2(transform(v1, transformation()));

i.e. what is the type of T as a fusion::vector as deduced from the
type of v1 and the transformation type? -- Thank you,    Alfredo--

Below is the illustrative code:

#include<boost/array.hpp>
#include <boost/fusion/container.hpp>
#include <boost/fusion/algorithm/transformation/zip.hpp>
#include <boost/units/systems/si.hpp>
#include<iostream>
using std::clog; using std::endl;

using namespace boost::fusion;
using namespace boost::units;

// this is the transformation
struct divide{
        template <typename SignatureT> struct result;
        template<class Q>
        struct result<divide(Q const&)>{
                typedef typename divide_typeof_helper<Q, quantity<si::time> >::type
type;
        };
        template<typename Q>
        typename result<divide(Q const&)>::type
                operator()(Q const& q) const
        {
                return q/quantity<si::time>(1.*si::second);
        }
};

int main(){
        typedef
                vector<
                        quantity<si::length>,
                        quantity<si::mass>,
                        quantity<si::time>
		>
                source_type
        ;
        source_type v1(1.*si::meter, 2.*si::kilogram, 3.*si::second);
        clog << "v1: " << at_c<0>(v1) << ", "<< at_c<1>(v1) << ", " <<
at_c<2>(v1) << endl;

        // how can I deduce the result_type from the type "divide"?
        // here manually defined
        typedef
                vector<
                        divide_typeof_helper<quantity<si::length>, quantity<si::time>
>::type,
                        divide_typeof_helper<quantity<si::mass>, quantity<si::time>
>::type,
                        divide_typeof_helper<quantity<si::time>, quantity<si::time> >::type
		> result_type
        ;

        result_type v2(
                boost::fusion::transform(v1, divide() )
        );

        clog << "v2: " << at_c<0>(v2) << ", "<< at_c<1>(v2) << ", " <<
at_c<2>(v2) << endl;

        return 0;
}