BOOST_FUSION_ADAPT_TPL_STRUCT and template array size

Question

I am trying to iterate over a C++ template structure thanks to BOOST_FUSION_ADAPT_TPL_STRUCT. My structure contains fixed-size multidimensional arrays whose sizes are template parameters. If we consider Boost's example modified to fit my problem:

#include <iostream>
#include <string>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct.hpp>

// Example:
// http://www.boost.org/doc/libs/1_53_0/libs/fusion/doc/html/fusion/adapted/adapt_tpl_struct.html

namespace demo
{
    template<typename T, unsigned int SIZE1, unsigned int SIZE2, typename Name, typename Age>
    struct employee
    {
        Name name;
        Age age;
        T ar[SIZE1][SIZE2];
    };
}

// Any instantiated demo::employee is now a Fusion sequence
BOOST_FUSION_ADAPT_TPL_STRUCT(
    (T)(SIZE1)(SIZE2)(Name)(Age),
    (demo::employee) (T)(SIZE1)(SIZE2)(Name)(Age),
    (Name, name)
    (Age, age)
    (T, ar[SIZE1][SIZE2]))

int main()
{
    demo::employee<float, 2, 2, std::string, int> e;
    e.name = "Bob";
    e.age = 25;
    e.ar[0][0] = e.ar[1][0] = 0.1;
    e.ar[0][1] = e.ar[1][1] = 0.2;
}

The compilation fails. Moreover, it also fails if we only add an integer template parameter without even using it for the array size.

Is that even possible with BOOST_FUSION_ADAPT_TPL_STRUCT? If not, how should I go about this?

Answer 1

From doc:

The sequence (template_param0)(template_param1)... declares the names of the template type parameters used.

While you have non-type template parameter SIZE:

template<typename T, unsigned int SIZE, typename Name, typename Age>
struct employee

You may convert it to type template parameter and use boost::mpl::int_ as wrapper for carry size.

Now, your code is compiled.

template<int Size>
struct Array
{
    template<typename T>
    struct Of
    {
        typedef T type[Size];
    };
};

namespace demo
{
    template<typename T, typename SIZE, typename Name, typename Age>
    struct employee
    {
        Name name;
        Age age;
        T ar[SIZE::value];
    };
}

// Any instantiated demo::employee is now a Fusion sequence
BOOST_FUSION_ADAPT_TPL_STRUCT(
    (T)(SIZE)(Name)(Age),
    (demo::employee) (T)(SIZE)(Name)(Age),
    (Name, name)
    (Age, age)
    (typename Array<SIZE::value>::template Of<T>::type, ar))

 //...
 demo::employee<float, int_<2>, std::string, int> e;

Answer 2

After a long talk with Evgeny Panasyuk, I ended up doing something a bit different. Since I wanted to be able to do some simple arithmetic operations on the data structures, I decided to use Eigen::Map rather than Boost::multi_array since it offers a wide range of operators as well as a clear documentation.

Thus, the higher-level loop is handled by boost::fusion::for_each and the lower-level loops are handled by Eigen. The arrays are mapped linearly to Eigen vectors. The sizes are passed in data_eigen's constructor.

#include <iostream>

#include <boost/fusion/adapted/struct/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/bind.hpp>

#include <Eigen/Core>

namespace demo
{
template<typename T, int SIZE1, int SIZE2>
struct data
{
    T ar1[SIZE1][SIZE2];
    T ar2[SIZE1][SIZE2];
};

template<typename T>
struct EigenMap
{
    typedef Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> > type;
};

template<typename T>
struct data_eigen
{
    template <int SIZE1, int SIZE2>
    data_eigen(data<T,SIZE1,SIZE2>& src)
        : ar1(typename EigenMap<T>::type(&src.ar1[0][0], SIZE1*SIZE2)),
          ar2(typename EigenMap<T>::type(&src.ar2[0][0], SIZE1*SIZE2))
    {
    }

    typename EigenMap<T>::type ar1;
    typename EigenMap<T>::type ar2;
};


struct print
{
    template<typename T>
    void operator()(const Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1> >& t) const
    {
        std::cout << t.transpose() << std::endl;
    }
};

struct scalarMult
{
    template<typename T, typename U>
    void operator()(T& t, U& u) const
    {
        t *= u;
    }
};

}

BOOST_FUSION_ADAPT_TPL_STRUCT
(
    (T),
    (demo::data_eigen) (T),
    (typename demo::EigenMap<T>::type, ar1)
    (typename demo::EigenMap<T>::type, ar2)
)

int main()
{
    typedef float REALTYPE;
    const int SIZE1 = 2;
    const int SIZE2 = 2;

    // Basic data structure with multidimensional arrays
    demo::data<REALTYPE, SIZE1, SIZE2> d;
    for (unsigned int i = 0; i < SIZE1; ++i)
        for (unsigned int j = 0; j < SIZE2; ++j)
        {
            d.ar1[i][j] = (i+1)*(j+1);
            d.ar2[i][j] = i + j;
        }

    // Eigen::Map + BOOST_FUSION_ADAPT_TPL_STRUCT
    demo::data_eigen<REALTYPE> eig_d(d);

    std::cout << "d:" << std::endl;
    boost::fusion::for_each(eig_d, demo::print());
    std::cout << std::endl;

    boost::fusion::for_each(eig_d, boost::bind<void>(demo::scalarMult(), _1, 2.0));
    std::cout << "2 * d:" << std::endl;
    boost::fusion::for_each(eig_d, demo::print());
    std::cout << std::endl;
}