Component bslmf_integersequence [Package bslmf]

Provide a template parameter pack of integers. More...

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::IntegerSequence

a compile-time sequence of integers

Description:

This component defines a class template, bslmf::IntegerSequence, which can be used in parameter pack expansions.

bslmf::IntegerSequence meets the requirements of the 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 t_U, class ...t_T>
     void read_impl(t_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 t_I and invokes the variadic template read method of the specified reader object.

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

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,
          bslmf::IntegerSequence<size_t, 0, 1, 2, 3, 4>());

Note that using a direct call to the bslmf::IntegerSequence constructor looks a bit clumsy here. The better approach is to use alias template bslmf::MakeIntegerSequence, that creates a collection of increasing integer values, having the specified t_N-value length. The usage example in that component shows this method more clearly. But we can not afford its presence here to avoid a cycle/levelization violation.

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