async.h

Go to the documentation of this file.

#ifndef CVMFS_UTIL_ASYNC_H_
#define CVMFS_UTIL_ASYNC_H_

#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif

template <typename ParamT>
class CallbackBase {
 public:
  virtual ~CallbackBase() {}
  virtual void operator()(const ParamT &value) const = 0;
};

template <>
class CallbackBase<void> {
 public:
  virtual ~CallbackBase() {}
  virtual void operator()() const = 0;
};

template <typename ParamT>
class Callback : public CallbackBase<ParamT> {
 public:
  typedef void (*CallbackFunction)(const ParamT &value);

  explicit Callback(CallbackFunction function) : function_(function) {}
  void operator()(const ParamT &value) const { function_(value); }

 private:
  CallbackFunction function_;
};

template <>
class Callback<void> : public CallbackBase<void> {
 public:
  typedef void (*CallbackFunction)();

  explicit Callback(CallbackFunction function) : function_(function) {}
  void operator()() const { function_(); }

 private:
  CallbackFunction function_;
};


template <typename ParamT, class DelegateT>
class BoundCallback : public CallbackBase<ParamT> {
 public:
  typedef void (DelegateT::*CallbackMethod)(const ParamT &value);

  BoundCallback(CallbackMethod method, DelegateT *delegate) :
    delegate_(delegate),
    method_(method) {}

  void operator()(const ParamT &value) const { (delegate_->*method_)(value); }

 private:
  DelegateT*     delegate_;
  CallbackMethod method_;
};

template <class DelegateT>
class BoundCallback<void, DelegateT> : public CallbackBase<void> {
 public:
  typedef void (DelegateT::*CallbackMethod)();

  BoundCallback(CallbackMethod method, DelegateT *delegate) :
    delegate_(delegate), method_(method) {}

  void operator()() const { (delegate_->*method_)(); }

 private:
  DelegateT*     delegate_;
  CallbackMethod method_;
};


template <typename ParamT, class DelegateT, typename ClosureDataT>
class BoundClosure : public CallbackBase<ParamT> {
 public:
  typedef void (DelegateT::*CallbackMethod)(const ParamT        &value,
                                            const ClosureDataT   closure_data);

 public:
  BoundClosure(CallbackMethod  method,
               DelegateT      *delegate,
               ClosureDataT    data) :
    delegate_(delegate),
    method_(method),
    closure_data_(data) {}

  void operator()(const ParamT &value) const {
    (delegate_->*method_)(value, closure_data_);
  }

 private:
  DelegateT*          delegate_;
  CallbackMethod      method_;
  const ClosureDataT  closure_data_;
};

template <class DelegateT, typename ClosureDataT>
class BoundClosure<void, DelegateT, ClosureDataT> : public CallbackBase<void> {
 public:
  typedef void (DelegateT::*CallbackMethod)(const ClosureDataT closure_data);

 public:
  BoundClosure(CallbackMethod  method,
               DelegateT      *delegate,
               ClosureDataT    data) :
    delegate_(delegate), method_(method), closure_data_(data) {}

  void operator()() const { (delegate_->*method_)(closure_data_); }

 private:
  DelegateT*         delegate_;
  CallbackMethod     method_;
  const ClosureDataT closure_data_;
};


template <class ParamT>
class Callbackable {
 public:
  typedef CallbackBase<ParamT> CallbackTN;

 public:
  template <class DelegateT, typename ClosureDataT>
  static CallbackTN* MakeClosure(
    typename BoundClosure<ParamT, DelegateT, ClosureDataT>::
             CallbackMethod method,
    DelegateT *delegate,
    const ClosureDataT &closure_data)
  {
    return new BoundClosure<ParamT, DelegateT, ClosureDataT>(method,
                                                             delegate,
                                                             closure_data);
  }

  template <class DelegateT>
  static CallbackTN* MakeCallback(
        typename BoundCallback<ParamT, DelegateT>::CallbackMethod method,
        DelegateT *delegate) {
    return new BoundCallback<ParamT, DelegateT>(method, delegate);
  }

  static CallbackTN* MakeCallback(
        typename Callback<ParamT>::CallbackFunction function) {
    return new Callback<ParamT>(function);
  }
};


template <class DelegateT>
void ThreadProxy(DelegateT        *delegate,
                 void (DelegateT::*method)()) {
  (*delegate.*method)();
}



#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_UTIL_ASYNC_H_