bslmf_makeintegersequence

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Pass C-array as a parameter to a function with variadic template

Purpose

Provide a template parameter pack of integers.

Classes

• bslmf::MakeIntegerSequence: compile-time integer sequence factory function

Description

This component defines a factory function bslmf::MakeIntegerSequence that generate a compile-time sequence of increasing integer values starting with 0.

bslmf::MakeIntegerSequence meets the requirements of the make_integer_sequence template introduced in the C++14 standard [intseq.intseq] and can be used in a client's code if the compiler supports the C++11 standard.

Note, that this component has no (emulated) support for pre-standard C++11 compilers, as its only purpose is to be used in deduction with template parameter packs. There is no language support to emulate in earlier compilers.

Usage

In this section we show intended use of this component.

Example 1: Pass C-array as a parameter to a function with variadic template

Suppose we want to initialize a C-Array of known size t_N with data read from a data source using a library class that provides a variadic template interface that loads a data of variable length into the supplied parameter pack.

First, define a class template DataReader,

template <std::size_t t_N>
class DataReader {
  public:

Then, implement a method that loads the specified parameter pack args with data read from a data source.

   template <class ...t_T>
   void read(t_T*... args) const
   {
       static_assert(sizeof...(args) == t_N, "");
       read_impl(args...);
   }

Next, for the test purpose provide simple implementation of the recursive variadic read_impl function that streams the index of the C-Array's element to stdout.

private:
    template <class U, class ...t_T>
    void read_impl(U*, t_T*... args) const
    {
        printf("read element #%i\n",
               static_cast<int>(t_N - 1 - sizeof...(args)));
        read_impl(args...);
    }

Then, implement the recursion break condition.

   void read_impl() const
   {
   }
};

Next, define a helper function template readData that expands the parameter pack of indices I and invokes the variadic template read method of the specified reader object.

namespace {
template<class R, class t_T, std::size_t... I>
void readData(const R&  reader,
              t_T      *data,
              bslmf::IntegerSequence<std::size_t, I...>)
{
    reader.read(&data[I]...);
        // In pseudocode, this is equivalent to:
        // reader.read(&data[0],
        //             &data[1],
        //             &data[2],
        //             ...
        //             &data[t_N-1]);
}
}

Now, define function template readData that invokes the helper function Note, that the bslmf::MakeIntegerSequence<std::size_t, t_N> function generates an object of an integer sequence class instantiated with a template parameter pack of integers that will be expanded and used as an array's indices in the helper function when calling the Reader::read(t_T*...) variadic template function.

template<class t_T, std::size_t t_N>
void readData(const DataReader<t_N>& reader, t_T *data)
{
    readData(reader, data, bslmf::MakeIntegerSequence<std::size_t, t_N>());
}

Finally, define a data C-Array and reader variables and pass them to the readData function as parameters.

constexpr int      k_SIZE = 5;
DataReader<k_SIZE> reader;
int                data[k_SIZE] = {0};
 
readData(reader, data);

The streaming operator produces output in the following format on stdout:

read element #0
read element #1
read element #2
read element #3
read element #4