Conditional Macros or expanding templates - c++

Question

I have a templated struct like this:
class Context {
template<typename T>
T construct();
};
template<typename T, typename ...Args>
struct aggregate {
T construct(Context& ctx) {
return { std::move(ctx.construct<Args>())... };
}
};
The problem with this is easy to see: When a user requests uses it like this:
typedef struct {
float xyz[3];
} Vector3;
using ConstructVector = aggregate<Vector3, float[3]>;
Here an error is generated because this would call the templated function Context.construct with T = float[3] resulting in a function returning an array. What I thus want is some way to expand { std::move(ctx.construct<Args>())... } to this: {{ std::move(ctx.construct<float>()), std::move(ctx.construct<float>()), std::move(ctx.construct<float>()) }} or more general, any array of type T (with constexpr size N) should be extended to a construct repeating std::move(ctx.construct<T>()) exactly N times and should be wrapped in an additional pair of {}.
Is this a wrong approach? Is there another way to initialize an array of values in an aggregate statement?
I get the following error from g++ (4.9.1):
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/utilitysupplier.hpp: In instantiation of 'typename io::Supplier<T>::item_t io::utility::aggregate_supplier<T, args>::supply(io::Context&) const [with T = Vector3; args = float [3]; typename io::Supplier<T>::item_t = Vector3]':
../test/main.cpp:185:1: required from here
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/utilitysupplier.hpp:42:37: error: no matching function for call to 'io::Context::construct()'
return { ctx.construct<args>()... };
^
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/utilitysupplier.hpp:42:37: note: candidate is:
In file included from C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Context.hpp:141:0,
from C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Reader.hpp:13,
from C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Environment.hpp:12,
from ../test/main.cpp:14:
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Context.tpp:37:28: note: template<class T> typename io::supply_t<T>::type io::Context::construct()
typename supply_t<T>::type Context::construct() {
^
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Context.tpp:37:28: note: template argument deduction/substitution failed:
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Context.tpp: In substitution of 'template<class T> typename io::supply_t<T>::type io::Context::construct() [with T = float [3]]':
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/utilitysupplier.hpp:42:37: required from 'typename io::Supplier<T>::item_t io::utility::aggregate_supplier<T, args>::supply(io::Context&) const [with T = Vector3; args = float [3]; typename io::Supplier<T>::item_t = Vector3]'
../test/main.cpp:185:1: required from here
C:\Users\Carbon\Documents\CreativeWorkspace\EpicRPG\SmartIO/smartio/Context.tpp:37:28: error: function returning an array

Answer 1

Generating a nested braced-init list is impossible, but generating a flatten one is possible and is suitable for aggregate.
The approach shown below uses C++14 though, with the help of std::make_index_sequence, but you can implement such a thing in C++11 as well:
template<class... Ts>
struct list;
template<class A, class B>
struct merge;
template<class... As, class... Bs>
struct merge<list<As...>, list<Bs...>>
{
using type = list<As..., Bs...>;
};
template<std::size_t N, class T>
using just = T;
template<class T, class Index>
struct repeat_impl;
template<class T, std::size_t... Ns>
struct repeat_impl<T, std::index_sequence<Ns...>>
{
using type = list<just<Ns, T>...>;
};
template<class T, int N>
using repeat = typename repeat_impl<T, std::make_index_sequence<N>>::type;
template<class T>
struct to_list
{
using type = list<T>;
};
template<class T, int N>
struct to_list<T[N]>
{
using type = repeat<T, N>;
};
template<class... Ts>
struct flatten;
template<>
struct flatten<>
{
using type = list<>;
};
template<class T, class... Ts>
struct flatten<T, Ts...>
{
using type = typename merge<typename to_list<T>::type, typename flatten<Ts...>::type>::type;
};
flatten<float[3], int[2]>::type will return you list<float, float, float, int, int, int>.
Now we can implement aggregate as below:
struct Context
{
template<typename T>
T construct();
};
template<class T, class List>
struct aggregate_impl;
template<class T, class... Args>
struct aggregate_impl<T, list<Args...>>
{
static T construct(Context& ctx)
{
return {ctx.construct<Args>()...};
}
};
template<class T, class... Args>
using aggregate = aggregate_impl<T, typename flatten<Args...>::type>;
Now you can do:
using ConstructVector = aggregate<Vector3, float[3]>;
Context ctx;
ConstructVector::construct(ctx);
LIVE DEMO