AIDelayedFunction.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <tuple>
 
#ifndef DOXYGEN
template<typename F>
class AIDelayedFunction; // not defined.
#endif
 
template<typename R, typename ...Args>
class AIDelayedFunction<R(Args...)>
{
 private:
  std::function<R(Args...)> m_function;       // Pointer to the (member) function.
  std::tuple<Args...> m_args;                 // Copy of the arguments to be passed.
  R m_result;                                 // Future result of the function.
 
 public:
  AIDelayedFunction(R (*fp)(Args...)) { m_function = fp; }
 
  template<class C>
  AIDelayedFunction(C* object, R (C::*memfn)(Args...))
      { m_function = [object, memfn](Args... args){ (object->*memfn)(args...); }; }
 
  void swap(AIDelayedFunction& other) noexcept
  {
    m_function.swap(other.m_function);
    m_args.swap(other.m_args);
    std::swap(m_result, other.m_result);
  }
 
  void operator()(Args... args) { m_args = std::make_tuple(args...); }
 
  void invoke() { m_result = std::apply(m_function, m_args); }
 
  R const& get() const { return m_result; }
};
 
template<typename ...Args>
class AIDelayedFunction<void(Args...)>
{
 private:
  std::function<void(Args...)> m_function;    // Pointer to the (member) function.
  std::tuple<Args...> m_args;                 // Copy of the arguments to be passed.
 
 public:
  AIDelayedFunction(void (*fp)(Args...)) { m_function = fp; }
 
  template<class C>
  AIDelayedFunction(C* object, void (C::*memfn)(Args...))
      { m_function = [object, memfn](Args... args){ (object->*memfn)(args...); }; }
 
  void operator()(Args... args) { m_args = std::make_tuple(args...); }
 
  void invoke() { std::apply(m_function, m_args); }
};