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_