struct FunctionWithDataDummy {};

Callback()

: invoker_(NULL) {}

template <class F, class T>

Callback(F func, T* object)

: invoker_(new (&storage_) MemberInvoker<F, T>(func, object)) {

typedef MemberInvoker<F, T> MemberInvoker;

STATIC_ASSERT(sizeof(Storage) >= sizeof(MemberInvoker));

STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(MemberInvoker));

}

template <class F>

explicit Callback(F func)

: invoker_(new (&storage_) FunctionInvoker<F>(func)) {

typedef FunctionInvoker<F> FunctionInvoker;

STATIC_ASSERT(sizeof(Storage) >= sizeof(FunctionInvoker));

STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(FunctionInvoker));

}

template <class F, class D>

Callback(F func, const D& data, FunctionWithDataDummy)

: invoker_(new (&storage_) FunctionWithDataInvoker<F, D>(func, data)) {

typedef FunctionWithDataInvoker<F, D> FunctionWithDataInvoker;

STATIC_ASSERT(sizeof(Storage) >= sizeof(FunctionWithDataInvoker));

STATIC_ASSERT(ALIGN_OF(Storage) >= ALIGN_OF(FunctionWithDataInvoker));

}

Callback(const Callback& other)

: invoker_(other.invoker_ ? other.invoker_->copy(&storage_) : NULL) {}

Callback& operator=(const Callback& other) {

invoker_ = other.invoker_ ? other.invoker_->copy(&storage_) : NULL;

return *this;

}

operator bool() const { return invoker_ != NULL; }

R operator()(const Arg& arg) const { return invoker_->invoke(arg); }

// This needs to be big enough to fit:

// - A vtable pointer (8 bytes).

// - A member function pointer or a function pointer (this can be a fat

// pointer of up to 16 bytes).

// - A pointer/int data parameter (8 bytes).

typedef AlignedStorage<32, 8> Storage;

struct Invoker {

virtual R invoke(const Arg& arg) const = 0;

virtual Invoker* copy(Storage* storage) = 0;

};

template <class F, class T>

struct MemberInvoker : public Invoker {

MemberInvoker(F func, T* object)

: func(func)

, object(object) {}

R invoke(const Arg& arg) const { return (object->*func)(arg); }

Invoker* copy(Storage* storage) { return new (storage) MemberInvoker<F, T>(func, object); }

F func;

T* object;

};

template <class F>

struct FunctionInvoker : public Invoker {

FunctionInvoker(F func)

: func(func) {}

R invoke(const Arg& arg) const { return func(arg); }

Invoker* copy(Storage* storage) { return new (storage) FunctionInvoker<F>(func); }

F func;

};

template <class F, class D>

struct FunctionWithDataInvoker : public Invoker {

FunctionWithDataInvoker(F func, D data)

: func(func)

, data(data) {}

R invoke(const Arg& arg) const { return func(arg, data); }

Invoker* copy(Storage* storage) {

return new (storage) FunctionWithDataInvoker<F, D>(func, data);

}

F func;

D data;

};

Invoker* invoker_;

Storage storage_;