123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544 |
- // Copyright (c) 2011 The Chromium Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style license that can be
- // found in the LICENSE file.
- // This defines a set of argument wrappers and related factory methods that
- // can be used specify the refcounting and reference semantics of arguments
- // that are bound by the Bind() function in butil/bind.h.
- //
- // It also defines a set of simple functions and utilities that people want
- // when using Callback<> and Bind().
- //
- //
- // ARGUMENT BINDING WRAPPERS
- //
- // The wrapper functions are butil::Unretained(), butil::Owned(), butil::Passed(),
- // butil::ConstRef(), and butil::IgnoreResult().
- //
- // Unretained() allows Bind() to bind a non-refcounted class, and to disable
- // refcounting on arguments that are refcounted objects.
- //
- // Owned() transfers ownership of an object to the Callback resulting from
- // bind; the object will be deleted when the Callback is deleted.
- //
- // Passed() is for transferring movable-but-not-copyable types (eg. scoped_ptr)
- // through a Callback. Logically, this signifies a destructive transfer of
- // the state of the argument into the target function. Invoking
- // Callback::Run() twice on a Callback that was created with a Passed()
- // argument will CHECK() because the first invocation would have already
- // transferred ownership to the target function.
- //
- // ConstRef() allows binding a constant reference to an argument rather
- // than a copy.
- //
- // IgnoreResult() is used to adapt a function or Callback with a return type to
- // one with a void return. This is most useful if you have a function with,
- // say, a pesky ignorable bool return that you want to use with PostTask or
- // something else that expect a Callback with a void return.
- //
- // EXAMPLE OF Unretained():
- //
- // class Foo {
- // public:
- // void func() { cout << "Foo:f" << endl; }
- // };
- //
- // // In some function somewhere.
- // Foo foo;
- // Closure foo_callback =
- // Bind(&Foo::func, Unretained(&foo));
- // foo_callback.Run(); // Prints "Foo:f".
- //
- // Without the Unretained() wrapper on |&foo|, the above call would fail
- // to compile because Foo does not support the AddRef() and Release() methods.
- //
- //
- // EXAMPLE OF Owned():
- //
- // void foo(int* arg) { cout << *arg << endl }
- //
- // int* pn = new int(1);
- // Closure foo_callback = Bind(&foo, Owned(pn));
- //
- // foo_callback.Run(); // Prints "1"
- // foo_callback.Run(); // Prints "1"
- // *n = 2;
- // foo_callback.Run(); // Prints "2"
- //
- // foo_callback.Reset(); // |pn| is deleted. Also will happen when
- // // |foo_callback| goes out of scope.
- //
- // Without Owned(), someone would have to know to delete |pn| when the last
- // reference to the Callback is deleted.
- //
- //
- // EXAMPLE OF ConstRef():
- //
- // void foo(int arg) { cout << arg << endl }
- //
- // int n = 1;
- // Closure no_ref = Bind(&foo, n);
- // Closure has_ref = Bind(&foo, ConstRef(n));
- //
- // no_ref.Run(); // Prints "1"
- // has_ref.Run(); // Prints "1"
- //
- // n = 2;
- // no_ref.Run(); // Prints "1"
- // has_ref.Run(); // Prints "2"
- //
- // Note that because ConstRef() takes a reference on |n|, |n| must outlive all
- // its bound callbacks.
- //
- //
- // EXAMPLE OF IgnoreResult():
- //
- // int DoSomething(int arg) { cout << arg << endl; }
- //
- // // Assign to a Callback with a void return type.
- // Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
- // cb->Run(1); // Prints "1".
- //
- // // Prints "1" on |ml|.
- // ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
- //
- //
- // EXAMPLE OF Passed():
- //
- // void TakesOwnership(scoped_ptr<Foo> arg) { }
- // scoped_ptr<Foo> CreateFoo() { return scoped_ptr<Foo>(new Foo()); }
- //
- // scoped_ptr<Foo> f(new Foo());
- //
- // // |cb| is given ownership of Foo(). |f| is now NULL.
- // // You can use f.Pass() in place of &f, but it's more verbose.
- // Closure cb = Bind(&TakesOwnership, Passed(&f));
- //
- // // Run was never called so |cb| still owns Foo() and deletes
- // // it on Reset().
- // cb.Reset();
- //
- // // |cb| is given a new Foo created by CreateFoo().
- // cb = Bind(&TakesOwnership, Passed(CreateFoo()));
- //
- // // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
- // // no longer owns Foo() and, if reset, would not delete Foo().
- // cb.Run(); // Foo() is now transferred to |arg| and deleted.
- // cb.Run(); // This CHECK()s since Foo() already been used once.
- //
- // Passed() is particularly useful with PostTask() when you are transferring
- // ownership of an argument into a task, but don't necessarily know if the
- // task will always be executed. This can happen if the task is cancellable
- // or if it is posted to a MessageLoopProxy.
- //
- //
- // SIMPLE FUNCTIONS AND UTILITIES.
- //
- // DoNothing() - Useful for creating a Closure that does nothing when called.
- // DeletePointer<T>() - Useful for creating a Closure that will delete a
- // pointer when invoked. Only use this when necessary.
- // In most cases MessageLoop::DeleteSoon() is a better
- // fit.
- #ifndef BASE_BIND_HELPERS_H_
- #define BASE_BIND_HELPERS_H_
- #include "butil/basictypes.h"
- #include "butil/callback.h"
- #include "butil/memory/weak_ptr.h"
- #include "butil/type_traits.h"
- namespace butil {
- namespace internal {
- // Use the Substitution Failure Is Not An Error (SFINAE) trick to inspect T
- // for the existence of AddRef() and Release() functions of the correct
- // signature.
- //
- // http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
- // http://stackoverflow.com/questions/257288/is-it-possible-to-write-a-c-template-to-check-for-a-functions-existence
- // http://stackoverflow.com/questions/4358584/sfinae-approach-comparison
- // http://stackoverflow.com/questions/1966362/sfinae-to-check-for-inherited-member-functions
- //
- // The last link in particular show the method used below.
- //
- // For SFINAE to work with inherited methods, we need to pull some extra tricks
- // with multiple inheritance. In the more standard formulation, the overloads
- // of Check would be:
- //
- // template <typename C>
- // Yes NotTheCheckWeWant(Helper<&C::TargetFunc>*);
- //
- // template <typename C>
- // No NotTheCheckWeWant(...);
- //
- // static const bool value = sizeof(NotTheCheckWeWant<T>(0)) == sizeof(Yes);
- //
- // The problem here is that template resolution will not match
- // C::TargetFunc if TargetFunc does not exist directly in C. That is, if
- // TargetFunc in inherited from an ancestor, &C::TargetFunc will not match,
- // |value| will be false. This formulation only checks for whether or
- // not TargetFunc exist directly in the class being introspected.
- //
- // To get around this, we play a dirty trick with multiple inheritance.
- // First, We create a class BaseMixin that declares each function that we
- // want to probe for. Then we create a class Base that inherits from both T
- // (the class we wish to probe) and BaseMixin. Note that the function
- // signature in BaseMixin does not need to match the signature of the function
- // we are probing for; thus it's easiest to just use void(void).
- //
- // Now, if TargetFunc exists somewhere in T, then &Base::TargetFunc has an
- // ambiguous resolution between BaseMixin and T. This lets us write the
- // following:
- //
- // template <typename C>
- // No GoodCheck(Helper<&C::TargetFunc>*);
- //
- // template <typename C>
- // Yes GoodCheck(...);
- //
- // static const bool value = sizeof(GoodCheck<Base>(0)) == sizeof(Yes);
- //
- // Notice here that the variadic version of GoodCheck() returns Yes here
- // instead of No like the previous one. Also notice that we calculate |value|
- // by specializing GoodCheck() on Base instead of T.
- //
- // We've reversed the roles of the variadic, and Helper overloads.
- // GoodCheck(Helper<&C::TargetFunc>*), when C = Base, fails to be a valid
- // substitution if T::TargetFunc exists. Thus GoodCheck<Base>(0) will resolve
- // to the variadic version if T has TargetFunc. If T::TargetFunc does not
- // exist, then &C::TargetFunc is not ambiguous, and the overload resolution
- // will prefer GoodCheck(Helper<&C::TargetFunc>*).
- //
- // This method of SFINAE will correctly probe for inherited names, but it cannot
- // typecheck those names. It's still a good enough sanity check though.
- //
- // Works on gcc-4.2, gcc-4.4, and Visual Studio 2008.
- //
- // TODO(ajwong): Move to ref_counted.h or type_traits.h when we've vetted
- // this works well.
- //
- // TODO(ajwong): Make this check for Release() as well.
- // See http://crbug.com/82038.
- template <typename T>
- class SupportsAddRefAndRelease {
- typedef char Yes[1];
- typedef char No[2];
- struct BaseMixin {
- void AddRef();
- };
- // MSVC warns when you try to use Base if T has a private destructor, the
- // common pattern for refcounted types. It does this even though no attempt to
- // instantiate Base is made. We disable the warning for this definition.
- #if defined(OS_WIN)
- #pragma warning(push)
- #pragma warning(disable:4624)
- #endif
- struct Base : public T, public BaseMixin {
- };
- #if defined(OS_WIN)
- #pragma warning(pop)
- #endif
- template <void(BaseMixin::*)(void)> struct Helper {};
- template <typename C>
- static No& Check(Helper<&C::AddRef>*);
- template <typename >
- static Yes& Check(...);
- public:
- static const bool value = sizeof(Check<Base>(0)) == sizeof(Yes);
- };
- // Helpers to assert that arguments of a recounted type are bound with a
- // scoped_refptr.
- template <bool IsClasstype, typename T>
- struct UnsafeBindtoRefCountedArgHelper : false_type {
- };
- template <typename T>
- struct UnsafeBindtoRefCountedArgHelper<true, T>
- : integral_constant<bool, SupportsAddRefAndRelease<T>::value> {
- };
- template <typename T>
- struct UnsafeBindtoRefCountedArg : false_type {
- };
- template <typename T>
- struct UnsafeBindtoRefCountedArg<T*>
- : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
- };
- template <typename T>
- class HasIsMethodTag {
- typedef char Yes[1];
- typedef char No[2];
- template <typename U>
- static Yes& Check(typename U::IsMethod*);
- template <typename U>
- static No& Check(...);
- public:
- static const bool value = sizeof(Check<T>(0)) == sizeof(Yes);
- };
- template <typename T>
- class UnretainedWrapper {
- public:
- explicit UnretainedWrapper(T* o) : ptr_(o) {}
- T* get() const { return ptr_; }
- private:
- T* ptr_;
- };
- template <typename T>
- class ConstRefWrapper {
- public:
- explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
- const T& get() const { return *ptr_; }
- private:
- const T* ptr_;
- };
- template <typename T>
- struct IgnoreResultHelper {
- explicit IgnoreResultHelper(T functor) : functor_(functor) {}
- T functor_;
- };
- template <typename T>
- struct IgnoreResultHelper<Callback<T> > {
- explicit IgnoreResultHelper(const Callback<T>& functor) : functor_(functor) {}
- const Callback<T>& functor_;
- };
- // An alternate implementation is to avoid the destructive copy, and instead
- // specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
- // a class that is essentially a scoped_ptr<>.
- //
- // The current implementation has the benefit though of leaving ParamTraits<>
- // fully in callback_internal.h as well as avoiding type conversions during
- // storage.
- template <typename T>
- class OwnedWrapper {
- public:
- explicit OwnedWrapper(T* o) : ptr_(o) {}
- ~OwnedWrapper() { delete ptr_; }
- T* get() const { return ptr_; }
- OwnedWrapper(const OwnedWrapper& other) {
- ptr_ = other.ptr_;
- other.ptr_ = NULL;
- }
- private:
- mutable T* ptr_;
- };
- // PassedWrapper is a copyable adapter for a scoper that ignores const.
- //
- // It is needed to get around the fact that Bind() takes a const reference to
- // all its arguments. Because Bind() takes a const reference to avoid
- // unnecessary copies, it is incompatible with movable-but-not-copyable
- // types; doing a destructive "move" of the type into Bind() would violate
- // the const correctness.
- //
- // This conundrum cannot be solved without either C++11 rvalue references or
- // a O(2^n) blowup of Bind() templates to handle each combination of regular
- // types and movable-but-not-copyable types. Thus we introduce a wrapper type
- // that is copyable to transmit the correct type information down into
- // BindState<>. Ignoring const in this type makes sense because it is only
- // created when we are explicitly trying to do a destructive move.
- //
- // Two notes:
- // 1) PassedWrapper supports any type that has a "Pass()" function.
- // This is intentional. The whitelisting of which specific types we
- // support is maintained by CallbackParamTraits<>.
- // 2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
- // scoper to a Callback and allow the Callback to execute once.
- template <typename T>
- class PassedWrapper {
- public:
- explicit PassedWrapper(T scoper) : is_valid_(true), scoper_(scoper.Pass()) {}
- PassedWrapper(const PassedWrapper& other)
- : is_valid_(other.is_valid_), scoper_(other.scoper_.Pass()) {
- }
- T Pass() const {
- CHECK(is_valid_);
- is_valid_ = false;
- return scoper_.Pass();
- }
- private:
- mutable bool is_valid_;
- mutable T scoper_;
- };
- // Unwrap the stored parameters for the wrappers above.
- template <typename T>
- struct UnwrapTraits {
- typedef const T& ForwardType;
- static ForwardType Unwrap(const T& o) { return o; }
- };
- template <typename T>
- struct UnwrapTraits<UnretainedWrapper<T> > {
- typedef T* ForwardType;
- static ForwardType Unwrap(UnretainedWrapper<T> unretained) {
- return unretained.get();
- }
- };
- template <typename T>
- struct UnwrapTraits<ConstRefWrapper<T> > {
- typedef const T& ForwardType;
- static ForwardType Unwrap(ConstRefWrapper<T> const_ref) {
- return const_ref.get();
- }
- };
- template <typename T>
- struct UnwrapTraits<scoped_refptr<T> > {
- typedef T* ForwardType;
- static ForwardType Unwrap(const scoped_refptr<T>& o) { return o.get(); }
- };
- template <typename T>
- struct UnwrapTraits<WeakPtr<T> > {
- typedef const WeakPtr<T>& ForwardType;
- static ForwardType Unwrap(const WeakPtr<T>& o) { return o; }
- };
- template <typename T>
- struct UnwrapTraits<OwnedWrapper<T> > {
- typedef T* ForwardType;
- static ForwardType Unwrap(const OwnedWrapper<T>& o) {
- return o.get();
- }
- };
- template <typename T>
- struct UnwrapTraits<PassedWrapper<T> > {
- typedef T ForwardType;
- static T Unwrap(PassedWrapper<T>& o) {
- return o.Pass();
- }
- };
- // Utility for handling different refcounting semantics in the Bind()
- // function.
- template <bool is_method, typename T>
- struct MaybeRefcount;
- template <typename T>
- struct MaybeRefcount<false, T> {
- static void AddRef(const T&) {}
- static void Release(const T&) {}
- };
- template <typename T, size_t n>
- struct MaybeRefcount<false, T[n]> {
- static void AddRef(const T*) {}
- static void Release(const T*) {}
- };
- template <typename T>
- struct MaybeRefcount<true, T> {
- static void AddRef(const T&) {}
- static void Release(const T&) {}
- };
- template <typename T>
- struct MaybeRefcount<true, T*> {
- static void AddRef(T* o) { o->AddRef(); }
- static void Release(T* o) { o->Release(); }
- };
- // No need to additionally AddRef() and Release() since we are storing a
- // scoped_refptr<> inside the storage object already.
- template <typename T>
- struct MaybeRefcount<true, scoped_refptr<T> > {
- static void AddRef(const scoped_refptr<T>& o) {}
- static void Release(const scoped_refptr<T>& o) {}
- };
- template <typename T>
- struct MaybeRefcount<true, const T*> {
- static void AddRef(const T* o) { o->AddRef(); }
- static void Release(const T* o) { o->Release(); }
- };
- // IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
- // method. It is used internally by Bind() to select the correct
- // InvokeHelper that will no-op itself in the event the WeakPtr<> for
- // the target object is invalidated.
- //
- // P1 should be the type of the object that will be received of the method.
- template <bool IsMethod, typename P1>
- struct IsWeakMethod : public false_type {};
- template <typename T>
- struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
- template <typename T>
- struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};
- } // namespace internal
- template <typename T>
- static inline internal::UnretainedWrapper<T> Unretained(T* o) {
- return internal::UnretainedWrapper<T>(o);
- }
- template <typename T>
- static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
- return internal::ConstRefWrapper<T>(o);
- }
- template <typename T>
- static inline internal::OwnedWrapper<T> Owned(T* o) {
- return internal::OwnedWrapper<T>(o);
- }
- // We offer 2 syntaxes for calling Passed(). The first takes a temporary and
- // is best suited for use with the return value of a function. The second
- // takes a pointer to the scoper and is just syntactic sugar to avoid having
- // to write Passed(scoper.Pass()).
- template <typename T>
- static inline internal::PassedWrapper<T> Passed(T scoper) {
- return internal::PassedWrapper<T>(scoper.Pass());
- }
- template <typename T>
- static inline internal::PassedWrapper<T> Passed(T* scoper) {
- return internal::PassedWrapper<T>(scoper->Pass());
- }
- template <typename T>
- static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
- return internal::IgnoreResultHelper<T>(data);
- }
- template <typename T>
- static inline internal::IgnoreResultHelper<Callback<T> >
- IgnoreResult(const Callback<T>& data) {
- return internal::IgnoreResultHelper<Callback<T> >(data);
- }
- BASE_EXPORT void DoNothing();
- template<typename T>
- void DeletePointer(T* obj) {
- delete obj;
- }
- } // namespace butil
- #endif // BASE_BIND_HELPERS_H_
|