Creating an array initializer from a tuple or variadic template parameters

by

In order for compile time accumulation to occur, you have to have a compile time sequence.

An easy way to do this would be to use variadic templates. Each entry would be an identifier and a size of a particular element, or the identifier and type of a particular element.

The top level bundle of entries would be a Layout:

template<std::size_t offset, typename Key, typename... Entries>
struct LayoutHelper {
  typedef std::tuple<> type;
};
template<typename Key, typename... Entries>
struct Layout:LayoutHelper<0, Key, Entries...> {};

Each entry would be:

template<typename Key, Key identifier, typename Data>
struct Entry {};

Then, we do something like this:

template<typename Key, Key identifier, typename Data, std::size_t Offset>
struct ProcessedEntry {};

template<std::size_t offset, typename Key, Key id0, typename D0, typename... Entries>
struct LayoutHelper<offset, Key, Entry<Key, id0, D0>, Entries...>
{
    typedef typename prepend
        < ProcessedEntry< Key, id0, D0, offset >
        , typename LayoutHelper<offset+sizeof(D0), Key, Entries...>::type
        >::type type;
};

Use would look like:

Layout< FooEnum, Entry< FooEnum, eFoo, char[10] >, Entry< FooEnum, eFoo2, double > > layout;

which, after writing or finding a prepend that takes an element and a tuple, and prepends the element at the front, would mean that Layout<blah>::type would contain a tuple that describes the layout of your data.

template<typename T, typename Pack>
struct prepend;
template<typename T, template<typename...>class Pack, typename... Ts>
struct prepend<T, Pack<Ts...>> {
  typedef Pack<T, Ts...> type;
};
// use: prepend<int, std::tuple<double>::type is std::tuple<int, double>
// this removes some ::type and typename boilerplate, if it works in your compiler:
template<typename T, typename Pack>
using Prepend = typename prepend<T, Pack>::type;

You’d then unpack that tuple into a std::array if you wanted. You’d use the indexes trick to do this (there are many examples on stack overflow that use this same trick in different ways).

Or, you could take your ProcessedEntry and add in methods to access data, then write a Key searching compile-time program that walks the tuple, looking for the matching Key, and then returns the offset and size (or even type) as compile time code. Maybe take an array<N, unsigned char> as an argument and do the reintepret_cast, returning a reference-to-data.

Removing the repeated FooEnum would be good via using aliases.

More Related Contents:

  1. How can you iterate over the elements of an std::tuple?
  2. Checking a member exists, possibly in a base class, C++11 version
  3. How to make generic computations over heterogeneous argument packs of a variadic template function?
  4. void_t “can implement concepts”?
  5. C++11 “overloaded lambda” with variadic template and variable capture
  6. TMP: how to generalize a Cartesian Product of Vectors?
  7. constexpr initialization of array to sort contents
  8. Generating one class member per variadic template argument
  9. “What happened to my SFINAE” redux: conditional template class members?
  10. Concatenate compile-time strings in a template at compile time?
  11. Difference between std::function and a standard function pointer? [duplicate]
  12. What is the recommended way to align memory in C++11
  13. “to_string” isn’t a member of “std”?
  14. using SFINAE for template class specialisation
  15. How can I pass a C++ lambda to a C-callback that expects a function pointer and a context?
  16. Timeout for thread.join()
  17. I want to kill a std::thread using its thread object? [duplicate]
  18. What expressions create xvalues?
  19. Why does the template-id in “A=0” not compile without space because of the greater-or-equal-than operator “>=”?
  20. What’s the standard/official name for universal references?
  21. Is Visual Studio 2013 optimizing correctly in the presence of /OPT:ICF?
  22. thread safety of MPI send using threads created with std::async
  23. Overloading on R-value references and code duplication
  24. Visual Studio 2008 with c++11
  25. Regex not working as expected with C++ regex_match
  26. Unable to print the value of nullptr on screen
  27. Need iterator when using range-based for loops
  28. Can using a lambda in header files violate the ODR?
  29. template parameter packs access Nth type and Nth element
  30. Can the ‘type’ of a lambda expression be expressed?

Leave a Comment