| blob | 5cf124df32f30bb5b4080d8370d1b05f199cc19e |
1 // This file was GENERATED by command:
2 // pump.py bind.h.pump
3 // DO NOT EDIT BY HAND!!!
6 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
7 // Use of this source code is governed by a BSD-style license that can be
8 // found in the LICENSE file.
10 #ifndef BASE_BIND_H_
11 #define BASE_BIND_H_
16 // -----------------------------------------------------------------------------
17 // Usage documentation
18 // -----------------------------------------------------------------------------
19 //
20 // See base/callback.h for documentation.
21 //
22 //
23 // -----------------------------------------------------------------------------
24 // Implementation notes
25 // -----------------------------------------------------------------------------
26 //
27 // If you're reading the implementation, before proceeding further, you should
28 // read the top comment of base/bind_internal.h for a definition of common
29 // terms and concepts.
30 //
31 // RETURN TYPES
32 //
33 // Though Bind()'s result is meant to be stored in a Callback<> type, it
34 // cannot actually return the exact type without requiring a large amount
35 // of extra template specializations. The problem is that in order to
36 // discern the correct specialization of Callback<>, Bind would need to
37 // unwrap the function signature to determine the signature's arity, and
38 // whether or not it is a method.
39 //
40 // Each unique combination of (arity, function_type, num_prebound) where
41 // function_type is one of {function, method, const_method} would require
42 // one specialization. We eventually have to do a similar number of
43 // specializations anyways in the implementation (see the Invoker<>,
44 // classes). However, it is avoidable in Bind if we return the result
45 // via an indirection like we do below.
46 //
47 // TODO(ajwong): We might be able to avoid this now, but need to test.
48 //
49 // It is possible to move most of the COMPILE_ASSERT asserts into BindState<>,
50 // but it feels a little nicer to have the asserts here so people do not
51 // need to crack open bind_internal.h. On the other hand, it makes Bind()
52 // harder to read.
64 // Typedefs for how to store and run the functor.
68 // Use RunnableType::RunType instead of RunType above because our
69 // checks should below for bound references need to know what the actual
70 // functor is going to interpret the argument as.
72 BoundFunctorTraits;
79 }
89 // Typedefs for how to store and run the functor.
93 // Use RunnableType::RunType instead of RunType above because our
94 // checks should below for bound references need to know what the actual
95 // functor is going to interpret the argument as.
97 BoundFunctorTraits;
99 // Do not allow binding a non-const reference parameter. Non-const reference
100 // parameters are disallowed by the Google style guide. Also, binding a
101 // non-const reference parameter can make for subtle bugs because the
102 // invoked function will receive a reference to the stored copy of the
103 // argument and not the original.
106 do_not_bind_functions_with_nonconst_ref);
108 // For methods, we need to be careful for parameter 1. We do not require
109 // a scoped_refptr because BindState<> itself takes care of AddRef() for
110 // methods. We also disallow binding of an array as the method's target
111 // object.
115 p1_is_refcounted_type_and_needs_scoped_refptr);
118 first_bound_argument_to_method_cannot_be_array);
125 }
136 // Typedefs for how to store and run the functor.
140 // Use RunnableType::RunType instead of RunType above because our
141 // checks should below for bound references need to know what the actual
142 // functor is going to interpret the argument as.
144 BoundFunctorTraits;
146 // Do not allow binding a non-const reference parameter. Non-const reference
147 // parameters are disallowed by the Google style guide. Also, binding a
148 // non-const reference parameter can make for subtle bugs because the
149 // invoked function will receive a reference to the stored copy of the
150 // argument and not the original.
154 do_not_bind_functions_with_nonconst_ref);
156 // For methods, we need to be careful for parameter 1. We do not require
157 // a scoped_refptr because BindState<> itself takes care of AddRef() for
158 // methods. We also disallow binding of an array as the method's target
159 // object.
163 p1_is_refcounted_type_and_needs_scoped_refptr);
166 first_bound_argument_to_method_cannot_be_array);
168 p2_is_refcounted_type_and_needs_scoped_refptr);
176 }
188 // Typedefs for how to store and run the functor.
192 // Use RunnableType::RunType instead of RunType above because our
193 // checks should below for bound references need to know what the actual
194 // functor is going to interpret the argument as.
196 BoundFunctorTraits;
198 // Do not allow binding a non-const reference parameter. Non-const reference
199 // parameters are disallowed by the Google style guide. Also, binding a
200 // non-const reference parameter can make for subtle bugs because the
201 // invoked function will receive a reference to the stored copy of the
202 // argument and not the original.
207 do_not_bind_functions_with_nonconst_ref);
209 // For methods, we need to be careful for parameter 1. We do not require
210 // a scoped_refptr because BindState<> itself takes care of AddRef() for
211 // methods. We also disallow binding of an array as the method's target
212 // object.
216 p1_is_refcounted_type_and_needs_scoped_refptr);
219 first_bound_argument_to_method_cannot_be_array);
221 p2_is_refcounted_type_and_needs_scoped_refptr);
223 p3_is_refcounted_type_and_needs_scoped_refptr);
232 }
245 // Typedefs for how to store and run the functor.
249 // Use RunnableType::RunType instead of RunType above because our
250 // checks should below for bound references need to know what the actual
251 // functor is going to interpret the argument as.
253 BoundFunctorTraits;
255 // Do not allow binding a non-const reference parameter. Non-const reference
256 // parameters are disallowed by the Google style guide. Also, binding a
257 // non-const reference parameter can make for subtle bugs because the
258 // invoked function will receive a reference to the stored copy of the
259 // argument and not the original.
265 do_not_bind_functions_with_nonconst_ref);
267 // For methods, we need to be careful for parameter 1. We do not require
268 // a scoped_refptr because BindState<> itself takes care of AddRef() for
269 // methods. We also disallow binding of an array as the method's target
270 // object.
274 p1_is_refcounted_type_and_needs_scoped_refptr);
277 first_bound_argument_to_method_cannot_be_array);
279 p2_is_refcounted_type_and_needs_scoped_refptr);
281 p3_is_refcounted_type_and_needs_scoped_refptr);
283 p4_is_refcounted_type_and_needs_scoped_refptr);
293 }
296 typename P5>
309 // Typedefs for how to store and run the functor.
313 // Use RunnableType::RunType instead of RunType above because our
314 // checks should below for bound references need to know what the actual
315 // functor is going to interpret the argument as.
317 BoundFunctorTraits;
319 // Do not allow binding a non-const reference parameter. Non-const reference
320 // parameters are disallowed by the Google style guide. Also, binding a
321 // non-const reference parameter can make for subtle bugs because the
322 // invoked function will receive a reference to the stored copy of the
323 // argument and not the original.
330 do_not_bind_functions_with_nonconst_ref);
332 // For methods, we need to be careful for parameter 1. We do not require
333 // a scoped_refptr because BindState<> itself takes care of AddRef() for
334 // methods. We also disallow binding of an array as the method's target
335 // object.
339 p1_is_refcounted_type_and_needs_scoped_refptr);
342 first_bound_argument_to_method_cannot_be_array);
344 p2_is_refcounted_type_and_needs_scoped_refptr);
346 p3_is_refcounted_type_and_needs_scoped_refptr);
348 p4_is_refcounted_type_and_needs_scoped_refptr);
350 p5_is_refcounted_type_and_needs_scoped_refptr);
361 }
378 // Typedefs for how to store and run the functor.
382 // Use RunnableType::RunType instead of RunType above because our
383 // checks should below for bound references need to know what the actual
384 // functor is going to interpret the argument as.
386 BoundFunctorTraits;
388 // Do not allow binding a non-const reference parameter. Non-const reference
389 // parameters are disallowed by the Google style guide. Also, binding a
390 // non-const reference parameter can make for subtle bugs because the
391 // invoked function will receive a reference to the stored copy of the
392 // argument and not the original.
400 do_not_bind_functions_with_nonconst_ref);
402 // For methods, we need to be careful for parameter 1. We do not require
403 // a scoped_refptr because BindState<> itself takes care of AddRef() for
404 // methods. We also disallow binding of an array as the method's target
405 // object.
409 p1_is_refcounted_type_and_needs_scoped_refptr);
412 first_bound_argument_to_method_cannot_be_array);
414 p2_is_refcounted_type_and_needs_scoped_refptr);
416 p3_is_refcounted_type_and_needs_scoped_refptr);
418 p4_is_refcounted_type_and_needs_scoped_refptr);
420 p5_is_refcounted_type_and_needs_scoped_refptr);
422 p6_is_refcounted_type_and_needs_scoped_refptr);
434 }
452 // Typedefs for how to store and run the functor.
456 // Use RunnableType::RunType instead of RunType above because our
457 // checks should below for bound references need to know what the actual
458 // functor is going to interpret the argument as.
460 BoundFunctorTraits;
462 // Do not allow binding a non-const reference parameter. Non-const reference
463 // parameters are disallowed by the Google style guide. Also, binding a
464 // non-const reference parameter can make for subtle bugs because the
465 // invoked function will receive a reference to the stored copy of the
466 // argument and not the original.
475 do_not_bind_functions_with_nonconst_ref);
477 // For methods, we need to be careful for parameter 1. We do not require
478 // a scoped_refptr because BindState<> itself takes care of AddRef() for
479 // methods. We also disallow binding of an array as the method's target
480 // object.
484 p1_is_refcounted_type_and_needs_scoped_refptr);
487 first_bound_argument_to_method_cannot_be_array);
489 p2_is_refcounted_type_and_needs_scoped_refptr);
491 p3_is_refcounted_type_and_needs_scoped_refptr);
493 p4_is_refcounted_type_and_needs_scoped_refptr);
495 p5_is_refcounted_type_and_needs_scoped_refptr);
497 p6_is_refcounted_type_and_needs_scoped_refptr);
499 p7_is_refcounted_type_and_needs_scoped_refptr);
512 p7));
513 }