How to implement foreach () compilation for template methods?

Question

I want to implement foreach () compilation, which can call the template member function N times. I currently have time to compile:

struct ForEach
{
   template <size_t Dummy>
   struct IntToType {};

   typedef IntToType<true> ForEachDoNotTerminateLoop;
   typedef IntToType<false> ForEachTerminateLoop;

   template <size_t TIdx, size_t TCount, typename TMethod>
   static void ForEachImpl(ForEachDoNotTerminateLoop, TMethod method)
   {
      method.Invoke<TIdx>();
      ForEachImpl<TIdx + 1, TCount, TMethod>(Internal::IntToType<(TIdx + 1 < TCount)>(), method);
   }

   template <size_t TIdx, size_t TCount, typename TMethod>
   static void ForEachImpl(ForEachTerminateLoop, TMethod method)
   {
   }

   template <size_t TCount, typename TMethod>
   static void Member(TMethod method)
   {
      ForEachImpl<0, TCount, TMethod>(Internal::IntToType<(0 < TCount)>(), method);
   }
};

And some template class:

template <typename T, size_t TCount>
class SomeClass
{
public:
   void Foo(int arg1)
   {
      ForEach::Member<TCount>(BarInvoker(this, arg1));
   }

private:
   struct BarInvoker // <-- How can I make this invoker a template to make it more flexible?
   {
      BarInvoker(SomeClass* instance, int arg1)
         : instance(instance)
         , arg1(arg1)
      {}

      template <size_t N>
      void Invoke()
      {
         instance->Bar<N>(arg1);
      }

      int arg1;
      SomeClass* instance;
   };

   template <size_t N>
   void Bar(int arg1)
   {
      _data[N] = arg1;
   }

   int* _data;
   T* _otherData;
};

Is there a way around the invoker functor, make it more flexible (template) and easier to use? I don't really like to inflate my code by adding an "invoker" stub for each of my private member functions. It would be great just to callForEach::Member<TCount, int>(Bar, 5);

Thanks in advance for helping me with this oddity! :)

Answer 1

ForEach:: Call < > .

ForEach::Call<> : ForEach::Call<N>(function_object, arguments...)

function_object - , operator(), :

template <std::size_t Idx>  // Current index in the for-loop.
void operator()(/* arguments... */) { /* Impl. */ }

ForEach < > .

class ForEach {
  public:

  /* Call function f with arguments args N times, passing the current index
     through the template argument. */
  template <std::size_t N, typename F, typename... Args>
  static void Call(F &&f, Args &&...args) {
    Impl<0, N>()(std::forward<F>(f), std::forward<Args>(args)...);
  }

  private:

  /* Forward declaration. */
  template <std::size_t Idx, std::size_t End>
  class Impl;

  /* Base case. We've incremeneted up to the end. */
  template <std::size_t End>
  class Impl<End, End> {
    public:

    template <typename F, typename... Args>
    void operator()(F &&, Args &&...) { /* Do nothing. */ }

  };  // Impl<End, End>

  /* Recursive case. Invoke the function with the arguments, while explicitly
     specifying the current index through the template argument. */
  template <std::size_t Idx, std::size_t End>
  class Impl {
    public:

    template <typename F, typename... Args>
    void operator()(F &&f, Args &&...args) {
      std::forward<F>(f).template operator()<Idx>(std::forward<Args>(args)...);
      Impl<Idx + 1, End>()(std::forward<F>(f), std::forward<Args>(args)...);
    }

  };  // Impl<Idx, End>

};  // ForEach

SomeClass, .

template <std::size_t Size>
class Ints {
  public:

  using Data = std::array<int, Size>;

  /* Call Assign, Size times, with data_ and n as the arguments. */
  void AssignAll(int n) { ForEach::Call<Size>(Assign(), data_, n); }

  /* Call Print, Size times, with data_ and n as the arguments. */
  void PrintAll() const { ForEach::Call<Size>(Print(), data_); }

  private:

  /* Wraps our templated assign function so that we can pass them around. */
  class Assign {
    public:

    template <size_t N>
    void operator()(Data &data, int arg) const {
      data[N] = arg;
    }

  };  // Assign

  /* Wraps our templated print function so that we can pass them around. */    
  class Print {
    public:

    template <size_t N>
    void operator()(const Data &data) const {
      std::cout << data[N] << std::endl;
    }

  };  // Print

  /* Our data. */
  Data data_;

};  // Ints<Size>

Ints.

int main() {
  Ints<5> ints;
  ints.AssignAll(101);
  ints.PrintAll();
}

101
101
101
101
101