callback.h

Go to the documentation of this file.

// Copyright 2013 Google Inc. All Rights Reserved.

#ifndef PAGESPEED_KERNEL_BASE_CALLBACK_H_
#define PAGESPEED_KERNEL_BASE_CALLBACK_H_



namespace net_instaweb {

template<class A1>
class Callback1 {
 public:
  Callback1() {}
  virtual ~Callback1() {}
  virtual void Run(A1) = 0;
};


template<class C, class A1, bool DeleteAfterRun>
class _MemberCallback_0_1 : public Callback1<A1> {
 public:
  typedef void (C::*MemberSignature)(A1);
  typedef Callback1<A1> base;

  _MemberCallback_0_1(C* object, MemberSignature member)
      : object_(object),
        member_(member) {
  }

  void Run(A1 t) {
    (object_->*member_)(t);
    if (DeleteAfterRun) {
      delete this;
    }
  }

 private:
  C* object_;
  MemberSignature member_;
};

template <class T1, class T2, class A1>
typename _MemberCallback_0_1<T1, A1, true>::base*
NewCallback(T1* obj, void (T2::*member)(A1)) {
  return new _MemberCallback_0_1<T1, A1, true>(obj, member);
}

template <class T1, class T2, class A1>
typename _MemberCallback_0_1<T1, A1, false>::base*
NewPermanentCallback(T1* obj, void (T2::*member)(A1)) {
  return new _MemberCallback_0_1<T1, A1, false>(obj, member);
}

template<typename T> struct remove_reference { typedef T type; };
template<typename T> struct remove_reference<T&> { typedef T type; };

template <typename T>
struct ConstRef {
  typedef typename remove_reference<T>::type base_type;
  typedef const base_type& type;
};

template <class T, class P1, class A1, bool DeleteAfterRun>
class _MemberCallback_1_1 : public Callback1<A1> {
 public:
  typedef Callback1<A1> base;
  typedef void (T::*MemberSignature)(P1, A1);

 private:
  T* object_;
  MemberSignature member_;
  typename remove_reference<P1>::type p1_;

 public:
  _MemberCallback_1_1(T* object,
                      MemberSignature member,
                      typename ConstRef<P1>::type p1)
      : object_(object),
        member_(member),
        p1_(p1) { }

  virtual void Run(A1 a1) {
    (object_->*member_)(p1_, a1);
    if (DeleteAfterRun) {
      delete this;
    }
  }
};

template <class T1, class T2, class P1, class A1>
inline typename _MemberCallback_1_1<T1, P1, A1, true>::base*
NewCallback(T1* obj,
            void (T2::*member)(P1, A1),
            typename ConstRef<P1>::type p1) {
  return new _MemberCallback_1_1<T1, P1, A1, true>(obj, member, p1);
}

template <class T1, class T2, class P1, class A1>
inline typename _MemberCallback_1_1<T1, P1, A1, false>::base*
NewPermanentCallback(T1* obj,
            void (T2::*member)(P1, A1),
            typename ConstRef<P1>::type p1) {
  return new _MemberCallback_1_1<T1, P1, A1, false>(obj, member, p1);
}

template<class A1, class A2>
class Callback2 {
 public:
  Callback2() {}
  virtual ~Callback2() {}
  virtual void Run(A1, A2) = 0;
};


template<class C, class A1, class A2, bool DeleteAfterRun>
class _MemberCallback_0_2 : public Callback2<A1, A2> {
 public:
  typedef void (C::*MemberSignature)(A1, A2);
  typedef Callback2<A1, A2> base;

  _MemberCallback_0_2(C* object, MemberSignature member)
      : object_(object),
        member_(member) {
  }

  void Run(A1 t1, A2 t2) {
    (object_->*member_)(t1, t2);
    if (DeleteAfterRun) {
      delete this;
    }
  }

 private:
  C* object_;
  MemberSignature member_;
};

template <class T1, class T2, class A1, class A2>
typename _MemberCallback_0_2<T1, A1, A2, true>::base*
NewCallback(T1* obj, void (T2::*member)(A1, A2)) {
  return new _MemberCallback_0_2<T1, A1, A2, true>(obj, member);
}

template <class T1, class T2, class A1, class A2>
typename _MemberCallback_0_2<T1, A1, A2, false>::base*
NewPermanentCallback(T1* obj, void (T2::*member)(A1, A2)) {
  return new _MemberCallback_0_2<T1, A1, A2, false>(obj, member);
}

template <class T, class P1, class A1, class A2, bool DeleteAfterRun>
class _MemberCallback_2_1 : public Callback2<A1, A2> {
 public:
  typedef Callback2<A1, A2> base;
  typedef void (T::*MemberSignature)(P1, A1, A2);

 private:
  T* object_;
  MemberSignature member_;
  typename remove_reference<P1>::type p1_;

 public:
  _MemberCallback_2_1(T* object,
                      MemberSignature member,
                      typename ConstRef<P1>::type p1)
      : object_(object),
        member_(member),
        p1_(p1) { }

  virtual void Run(A1 a1, A2 a2) {
    (object_->*member_)(p1_, a1, a2);
    if (DeleteAfterRun) {
      delete this;
    }
  }
};

template <class T1, class T2, class P1, class A1, class A2>
inline typename _MemberCallback_2_1<T1, P1, A1, A2, true>::base*
NewCallback(T1* obj,
            void (T2::*member)(P1, A1, A2),
            typename ConstRef<P1>::type p1) {
  return new _MemberCallback_2_1<T1, P1, A1, A2, true>(obj, member, p1);
}

template <class T1, class T2, class P1, class A1, class A2>
inline typename _MemberCallback_2_1<T1, P1, A1, A2, false>::base*
NewPermanentCallback(T1* obj,
                     void (T2::*member)(P1, A1, A2),
                     typename ConstRef<P1>::type p1) {
  return new _MemberCallback_2_1<T1, P1, A1, A2, false>(obj, member, p1);
}

}  


#endif