function.h

Go to the documentation of this file.

/*
 * Copyright 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_KERNEL_BASE_FUNCTION_H_
#define PAGESPEED_KERNEL_BASE_FUNCTION_H_

#include "pagespeed/kernel/base/atomic_bool.h"
#include "pagespeed/kernel/base/basictypes.h"

namespace net_instaweb {

class Function {
 public:
  Function();
  virtual ~Function();

  void set_quit_requested_pointer(AtomicBool* x) { quit_requested_ = x; }

  bool quit_requested() const {
    return (quit_requested_ != NULL) && quit_requested_->value();
  }

  void CallRun();
  void CallCancel();

  void set_delete_after_callback(bool x) { delete_after_callback_ = x; }

  void Reset();

 protected:
  virtual void Run() = 0;

  virtual void Cancel() {}

 private:
  AtomicBool* quit_requested_;
  bool run_called_;
  bool cancel_called_;
  bool delete_after_callback_;

  
};

#define CALL_MEMBER_FN(object, ptrToMember) ((this->object)->*(ptrToMember))

template<class C>
class MemberFunctionBase : public Function {
 public:
  explicit MemberFunctionBase(C* c) : object_(c) {}

 protected:
  C* object_;
};

template<class C>
class MemberFunction0 : public MemberFunctionBase<C> {
 public:
  typedef void (C::*Func)();

  MemberFunction0(Func f, C* c) : MemberFunctionBase<C>(c), run_(f),
                                  cancel_(NULL) {
  }

  MemberFunction0(Func f, Func cancel, C* c)
      : MemberFunctionBase<C>(c), run_(f), cancel_(cancel) {}

 protected:
  virtual void Run() { CALL_MEMBER_FN(object_, run_)(); }
  virtual void Cancel() {
    if (cancel_ != NULL) {
      CALL_MEMBER_FN(object_, cancel_)();
    }
  }

 private:
  Func run_;
  Func cancel_;
};

template<class C, typename T1>
class MemberFunction1 : public MemberFunctionBase<C> {
 public:
  typedef void (C::*Func)(T1);

  MemberFunction1(Func f, C* c, T1 v1)
      : MemberFunctionBase<C>(c), run_(f), cancel_(NULL), v1_(v1) {}

  MemberFunction1(Func f, Func cancel,
                  C* c, T1 v1)
      : MemberFunctionBase<C>(c), run_(f), cancel_(cancel), v1_(v1)  {}

 protected:
  virtual void Run() { CALL_MEMBER_FN(object_, run_)(v1_); }
  virtual void Cancel() {
    if (cancel_ != NULL) {
      CALL_MEMBER_FN(object_, cancel_)(v1_);
    }
  }

 private:
  Func run_;
  Func cancel_;
  T1 v1_;
};

template<class C, typename T1, typename T2>
class MemberFunction2 : public MemberFunctionBase<C> {
 public:
  typedef void (C::*Func)(T1, T2);

  MemberFunction2(Func f, C* c, T1 v1, T2 v2)
      : MemberFunctionBase<C>(c), run_(f), cancel_(NULL), v1_(v1), v2_(v2) {}

  MemberFunction2(Func f, Func cancel,
                  C* c, T1 v1, T2 v2)
      : MemberFunctionBase<C>(c),
        run_(f), cancel_(cancel),
        v1_(v1), v2_(v2)  {}

 protected:
  virtual void Run() { CALL_MEMBER_FN(object_, run_)(v1_, v2_); }
  virtual void Cancel() {
    if (cancel_ != NULL) {
      CALL_MEMBER_FN(object_, cancel_)(v1_, v2_);
    }
  }

 private:
  Func run_;
  Func cancel_;
  T1 v1_;
  T2 v2_;
};

template<class C, typename T1, typename T2, typename T3>
class MemberFunction3 : public MemberFunctionBase<C> {
 public:
  typedef void (C::*Func)(T1, T2, T3);

  MemberFunction3(Func f, C* c, T1 v1, T2 v2, T3 v3)
      : MemberFunctionBase<C>(c), run_(f), cancel_(NULL), v1_(v1), v2_(v2),
        v3_(v3) {
  }

  MemberFunction3(Func f, Func cancel,
                  C* c, T1 v1, T2 v2, T3 v3)
      : MemberFunctionBase<C>(c),
        run_(f), cancel_(cancel),
        v1_(v1), v2_(v2), v3_(v3)  {}

 protected:
  virtual void Run() { CALL_MEMBER_FN(object_, run_)(v1_, v2_, v3_); }
  virtual void Cancel() {
    if (cancel_ != NULL) {
      CALL_MEMBER_FN(object_, cancel_)(v1_, v2_, v3_);
    }
  }

 private:
  Func run_;
  Func cancel_;
  T1 v1_;
  T2 v2_;
  T3 v3_;
};

template<class C, typename T1, typename T2, typename T3, typename T4>
class MemberFunction4 : public MemberFunctionBase<C> {
 public:
  typedef void (C::*Func)(T1, T2, T3, T4);

  MemberFunction4(Func f, C* c, T1 v1, T2 v2, T3 v3, T4 v4)
      : MemberFunctionBase<C>(c), run_(f), cancel_(NULL), v1_(v1), v2_(v2),
        v3_(v3), v4_(v4) {
  }

  MemberFunction4(Func f, Func cancel,
                  C* c, T1 v1, T2 v2, T3 v3, T4 v4)
      : MemberFunctionBase<C>(c),
        run_(f), cancel_(cancel),
        v1_(v1), v2_(v2), v3_(v3), v4_(v4)  {}

 protected:
  virtual void Run() { CALL_MEMBER_FN(object_, run_)(v1_, v2_, v3_, v4_); }
  virtual void Cancel() {
    if (cancel_ != NULL) {
      CALL_MEMBER_FN(object_, cancel_)(v1_, v2_, v3_, v4_);
    }
  }

 private:
  Func run_;
  Func cancel_;
  T1 v1_;
  T2 v2_;
  T3 v3_;
  T4 v4_;
};

#undef CALL_MEMBER_FN

template<class C>
Function* MakeFunction(C* object, void (C::*run)()) {
  return new MemberFunction0<C>(run, object);
}

template<class C>
Function* MakeFunction(C* object, void (C::*run)(), void (C::*cancel)()) {
  return new MemberFunction0<C>(run, cancel, object);
}

template<class C, class T>
Function* MakeFunction(C* object, void (C::*run)(T), T t) {
  return new MemberFunction1<C, T>(run, object, t);
}

template<class C, class T>
Function* MakeFunction(C* object,
                       void (C::*run)(T),
                       void (C::*cancel)(T), T t) {
  return new MemberFunction1<C, T>(run, cancel, object, t);
}

template<class C, class T, class U>
Function* MakeFunction(C* object, void (C::*run)(T, U), T t, U u) {
  return new MemberFunction2<C, T, U>(run, object, t, u);
}

template<class C, class T, class U>
Function* MakeFunction(C* object,
                       void (C::*run)(T, U),
                       void (C::*cancel)(T, U),
                       T t, U u) {
  return new MemberFunction2<C, T, U>(run, cancel, object, t, u);
}

template<class C, class T, class U, class V>
Function* MakeFunction(C* object,
                       void (C::*run)(T, U, V),
                       T t, U u, V v) {
  return new MemberFunction3<C, T, U, V>(run, object, t, u, v);
}

template<class C, class T, class U, class V>
Function* MakeFunction(C* object,
                       void (C::*run)(T, U, V),
                       void (C::*cancel)(T, U, V),
                       T t, U u, V v) {
  return new MemberFunction3<C, T, U, V>(run, cancel, object, t, u, v);
}

template<class C, class T, class U, class V, class W>
Function* MakeFunction(C* object,
                       void (C::*run)(T, U, V, W),
                       T t, U u, V v, W w) {
  return new MemberFunction4<C, T, U, V, W>(run, object, t, u, v, w);
}

template<class C, class T, class U, class V, class W>
Function* MakeFunction(C* object,
                       void (C::*run)(T, U, V, W),
                       void (C::*cancel)(T, U, V, W),
                       T t, U u, V v, W w) {
  return new MemberFunction4<C, T, U, V, W>(run, cancel, object, t, u, v, w);
}

}  

#endif