functioncall.h

Go to the documentation of this file.

#ifndef ION_BASE_FUNCTIONCALL_H_
#define ION_BASE_FUNCTIONCALL_H_

#include <tuple>

#include "base/macros.h"
#include "ion/base/allocatable.h"

namespace ion {
namespace base {

class FunctionCallBase : public Allocatable {
 public:
  virtual void operator()() const = 0;
  ~FunctionCallBase() override {}
};

 3.14);
template <typename T>
class FunctionCall;

template <typename ReturnType, typename... Types>
class FunctionCall<ReturnType(Types...)> : public FunctionCallBase {
 public:
  FunctionCall(ReturnType (*func)(Types...),
               Types&&... args)  // NOLINT
      : free_func_(func),
        args_(std::make_tuple(std::forward<Types>(args)...)) {}

  FunctionCall(const std::function<ReturnType(Types...)>& func,
               Types&&... args)  // NOLINT
      : free_func_(NULL),
        std_func_(func),
        args_(std::make_tuple(std::forward<Types>(args)...)) {}

  ~FunctionCall() override {}

  void operator()() const override {
    if (free_func_)
      this->ExpandArgsAndCall(free_func_,
                              SequenceGenerator<sizeof...(Types)>{});
    else
      this->ExpandArgsAndCall(std_func_,
                              SequenceGenerator<sizeof...(Types)>{});
  }

  template <size_t I>
  const typename std::tuple_element<I, std::tuple<Types...> >::type& GetArg()
      const {
    return std::get<I>(args_);
  }

  template <size_t I>
  void SetArg(const typename std::tuple_element<I, std::tuple<Types...> >::type&
                  value) {
    std::get<I>(args_) = value;
  }

 private:
  template <size_t... Indicies> struct Sequence {};

  template <size_t N, size_t... Indices>
  struct SequenceGenerator : SequenceGenerator<N - 1U, N - 1U, Indices...> {};

  template <size_t... Indices>
  struct SequenceGenerator<0U, Indices...> : Sequence<Indices...> {};

  template <typename Func, size_t... Indices>
  void ExpandArgsAndCall(const Func& func, Sequence<Indices...> seq) const {
    func(std::get<Indices>(args_)...);
  }

  ReturnType (*free_func_)(Types...);
  std::function<ReturnType(Types...)> std_func_;

  std::tuple<Types...> args_;
};

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_FUNCTIONCALL_H_