1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef BASE_BIND_H_
6 #define BASE_BIND_H_
7
8 #include "base/bind_internal.h"
9 #include "base/callback_internal.h"
10
11 // -----------------------------------------------------------------------------
12 // Usage documentation
13 // -----------------------------------------------------------------------------
14 //
15 // See base/callback.h for documentation.
16 //
17 //
18 // -----------------------------------------------------------------------------
compare256_unaligned_avx2_static(const unsigned char * src0,const unsigned char * src1)19 // Implementation notes
20 // -----------------------------------------------------------------------------
21 //
22 // If you're reading the implementation, before proceeding further, you should
23 // read the top comment of base/bind_internal.h for a definition of common
24 // terms and concepts.
25 //
26 // RETURN TYPES
27 //
28 // Though Bind()'s result is meant to be stored in a Callback<> type, it
29 // cannot actually return the exact type without requiring a large amount
30 // of extra template specializations. The problem is that in order to
31 // discern the correct specialization of Callback<>, Bind would need to
32 // unwrap the function signature to determine the signature's arity, and
33 // whether or not it is a method.
34 //
35 // Each unique combination of (arity, function_type, num_prebound) where
36 // function_type is one of {function, method, const_method} would require
37 // one specialization. We eventually have to do a similar number of
38 // specializations anyways in the implementation (see the Invoker<>,
39 // classes). However, it is avoidable in Bind if we return the result
40 // via an indirection like we do below.
41 //
42 // TODO(ajwong): We might be able to avoid this now, but need to test.
43 //
44 // It is possible to move most of the static_assert into BindState<>, but it
45 // feels a little nicer to have the asserts here so people do not need to crack
46 // open bind_internal.h. On the other hand, it makes Bind() harder to read.
47
48 namespace base {
49
50 template <typename Functor, typename... Args>
51 base::Callback<
52 typename internal::BindState<
53 typename internal::FunctorTraits<Functor>::RunnableType,
54 typename internal::FunctorTraits<Functor>::RunType,
55 typename internal::CallbackParamTraits<Args>::StorageType...>
56 ::UnboundRunType>
57 Bind(Functor functor, const Args&... args) {
58 // Type aliases for how to store and run the functor.
59 using RunnableType = typename internal::FunctorTraits<Functor>::RunnableType;
60 using RunType = typename internal::FunctorTraits<Functor>::RunType;
61
62 // Use RunnableType::RunType instead of RunType above because our
63 // checks below for bound references need to know what the actual
64 // functor is going to interpret the argument as.
65 using BoundRunType = typename RunnableType::RunType;
66
67 using BoundArgs =
68 internal::TakeTypeListItem<sizeof...(Args),
69 internal::ExtractArgs<BoundRunType>>;
70
71 // Do not allow binding a non-const reference parameter. Non-const reference
72 // parameters are disallowed by the Google style guide. Also, binding a
73 // non-const reference parameter can make for subtle bugs because the
74 // invoked function will receive a reference to the stored copy of the
75 // argument and not the original.
76 static_assert(!internal::HasNonConstReferenceItem<BoundArgs>::value,
77 "do not bind functions with nonconst ref");
78
79 const bool is_method = internal::HasIsMethodTag<RunnableType>::value;
80
81 // For methods, we need to be careful for parameter 1. We do not require
82 // a scoped_refptr because BindState<> itself takes care of AddRef() for
83 // methods. We also disallow binding of an array as the method's target
84 // object.
85 static_assert(!internal::BindsArrayToFirstArg<is_method, Args...>::value,
86 "first bound argument to method cannot be array");
87 static_assert(
88 !internal::HasRefCountedParamAsRawPtr<is_method, Args...>::value,
89 "a parameter is a refcounted type and needs scoped_refptr");
90
91 using BindState = internal::BindState<
92 RunnableType, RunType,
93 typename internal::CallbackParamTraits<Args>::StorageType...>;
94
95 return Callback<typename BindState::UnboundRunType>(
96 new BindState(internal::MakeRunnable(functor), args...));
97 }
98
99 } // namespace base
100
101 #endif // BASE_BIND_H_
102