YugabyteDB (2.13.0.0-b42, bfc6a6643e7399ac8a0e81d06a3ee6d6571b33ab)

Coverage Report

Created: 2022-03-09 17:30

/Users/deen/code/yugabyte-db/src/yb/gutil/bind.h
Line
Count
Source (jump to first uncovered line)
1
// This file was GENERATED by command:
2
//     pump.py bind.h.pump
3
// DO NOT EDIT BY HAND!!!
4
5
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.
9
//
10
// The following only applies to changes made to this file as part of YugaByte development.
11
//
12
// Portions Copyright (c) YugaByte, Inc.
13
//
14
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
15
// in compliance with the License.  You may obtain a copy of the License at
16
//
17
// http://www.apache.org/licenses/LICENSE-2.0
18
//
19
// Unless required by applicable law or agreed to in writing, software distributed under the License
20
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
21
// or implied.  See the License for the specific language governing permissions and limitations
22
// under the License.
23
//
24
25
#ifndef YB_GUTIL_BIND_H_
26
#define YB_GUTIL_BIND_H_
27
28
#include "yb/gutil/bind_internal.h"
29
#include "yb/gutil/callback_internal.h"
30
31
// -----------------------------------------------------------------------------
32
// Usage documentation
33
// -----------------------------------------------------------------------------
34
//
35
// See yb/gutil/callback.h for documentation.
36
//
37
//
38
// -----------------------------------------------------------------------------
39
// Implementation notes
40
// -----------------------------------------------------------------------------
41
//
42
// If you're reading the implementation, before proceeding further, you should
43
// read the top comment of yb/gutil/bind_internal.h for a definition of common
44
// terms and concepts.
45
//
46
// RETURN TYPES
47
//
48
// Though Bind()'s result is meant to be stored in a Callback<> type, it
49
// cannot actually return the exact type without requiring a large amount
50
// of extra template specializations. The problem is that in order to
51
// discern the correct specialization of Callback<>, Bind would need to
52
// unwrap the function signature to determine the signature's arity, and
53
// whether or not it is a method.
54
//
55
// Each unique combination of (arity, function_type, num_prebound) where
56
// function_type is one of {function, method, const_method} would require
57
// one specialization.  We eventually have to do a similar number of
58
// specializations anyways in the implementation (see the Invoker<>,
59
// classes).  However, it is avoidable in Bind if we return the result
60
// via an indirection like we do below.
61
//
62
// TODO(ajwong): We might be able to avoid this now, but need to test.
63
//
64
// It is possible to move most of the COMPILE_ASSERT asserts into BindState<>,
65
// but it feels a little nicer to have the asserts here so people do not
66
// need to crack open bind_internal.h.  On the other hand, it makes Bind()
67
// harder to read.
68
69
namespace yb {
70
71
template <typename Functor>
72
Callback<
73
    typename internal::BindState<
74
        typename internal::FunctorTraits<Functor>::RunnableType,
75
        typename internal::FunctorTraits<Functor>::RunType,
76
        void()>
77
            ::UnboundRunType>
78
87.7k
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
87.7k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
87.7k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
87.7k
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
87.7k
  return Callback<typename BindState::UnboundRunType>(
87
87.7k
      new BindState(internal::MakeRunnable(functor)));
88
87.7k
}
_ZN2yb4BindIPFvRKNS_6StatusEEEENS_8CallbackINS_8internal9BindStateINS7_13FunctorTraitsIT_E12RunnableTypeENSB_7RunTypeEFvvEE14UnboundRunTypeEEESA_
Line
Count
Source
78
191
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
191
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
191
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
191
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
191
  return Callback<typename BindState::UnboundRunType>(
87
191
      new BindState(internal::MakeRunnable(functor)));
88
191
}
_ZN2yb4BindIPFvNSt3__110shared_ptrINS_9consensus18StateChangeContextEEEEEENS_8CallbackINS_8internal9BindStateINS9_13FunctorTraitsIT_E12RunnableTypeENSD_7RunTypeEFvvEE14UnboundRunTypeEEESC_
Line
Count
Source
78
29
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
29
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
29
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
29
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
29
  return Callback<typename BindState::UnboundRunType>(
87
29
      new BindState(internal::MakeRunnable(functor)));
88
29
}
_ZN2yb4BindIPFivEEENS_8CallbackINS_8internal9BindStateINS4_13FunctorTraitsIT_E12RunnableTypeENS8_7RunTypeEFvvEE14UnboundRunTypeEEES7_
Line
Count
Source
78
1
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
1
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
1
  return Callback<typename BindState::UnboundRunType>(
87
1
      new BindState(internal::MakeRunnable(functor)));
88
1
}
_ZN2yb4BindIPFvPNS_5debug15TraceBucketDataEEEENS_8CallbackINS_8internal9BindStateINS7_13FunctorTraitsIT_E12RunnableTypeENSB_7RunTypeEFvvEE14UnboundRunTypeEEESA_
Line
Count
Source
78
3
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
3
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
3
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
3
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
3
  return Callback<typename BindState::UnboundRunType>(
87
3
      new BindState(internal::MakeRunnable(functor)));
88
3
}
_ZN2yb4BindIPFyvEEENS_8CallbackINS_8internal9BindStateINS4_13FunctorTraitsIT_E12RunnableTypeENS8_7RunTypeEFvvEE14UnboundRunTypeEEES7_
Line
Count
Source
78
87.5k
Bind(Functor functor) {
79
  // Typedefs for how to store and run the functor.
80
87.5k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
81
87.5k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
82
83
87.5k
  typedef internal::BindState<RunnableType, RunType, void()> BindState;
84
85
86
87.5k
  return Callback<typename BindState::UnboundRunType>(
87
87.5k
      new BindState(internal::MakeRunnable(functor)));
88
87.5k
}
89
90
template <typename Functor, typename P1>
91
Callback<
92
    typename internal::BindState<
93
        typename internal::FunctorTraits<Functor>::RunnableType,
94
        typename internal::FunctorTraits<Functor>::RunType,
95
        void(typename internal::CallbackParamTraits<P1>::StorageType)>
96
            ::UnboundRunType>
97
1.60M
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
1.60M
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
1.60M
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
1.60M
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
1.60M
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
1.60M
  COMPILE_ASSERT(
114
1.60M
      !(base::is_non_const_reference<typename
115
1.60M
          BoundFunctorTraits::A1Type>::value ),
116
1.60M
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
1.60M
  COMPILE_ASSERT(
123
1.60M
      internal::HasIsMethodTag<RunnableType>::value ||
124
1.60M
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
1.60M
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
1.60M
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
1.60M
                     !base::is_array<P1>::value,
128
1.60M
                 first_bound_argument_to_method_cannot_be_array);
129
1.60M
  typedef internal::BindState<RunnableType, RunType,
130
1.60M
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
1.60M
  return Callback<typename BindState::UnboundRunType>(
134
1.60M
      new BindState(internal::MakeRunnable(functor), p1));
135
1.60M
}
_ZN2yb4BindIPFvRKNSt3__110shared_ptrINS_9consensus12ReplicateMsgEEERKNS_6StatusEES5_EENS_8CallbackINS_8internal9BindStateINSE_13FunctorTraitsIT_E12RunnableTypeENSI_7RunTypeEFvNSE_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISM_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESH_RKSM_
Line
Count
Source
97
250
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
250
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
250
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
250
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
250
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
250
  COMPILE_ASSERT(
114
250
      !(base::is_non_const_reference<typename
115
250
          BoundFunctorTraits::A1Type>::value ),
116
250
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
250
  COMPILE_ASSERT(
123
250
      internal::HasIsMethodTag<RunnableType>::value ||
124
250
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
250
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
250
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
250
                     !base::is_array<P1>::value,
128
250
                 first_bound_argument_to_method_cannot_be_array);
129
250
  typedef internal::BindState<RunnableType, RunType,
130
250
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
250
  return Callback<typename BindState::UnboundRunType>(
134
250
      new BindState(internal::MakeRunnable(functor), p1));
135
250
}
mt-log-test.cc:_ZN2yb4BindIMNS_3log12_GLOBAL__N_119CustomLatchCallbackEFvRKNS_6StatusEEPS3_EENS_8CallbackINS_8internal9BindStateINSB_13FunctorTraitsIT_E12RunnableTypeENSF_7RunTypeEFvNSB_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISJ_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESE_RKSJ_
Line
Count
Source
97
2.00k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
2.00k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
2.00k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
2.00k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
2.00k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
2.00k
  COMPILE_ASSERT(
114
2.00k
      !(base::is_non_const_reference<typename
115
2.00k
          BoundFunctorTraits::A1Type>::value ),
116
2.00k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
2.00k
  COMPILE_ASSERT(
123
2.00k
      internal::HasIsMethodTag<RunnableType>::value ||
124
2.00k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
2.00k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
2.00k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
2.00k
                     !base::is_array<P1>::value,
128
2.00k
                 first_bound_argument_to_method_cannot_be_array);
129
2.00k
  typedef internal::BindState<RunnableType, RunType,
130
2.00k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
2.00k
  return Callback<typename BindState::UnboundRunType>(
134
2.00k
      new BindState(internal::MakeRunnable(functor), p1));
135
2.00k
}
_ZN2yb4BindIPFvPNS_12SynchronizerERKNS_6StatusERKNS_8HostPortEES2_EENS_8CallbackINS_8internal9BindStateINSC_13FunctorTraitsIT_E12RunnableTypeENSG_7RunTypeEFvNSC_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISK_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESF_RKSK_
Line
Count
Source
97
395k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
395k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
395k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
395k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
395k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
395k
  COMPILE_ASSERT(
114
395k
      !(base::is_non_const_reference<typename
115
395k
          BoundFunctorTraits::A1Type>::value ),
116
395k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
395k
  COMPILE_ASSERT(
123
395k
      internal::HasIsMethodTag<RunnableType>::value ||
124
395k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
395k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
395k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
395k
                     !base::is_array<P1>::value,
128
395k
                 first_bound_argument_to_method_cannot_be_array);
129
395k
  typedef internal::BindState<RunnableType, RunType,
130
395k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
395k
  return Callback<typename BindState::UnboundRunType>(
134
395k
      new BindState(internal::MakeRunnable(functor), p1));
135
395k
}
_ZN2yb4BindIMNS_12SynchronizerEFvRKNS_6StatusEENS_8internal17UnretainedWrapperIS1_EEEENS_8CallbackINS7_9BindStateINS7_13FunctorTraitsIT_E12RunnableTypeENSE_7RunTypeEFvNS7_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISI_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESD_RKSI_
Line
Count
Source
97
854k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
854k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
854k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
854k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
854k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
854k
  COMPILE_ASSERT(
114
854k
      !(base::is_non_const_reference<typename
115
854k
          BoundFunctorTraits::A1Type>::value ),
116
854k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
854k
  COMPILE_ASSERT(
123
854k
      internal::HasIsMethodTag<RunnableType>::value ||
124
854k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
854k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
854k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
854k
                     !base::is_array<P1>::value,
128
854k
                 first_bound_argument_to_method_cannot_be_array);
129
854k
  typedef internal::BindState<RunnableType, RunType,
130
854k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
854k
  return Callback<typename BindState::UnboundRunType>(
134
854k
      new BindState(internal::MakeRunnable(functor), p1));
135
854k
}
_ZN2yb4BindIMNS_3RefEFivE13scoped_refptrIS1_EEENS_8CallbackINS_8internal9BindStateINS7_13FunctorTraitsIT_E12RunnableTypeENSB_7RunTypeEFvNS7_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISF_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESA_RKSF_
Line
Count
Source
97
1
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
1
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
1
  COMPILE_ASSERT(
114
1
      !(base::is_non_const_reference<typename
115
1
          BoundFunctorTraits::A1Type>::value ),
116
1
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
1
  COMPILE_ASSERT(
123
1
      internal::HasIsMethodTag<RunnableType>::value ||
124
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
1
                     !base::is_array<P1>::value,
128
1
                 first_bound_argument_to_method_cannot_be_array);
129
1
  typedef internal::BindState<RunnableType, RunType,
130
1
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
1
  return Callback<typename BindState::UnboundRunType>(
134
1
      new BindState(internal::MakeRunnable(functor), p1));
135
1
}
_ZN2yb4BindIPFiiPKcEiEENS_8CallbackINS_8internal9BindStateINS6_13FunctorTraitsIT_E12RunnableTypeENSA_7RunTypeEFvNS6_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISE_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES9_RKSE_
Line
Count
Source
97
1
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
1
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
1
  COMPILE_ASSERT(
114
1
      !(base::is_non_const_reference<typename
115
1
          BoundFunctorTraits::A1Type>::value ),
116
1
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
1
  COMPILE_ASSERT(
123
1
      internal::HasIsMethodTag<RunnableType>::value ||
124
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
1
                     !base::is_array<P1>::value,
128
1
                 first_bound_argument_to_method_cannot_be_array);
129
1
  typedef internal::BindState<RunnableType, RunType,
130
1
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
1
  return Callback<typename BindState::UnboundRunType>(
134
1
      new BindState(internal::MakeRunnable(functor), p1));
135
1
}
_ZN2yb4BindIMNS_12RefCountableEKFvvEPS1_EENS_8CallbackINS_8internal9BindStateINS6_13FunctorTraitsIT_E12RunnableTypeENSA_7RunTypeEFvNS6_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISE_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES9_RKSE_
Line
Count
Source
97
1
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
1
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
1
  COMPILE_ASSERT(
114
1
      !(base::is_non_const_reference<typename
115
1
          BoundFunctorTraits::A1Type>::value ),
116
1
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
1
  COMPILE_ASSERT(
123
1
      internal::HasIsMethodTag<RunnableType>::value ||
124
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
1
                     !base::is_array<P1>::value,
128
1
                 first_bound_argument_to_method_cannot_be_array);
129
1
  typedef internal::BindState<RunnableType, RunType,
130
1
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
1
  return Callback<typename BindState::UnboundRunType>(
134
1
      new BindState(internal::MakeRunnable(functor), p1));
135
1
}
_ZN2yb4BindIMNS_19FailureDetectorTestEFvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_6StatusEENS_8internal17UnretainedWrapperINS_43FailureDetectorTest_TestDetectsFailure_TestEEEEENS_8CallbackINSG_9BindStateINSG_13FunctorTraitsIT_E12RunnableTypeENSO_7RunTypeEFvNSG_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISS_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESN_RKSS_
Line
Count
Source
97
1
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
1
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
1
  COMPILE_ASSERT(
114
1
      !(base::is_non_const_reference<typename
115
1
          BoundFunctorTraits::A1Type>::value ),
116
1
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
1
  COMPILE_ASSERT(
123
1
      internal::HasIsMethodTag<RunnableType>::value ||
124
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
1
                     !base::is_array<P1>::value,
128
1
                 first_bound_argument_to_method_cannot_be_array);
129
1
  typedef internal::BindState<RunnableType, RunType,
130
1
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
1
  return Callback<typename BindState::UnboundRunType>(
134
1
      new BindState(internal::MakeRunnable(functor), p1));
135
1
}
_ZN2yb4BindIPFxPiENS_8internal17UnretainedWrapperIiEEEENS_8CallbackINS4_9BindStateINS4_13FunctorTraitsIT_E12RunnableTypeENSB_7RunTypeEFvNS4_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISF_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESA_RKSF_
Line
Count
Source
97
3
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
3
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
3
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
3
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
3
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
3
  COMPILE_ASSERT(
114
3
      !(base::is_non_const_reference<typename
115
3
          BoundFunctorTraits::A1Type>::value ),
116
3
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
3
  COMPILE_ASSERT(
123
3
      internal::HasIsMethodTag<RunnableType>::value ||
124
3
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
3
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
3
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
3
                     !base::is_array<P1>::value,
128
3
                 first_bound_argument_to_method_cannot_be_array);
129
3
  typedef internal::BindState<RunnableType, RunType,
130
3
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
3
  return Callback<typename BindState::UnboundRunType>(
134
3
      new BindState(internal::MakeRunnable(functor), p1));
135
3
}
_ZN2yb4BindIPFxxExEENS_8CallbackINS_8internal9BindStateINS4_13FunctorTraitsIT_E12RunnableTypeENS8_7RunTypeEFvNS4_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISC_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES7_RKSC_
Line
Count
Source
97
133
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
133
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
133
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
133
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
133
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
133
  COMPILE_ASSERT(
114
133
      !(base::is_non_const_reference<typename
115
133
          BoundFunctorTraits::A1Type>::value ),
116
133
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
133
  COMPILE_ASSERT(
123
133
      internal::HasIsMethodTag<RunnableType>::value ||
124
133
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
133
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
133
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
133
                     !base::is_array<P1>::value,
128
133
                 first_bound_argument_to_method_cannot_be_array);
129
133
  typedef internal::BindState<RunnableType, RunType,
130
133
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
133
  return Callback<typename BindState::UnboundRunType>(
134
133
      new BindState(internal::MakeRunnable(functor), p1));
135
133
}
_ZN2yb4BindIMNS_3log3LogEFvvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
96.9k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
96.9k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
96.9k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
96.9k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
96.9k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
96.9k
  COMPILE_ASSERT(
114
96.9k
      !(base::is_non_const_reference<typename
115
96.9k
          BoundFunctorTraits::A1Type>::value ),
116
96.9k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
96.9k
  COMPILE_ASSERT(
123
96.9k
      internal::HasIsMethodTag<RunnableType>::value ||
124
96.9k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
96.9k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
96.9k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
96.9k
                     !base::is_array<P1>::value,
128
96.9k
                 first_bound_argument_to_method_cannot_be_array);
129
96.9k
  typedef internal::BindState<RunnableType, RunType,
130
96.9k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
96.9k
  return Callback<typename BindState::UnboundRunType>(
134
96.9k
      new BindState(internal::MakeRunnable(functor), p1));
135
96.9k
}
_ZN2yb4BindIMNS_6master14CatalogManagerEFNS_6StatusEvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS6_9BindStateINS6_13FunctorTraitsIT_E12RunnableTypeENSD_7RunTypeEFvNS6_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISH_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESC_RKSH_
Line
Count
Source
97
5.45k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
5.45k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
5.45k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
5.45k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
5.45k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
5.45k
  COMPILE_ASSERT(
114
5.45k
      !(base::is_non_const_reference<typename
115
5.45k
          BoundFunctorTraits::A1Type>::value ),
116
5.45k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
5.45k
  COMPILE_ASSERT(
123
5.45k
      internal::HasIsMethodTag<RunnableType>::value ||
124
5.45k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
5.45k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
5.45k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
5.45k
                     !base::is_array<P1>::value,
128
5.45k
                 first_bound_argument_to_method_cannot_be_array);
129
5.45k
  typedef internal::BindState<RunnableType, RunType,
130
5.45k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
5.45k
  return Callback<typename BindState::UnboundRunType>(
134
5.45k
      new BindState(internal::MakeRunnable(functor), p1));
135
5.45k
}
_ZN2yb4BindIMNS_6master14CatalogManagerEFvvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
2.01k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
2.01k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
2.01k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
2.01k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
2.01k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
2.01k
  COMPILE_ASSERT(
114
2.01k
      !(base::is_non_const_reference<typename
115
2.01k
          BoundFunctorTraits::A1Type>::value ),
116
2.01k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
2.01k
  COMPILE_ASSERT(
123
2.01k
      internal::HasIsMethodTag<RunnableType>::value ||
124
2.01k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
2.01k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
2.01k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
2.01k
                     !base::is_array<P1>::value,
128
2.01k
                 first_bound_argument_to_method_cannot_be_array);
129
2.01k
  typedef internal::BindState<RunnableType, RunType,
130
2.01k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
2.01k
  return Callback<typename BindState::UnboundRunType>(
134
2.01k
      new BindState(internal::MakeRunnable(functor), p1));
135
2.01k
}
_ZN2yb4BindIMNS_6master6MasterEFvvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
5.42k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
5.42k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
5.42k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
5.42k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
5.42k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
5.42k
  COMPILE_ASSERT(
114
5.42k
      !(base::is_non_const_reference<typename
115
5.42k
          BoundFunctorTraits::A1Type>::value ),
116
5.42k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
5.42k
  COMPILE_ASSERT(
123
5.42k
      internal::HasIsMethodTag<RunnableType>::value ||
124
5.42k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
5.42k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
5.42k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
5.42k
                     !base::is_array<P1>::value,
128
5.42k
                 first_bound_argument_to_method_cannot_be_array);
129
5.42k
  typedef internal::BindState<RunnableType, RunType,
130
5.42k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
5.42k
  return Callback<typename BindState::UnboundRunType>(
134
5.42k
      new BindState(internal::MakeRunnable(functor), p1));
135
5.42k
}
_ZN2yb4BindIMNS_6server11HybridClockEFyvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
34.2k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
34.2k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
34.2k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
34.2k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
34.2k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
34.2k
  COMPILE_ASSERT(
114
34.2k
      !(base::is_non_const_reference<typename
115
34.2k
          BoundFunctorTraits::A1Type>::value ),
116
34.2k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
34.2k
  COMPILE_ASSERT(
123
34.2k
      internal::HasIsMethodTag<RunnableType>::value ||
124
34.2k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
34.2k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
34.2k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
34.2k
                     !base::is_array<P1>::value,
128
34.2k
                 first_bound_argument_to_method_cannot_be_array);
129
34.2k
  typedef internal::BindState<RunnableType, RunType,
130
34.2k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
34.2k
  return Callback<typename BindState::UnboundRunType>(
134
34.2k
      new BindState(internal::MakeRunnable(functor), p1));
135
34.2k
}
_ZN2yb4BindIPFyyEyEENS_8CallbackINS_8internal9BindStateINS4_13FunctorTraitsIT_E12RunnableTypeENS8_7RunTypeEFvNS4_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISC_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES7_RKSC_
Line
Count
Source
97
286
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
286
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
286
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
286
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
286
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
286
  COMPILE_ASSERT(
114
286
      !(base::is_non_const_reference<typename
115
286
          BoundFunctorTraits::A1Type>::value ),
116
286
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
286
  COMPILE_ASSERT(
123
286
      internal::HasIsMethodTag<RunnableType>::value ||
124
286
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
286
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
286
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
286
                     !base::is_array<P1>::value,
128
286
                 first_bound_argument_to_method_cannot_be_array);
129
286
  typedef internal::BindState<RunnableType, RunType,
130
286
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
286
  return Callback<typename BindState::UnboundRunType>(
134
286
      new BindState(internal::MakeRunnable(functor), p1));
135
286
}
_ZN2yb4BindIMNS_6server11HybridClockEFxvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
17.1k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
17.1k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
17.1k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
17.1k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
17.1k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
17.1k
  COMPILE_ASSERT(
114
17.1k
      !(base::is_non_const_reference<typename
115
17.1k
          BoundFunctorTraits::A1Type>::value ),
116
17.1k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
17.1k
  COMPILE_ASSERT(
123
17.1k
      internal::HasIsMethodTag<RunnableType>::value ||
124
17.1k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
17.1k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
17.1k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
17.1k
                     !base::is_array<P1>::value,
128
17.1k
                 first_bound_argument_to_method_cannot_be_array);
129
17.1k
  typedef internal::BindState<RunnableType, RunType,
130
17.1k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
17.1k
  return Callback<typename BindState::UnboundRunType>(
134
17.1k
      new BindState(internal::MakeRunnable(functor), p1));
135
17.1k
}
_ZN2yb4BindIMNS_6server12LogicalClockEFyvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
72
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
72
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
72
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
72
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
72
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
72
  COMPILE_ASSERT(
114
72
      !(base::is_non_const_reference<typename
115
72
          BoundFunctorTraits::A1Type>::value ),
116
72
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
72
  COMPILE_ASSERT(
123
72
      internal::HasIsMethodTag<RunnableType>::value ||
124
72
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
72
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
72
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
72
                     !base::is_array<P1>::value,
128
72
                 first_bound_argument_to_method_cannot_be_array);
129
72
  typedef internal::BindState<RunnableType, RunType,
130
72
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
72
  return Callback<typename BindState::UnboundRunType>(
134
72
      new BindState(internal::MakeRunnable(functor), p1));
135
72
}
_ZN2yb4BindIPFyPKcENS_8internal17UnretainedWrapperIS1_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
105k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
105k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
105k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
105k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
105k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
105k
  COMPILE_ASSERT(
114
105k
      !(base::is_non_const_reference<typename
115
105k
          BoundFunctorTraits::A1Type>::value ),
116
105k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
105k
  COMPILE_ASSERT(
123
105k
      internal::HasIsMethodTag<RunnableType>::value ||
124
105k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
105k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
105k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
105k
                     !base::is_array<P1>::value,
128
105k
                 first_bound_argument_to_method_cannot_be_array);
129
105k
  typedef internal::BindState<RunnableType, RunType,
130
105k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
105k
  return Callback<typename BindState::UnboundRunType>(
134
105k
      new BindState(internal::MakeRunnable(functor), p1));
135
105k
}
heartbeater.cc:_ZN2yb4BindIPFvRKNSt3__110shared_ptrINS_7tserver12_GLOBAL__N_120FindLeaderMasterDataEEERKNS_6StatusERKNS_8HostPortEES6_EENS_8CallbackINS_8internal9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSM_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISQ_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESL_RKSQ_
Line
Count
Source
97
5.72k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
5.72k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
5.72k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
5.72k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
5.72k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
5.72k
  COMPILE_ASSERT(
114
5.72k
      !(base::is_non_const_reference<typename
115
5.72k
          BoundFunctorTraits::A1Type>::value ),
116
5.72k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
5.72k
  COMPILE_ASSERT(
123
5.72k
      internal::HasIsMethodTag<RunnableType>::value ||
124
5.72k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
5.72k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
5.72k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
5.72k
                     !base::is_array<P1>::value,
128
5.72k
                 first_bound_argument_to_method_cannot_be_array);
129
5.72k
  typedef internal::BindState<RunnableType, RunType,
130
5.72k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
5.72k
  return Callback<typename BindState::UnboundRunType>(
134
5.72k
      new BindState(internal::MakeRunnable(functor), p1));
135
5.72k
}
_ZN2yb4BindIMNS_9cqlserver12CQLProcessorEFvRKNS_6StatusERKNSt3__110shared_ptrINS_2ql14ExecutedResultEEEENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINSF_9BindStateINSF_13FunctorTraitsIT_E12RunnableTypeENSM_7RunTypeEFvNSF_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISQ_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESL_RKSQ_
Line
Count
Source
97
16.9k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
16.9k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
16.9k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
16.9k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
16.9k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
16.9k
  COMPILE_ASSERT(
114
16.9k
      !(base::is_non_const_reference<typename
115
16.9k
          BoundFunctorTraits::A1Type>::value ),
116
16.9k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
16.9k
  COMPILE_ASSERT(
123
16.9k
      internal::HasIsMethodTag<RunnableType>::value ||
124
16.9k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
16.9k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
16.9k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
16.9k
                     !base::is_array<P1>::value,
128
16.9k
                 first_bound_argument_to_method_cannot_be_array);
129
16.9k
  typedef internal::BindState<RunnableType, RunType,
130
16.9k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
16.9k
  return Callback<typename BindState::UnboundRunType>(
134
16.9k
      new BindState(internal::MakeRunnable(functor), p1));
135
16.9k
}
Unexecuted instantiation: _ZN2yb4BindIPFvPNS_6client17YBLoggingCallbackENS_11LogSeverityEPKciPK2tmS6_mENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINSC_9BindStateINSC_13FunctorTraitsIT_E12RunnableTypeENSJ_7RunTypeEFvNSC_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISN_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESI_RKSN_
_ZN2yb4BindIMNS_6client8YBClient4DataEFvRKNS_6StatusERKNS_8HostPortEENS_8internal17UnretainedWrapperIS3_EEEENS_8CallbackINSC_9BindStateINSC_13FunctorTraitsIT_E12RunnableTypeENSJ_7RunTypeEFvNSC_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISN_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESI_RKSN_
Line
Count
Source
97
29.0k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
29.0k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
29.0k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
29.0k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
29.0k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
29.0k
  COMPILE_ASSERT(
114
29.0k
      !(base::is_non_const_reference<typename
115
29.0k
          BoundFunctorTraits::A1Type>::value ),
116
29.0k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
29.0k
  COMPILE_ASSERT(
123
29.0k
      internal::HasIsMethodTag<RunnableType>::value ||
124
29.0k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
29.0k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
29.0k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
29.0k
                     !base::is_array<P1>::value,
128
29.0k
                 first_bound_argument_to_method_cannot_be_array);
129
29.0k
  typedef internal::BindState<RunnableType, RunType,
130
29.0k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
29.0k
  return Callback<typename BindState::UnboundRunType>(
134
29.0k
      new BindState(internal::MakeRunnable(functor), p1));
135
29.0k
}
_ZN2yb4BindIMNS_5debug17TraceResultBufferEFvRK13scoped_refptrINS_16RefCountedStringEEbENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINSA_9BindStateINSA_13FunctorTraitsIT_E12RunnableTypeENSH_7RunTypeEFvNSA_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISL_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESG_RKSL_
Line
Count
Source
97
23
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
23
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
23
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
23
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
23
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
23
  COMPILE_ASSERT(
114
23
      !(base::is_non_const_reference<typename
115
23
          BoundFunctorTraits::A1Type>::value ),
116
23
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
23
  COMPILE_ASSERT(
123
23
      internal::HasIsMethodTag<RunnableType>::value ||
124
23
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
23
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
23
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
23
                     !base::is_array<P1>::value,
128
23
                 first_bound_argument_to_method_cannot_be_array);
129
23
  typedef internal::BindState<RunnableType, RunType,
130
23
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
23
  return Callback<typename BindState::UnboundRunType>(
134
23
      new BindState(internal::MakeRunnable(functor), p1));
135
23
}
_ZN2yb4BindIMNS_5debug8TraceLogEFvvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
8
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
8
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
8
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
8
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
8
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
8
  COMPILE_ASSERT(
114
8
      !(base::is_non_const_reference<typename
115
8
          BoundFunctorTraits::A1Type>::value ),
116
8
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
8
  COMPILE_ASSERT(
123
8
      internal::HasIsMethodTag<RunnableType>::value ||
124
8
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
8
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
8
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
8
                     !base::is_array<P1>::value,
128
8
                 first_bound_argument_to_method_cannot_be_array);
129
8
  typedef internal::BindState<RunnableType, RunType,
130
8
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
8
  return Callback<typename BindState::UnboundRunType>(
134
8
      new BindState(internal::MakeRunnable(functor), p1));
135
8
}
thread.cc:_ZN2yb4BindIMNS_12_GLOBAL__N_19ThreadMgrEFyvENS_8internal17UnretainedWrapperIS2_EEEENS_8CallbackINS5_9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENSC_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESB_RKSG_
Line
Count
Source
97
35.0k
Bind(Functor functor, const P1& p1) {
98
  // Typedefs for how to store and run the functor.
99
35.0k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
100
35.0k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
101
102
  // Use RunnableType::RunType instead of RunType above because our
103
  // checks should below for bound references need to know what the actual
104
  // functor is going to interpret the argument as.
105
35.0k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
106
35.0k
      BoundFunctorTraits;
107
108
  // Do not allow binding a non-const reference parameter. Non-const reference
109
  // parameters are disallowed by the Google style guide.  Also, binding a
110
  // non-const reference parameter can make for subtle bugs because the
111
  // invoked function will receive a reference to the stored copy of the
112
  // argument and not the original.
113
35.0k
  COMPILE_ASSERT(
114
35.0k
      !(base::is_non_const_reference<typename
115
35.0k
          BoundFunctorTraits::A1Type>::value ),
116
35.0k
      do_not_bind_functions_with_nonconst_ref);
117
118
  // For methods, we need to be careful for parameter 1.  We do not require
119
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
120
  // methods. We also disallow binding of an array as the method's target
121
  // object.
122
35.0k
  COMPILE_ASSERT(
123
35.0k
      internal::HasIsMethodTag<RunnableType>::value ||
124
35.0k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
125
35.0k
      p1_is_refcounted_type_and_needs_scoped_refptr);
126
35.0k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
127
35.0k
                     !base::is_array<P1>::value,
128
35.0k
                 first_bound_argument_to_method_cannot_be_array);
129
35.0k
  typedef internal::BindState<RunnableType, RunType,
130
35.0k
      void(typename internal::CallbackParamTraits<P1>::StorageType)> BindState;
131
132
133
35.0k
  return Callback<typename BindState::UnboundRunType>(
134
35.0k
      new BindState(internal::MakeRunnable(functor), p1));
135
35.0k
}
Unexecuted instantiation: _ZN2yb4BindIPFvNSt3__18weak_ptrINS_12SynchronizerEEERKNS_6StatusEES4_EENS_8CallbackINS_8internal9BindStateINSB_13FunctorTraitsIT_E12RunnableTypeENSF_7RunTypeEFvNSB_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISJ_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESE_RKSJ_
136
137
template <typename Functor, typename P1, typename P2>
138
Callback<
139
    typename internal::BindState<
140
        typename internal::FunctorTraits<Functor>::RunnableType,
141
        typename internal::FunctorTraits<Functor>::RunType,
142
        void(typename internal::CallbackParamTraits<P1>::StorageType,
143
            typename internal::CallbackParamTraits<P2>::StorageType)>
144
            ::UnboundRunType>
145
28.5M
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
28.5M
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
28.5M
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
28.5M
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
28.5M
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
28.5M
  COMPILE_ASSERT(
162
28.5M
      !(base::is_non_const_reference<typename
163
28.5M
          BoundFunctorTraits::A1Type>::value ||
164
28.5M
          base::is_non_const_reference<typename
165
28.5M
          BoundFunctorTraits::A2Type>::value ),
166
28.5M
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
28.5M
  COMPILE_ASSERT(
173
28.5M
      internal::HasIsMethodTag<RunnableType>::value ||
174
28.5M
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
28.5M
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
28.5M
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
28.5M
                     !base::is_array<P1>::value,
178
28.5M
                 first_bound_argument_to_method_cannot_be_array);
179
28.5M
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
28.5M
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
28.5M
  typedef internal::BindState<RunnableType, RunType,
182
28.5M
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
28.5M
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
28.5M
  return Callback<typename BindState::UnboundRunType>(
187
28.5M
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
28.5M
}
_ZN2yb4BindIMNS_6master25SystemTableFaultToleranceEFvNS_8CallbackIFvRKNS_6StatusEEEES6_RKNSt3__110shared_ptrINS_2ql14ExecutedResultEEEENS_8internal17UnretainedWrapperINS1_49SystemTableFaultTolerance_TestFaultTolerance_TestEEES8_EENS3_INSI_9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSP_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIST_EE5valueEE11StorageTypeENSS_IT1_Xsr14IsMoveOnlyTypeISW_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESO_RKST_RKSW_
Line
Count
Source
145
1
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
1
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
1
  COMPILE_ASSERT(
162
1
      !(base::is_non_const_reference<typename
163
1
          BoundFunctorTraits::A1Type>::value ||
164
1
          base::is_non_const_reference<typename
165
1
          BoundFunctorTraits::A2Type>::value ),
166
1
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
1
  COMPILE_ASSERT(
173
1
      internal::HasIsMethodTag<RunnableType>::value ||
174
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
1
                     !base::is_array<P1>::value,
178
1
                 first_bound_argument_to_method_cannot_be_array);
179
1
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
1
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
1
  typedef internal::BindState<RunnableType, RunType,
182
1
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
1
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
1
  return Callback<typename BindState::UnboundRunType>(
187
1
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
1
}
Unexecuted instantiation: _ZN2yb4BindIMNS_2ql15TestQLStatementEFvNS_8CallbackIFvRKNS_6StatusEEEES6_RKNSt3__110shared_ptrINS1_14ExecutedResultEEEENS_8internal17UnretainedWrapperIS2_EES8_EENS3_INSH_9BindStateINSH_13FunctorTraitsIT_E12RunnableTypeENSN_7RunTypeEFvNSH_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISR_EE5valueEE11StorageTypeENSQ_IT1_Xsr14IsMoveOnlyTypeISU_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESM_RKSR_RKSU_
_ZN2yb4BindIMNS_6tablet14TabletPeerTestEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_10shared_ptrINS_9consensus18StateChangeContextEEEENS_8internal17UnretainedWrapperIS2_EES9_EENS_8CallbackINSI_9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSP_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIST_EE5valueEE11StorageTypeENSS_IT1_Xsr14IsMoveOnlyTypeISW_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESO_RKST_RKSW_
Line
Count
Source
145
4
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
4
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
4
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
4
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
4
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
4
  COMPILE_ASSERT(
162
4
      !(base::is_non_const_reference<typename
163
4
          BoundFunctorTraits::A1Type>::value ||
164
4
          base::is_non_const_reference<typename
165
4
          BoundFunctorTraits::A2Type>::value ),
166
4
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
4
  COMPILE_ASSERT(
173
4
      internal::HasIsMethodTag<RunnableType>::value ||
174
4
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
4
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
4
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
4
                     !base::is_array<P1>::value,
178
4
                 first_bound_argument_to_method_cannot_be_array);
179
4
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
4
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
4
  typedef internal::BindState<RunnableType, RunType,
182
4
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
4
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
4
  return Callback<typename BindState::UnboundRunType>(
187
4
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
4
}
_ZN2yb4BindIPFvPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcES8_NS_8internal17UnretainedWrapperIS9_EEEENS_8CallbackINSD_9BindStateINSD_13FunctorTraitsIT_E12RunnableTypeENSK_7RunTypeEFvNSD_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISO_EE5valueEE11StorageTypeENSN_IT1_Xsr14IsMoveOnlyTypeISR_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESJ_RKSO_RKSR_
Line
Count
Source
145
2
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
2
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
2
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
2
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
2
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
2
  COMPILE_ASSERT(
162
2
      !(base::is_non_const_reference<typename
163
2
          BoundFunctorTraits::A1Type>::value ||
164
2
          base::is_non_const_reference<typename
165
2
          BoundFunctorTraits::A2Type>::value ),
166
2
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
2
  COMPILE_ASSERT(
173
2
      internal::HasIsMethodTag<RunnableType>::value ||
174
2
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
2
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
2
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
2
                     !base::is_array<P1>::value,
178
2
                 first_bound_argument_to_method_cannot_be_array);
179
2
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
2
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
2
  typedef internal::BindState<RunnableType, RunType,
182
2
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
2
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
2
  return Callback<typename BindState::UnboundRunType>(
187
2
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
2
}
_ZN2yb4BindIPFviPiEiS1_EENS_8CallbackINS_8internal9BindStateINS5_13FunctorTraitsIT_E12RunnableTypeENS9_7RunTypeEFvNS5_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISD_EE5valueEE11StorageTypeENSC_IT1_Xsr14IsMoveOnlyTypeISG_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES8_RKSD_RKSG_
Line
Count
Source
145
1
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
1
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
1
  COMPILE_ASSERT(
162
1
      !(base::is_non_const_reference<typename
163
1
          BoundFunctorTraits::A1Type>::value ||
164
1
          base::is_non_const_reference<typename
165
1
          BoundFunctorTraits::A2Type>::value ),
166
1
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
1
  COMPILE_ASSERT(
173
1
      internal::HasIsMethodTag<RunnableType>::value ||
174
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
1
                     !base::is_array<P1>::value,
178
1
                 first_bound_argument_to_method_cannot_be_array);
179
1
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
1
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
1
  typedef internal::BindState<RunnableType, RunType,
182
1
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
1
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
1
  return Callback<typename BindState::UnboundRunType>(
187
1
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
1
}
_ZN2yb4BindIMNS_7PromiseIiEEFvRKiENS_8internal17UnretainedWrapperIS2_EEiEENS_8CallbackINS7_9BindStateINS7_13FunctorTraitsIT_E12RunnableTypeENSE_7RunTypeEFvNS7_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISI_EE5valueEE11StorageTypeENSH_IT1_Xsr14IsMoveOnlyTypeISL_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESD_RKSI_RKSL_
Line
Count
Source
145
1
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
1
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
1
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
1
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
1
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
1
  COMPILE_ASSERT(
162
1
      !(base::is_non_const_reference<typename
163
1
          BoundFunctorTraits::A1Type>::value ||
164
1
          base::is_non_const_reference<typename
165
1
          BoundFunctorTraits::A2Type>::value ),
166
1
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
1
  COMPILE_ASSERT(
173
1
      internal::HasIsMethodTag<RunnableType>::value ||
174
1
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
1
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
1
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
1
                     !base::is_array<P1>::value,
178
1
                 first_bound_argument_to_method_cannot_be_array);
179
1
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
1
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
1
  typedef internal::BindState<RunnableType, RunType,
182
1
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
1
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
1
  return Callback<typename BindState::UnboundRunType>(
187
1
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
1
}
_ZN2yb4BindIMNS_9consensus16PeerMessageQueueEFvRKNS_4OpIdERKNS_6StatusEENS_8internal17UnretainedWrapperIS2_EES3_EENS_8CallbackINSB_9BindStateINSB_13FunctorTraitsIT_E12RunnableTypeENSI_7RunTypeEFvNSB_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISM_EE5valueEE11StorageTypeENSL_IT1_Xsr14IsMoveOnlyTypeISP_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESH_RKSM_RKSP_
Line
Count
Source
145
13.1M
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
13.1M
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
13.1M
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
13.1M
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
13.1M
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
13.1M
  COMPILE_ASSERT(
162
13.1M
      !(base::is_non_const_reference<typename
163
13.1M
          BoundFunctorTraits::A1Type>::value ||
164
13.1M
          base::is_non_const_reference<typename
165
13.1M
          BoundFunctorTraits::A2Type>::value ),
166
13.1M
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
13.1M
  COMPILE_ASSERT(
173
13.1M
      internal::HasIsMethodTag<RunnableType>::value ||
174
13.1M
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
13.1M
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
13.1M
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
13.1M
                     !base::is_array<P1>::value,
178
13.1M
                 first_bound_argument_to_method_cannot_be_array);
179
13.1M
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
13.1M
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
13.1M
  typedef internal::BindState<RunnableType, RunType,
182
13.1M
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
13.1M
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
13.1M
  return Callback<typename BindState::UnboundRunType>(
187
13.1M
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
13.1M
}
_ZN2yb4BindIMNS_9consensus16PeerMessageQueueEFvRKNS1_22MajorityReplicatedDataEENS_8internal17UnretainedWrapperIS2_EES3_EENS_8CallbackINS8_9BindStateINS8_13FunctorTraitsIT_E12RunnableTypeENSF_7RunTypeEFvNS8_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISJ_EE5valueEE11StorageTypeENSI_IT1_Xsr14IsMoveOnlyTypeISM_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESE_RKSJ_RKSM_
Line
Count
Source
145
15.1M
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
15.1M
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
15.1M
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
15.1M
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
15.1M
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
15.1M
  COMPILE_ASSERT(
162
15.1M
      !(base::is_non_const_reference<typename
163
15.1M
          BoundFunctorTraits::A1Type>::value ||
164
15.1M
          base::is_non_const_reference<typename
165
15.1M
          BoundFunctorTraits::A2Type>::value ),
166
15.1M
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
15.1M
  COMPILE_ASSERT(
173
15.1M
      internal::HasIsMethodTag<RunnableType>::value ||
174
15.1M
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
15.1M
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
15.1M
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
15.1M
                     !base::is_array<P1>::value,
178
15.1M
                 first_bound_argument_to_method_cannot_be_array);
179
15.1M
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
15.1M
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
15.1M
  typedef internal::BindState<RunnableType, RunType,
182
15.1M
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
15.1M
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
15.1M
  return Callback<typename BindState::UnboundRunType>(
187
15.1M
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
15.1M
}
_ZN2yb4BindIPFvPNS_8HostPortEPNS_12SynchronizerERKNS_6StatusERKS1_ES2_S4_EENS_8CallbackINS_8internal9BindStateINSD_13FunctorTraitsIT_E12RunnableTypeENSH_7RunTypeEFvNSD_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISL_EE5valueEE11StorageTypeENSK_IT1_Xsr14IsMoveOnlyTypeISO_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESG_RKSL_RKSO_
Line
Count
Source
145
2.28k
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
2.28k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
2.28k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
2.28k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
2.28k
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
2.28k
  COMPILE_ASSERT(
162
2.28k
      !(base::is_non_const_reference<typename
163
2.28k
          BoundFunctorTraits::A1Type>::value ||
164
2.28k
          base::is_non_const_reference<typename
165
2.28k
          BoundFunctorTraits::A2Type>::value ),
166
2.28k
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
2.28k
  COMPILE_ASSERT(
173
2.28k
      internal::HasIsMethodTag<RunnableType>::value ||
174
2.28k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
2.28k
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
2.28k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
2.28k
                     !base::is_array<P1>::value,
178
2.28k
                 first_bound_argument_to_method_cannot_be_array);
179
2.28k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
2.28k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
2.28k
  typedef internal::BindState<RunnableType, RunType,
182
2.28k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
2.28k
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
2.28k
  return Callback<typename BindState::UnboundRunType>(
187
2.28k
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
2.28k
}
_ZN2yb4BindIMNS_6master15SysCatalogTableEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_10shared_ptrINS_9consensus18StateChangeContextEEEENS_8internal17UnretainedWrapperIS2_EES9_EENS_8CallbackINSI_9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSP_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIST_EE5valueEE11StorageTypeENSS_IT1_Xsr14IsMoveOnlyTypeISW_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESO_RKST_RKSW_
Line
Count
Source
145
5.35k
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
5.35k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
5.35k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
5.35k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
5.35k
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
5.35k
  COMPILE_ASSERT(
162
5.35k
      !(base::is_non_const_reference<typename
163
5.35k
          BoundFunctorTraits::A1Type>::value ||
164
5.35k
          base::is_non_const_reference<typename
165
5.35k
          BoundFunctorTraits::A2Type>::value ),
166
5.35k
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
5.35k
  COMPILE_ASSERT(
173
5.35k
      internal::HasIsMethodTag<RunnableType>::value ||
174
5.35k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
5.35k
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
5.35k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
5.35k
                     !base::is_array<P1>::value,
178
5.35k
                 first_bound_argument_to_method_cannot_be_array);
179
5.35k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
5.35k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
5.35k
  typedef internal::BindState<RunnableType, RunType,
182
5.35k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
5.35k
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
5.35k
  return Callback<typename BindState::UnboundRunType>(
187
5.35k
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
5.35k
}
Unexecuted instantiation: _ZN2yb4BindIMNS_2ql15TestQLProcessorEFvNS_8CallbackIFvRKNS_6StatusEEEES6_RKNSt3__110shared_ptrINS1_14ExecutedResultEEEENS_8internal17UnretainedWrapperIS2_EES8_EENS3_INSH_9BindStateINSH_13FunctorTraitsIT_E12RunnableTypeENSN_7RunTypeEFvNSH_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISR_EE5valueEE11StorageTypeENSQ_IT1_Xsr14IsMoveOnlyTypeISU_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESM_RKSR_RKSU_
_ZN2yb4BindIMNS_7tserver15TSTabletManagerEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_10shared_ptrINS_9consensus18StateChangeContextEEEENS_8internal17UnretainedWrapperIS2_EES9_EENS_8CallbackINSI_9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSP_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIST_EE5valueEE11StorageTypeENSS_IT1_Xsr14IsMoveOnlyTypeISW_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESO_RKST_RKSW_
Line
Count
Source
145
83.3k
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
83.3k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
83.3k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
83.3k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
83.3k
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
83.3k
  COMPILE_ASSERT(
162
83.3k
      !(base::is_non_const_reference<typename
163
83.3k
          BoundFunctorTraits::A1Type>::value ||
164
83.3k
          base::is_non_const_reference<typename
165
83.3k
          BoundFunctorTraits::A2Type>::value ),
166
83.3k
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
83.3k
  COMPILE_ASSERT(
173
83.3k
      internal::HasIsMethodTag<RunnableType>::value ||
174
83.3k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
83.3k
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
83.3k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
83.3k
                     !base::is_array<P1>::value,
178
83.3k
                 first_bound_argument_to_method_cannot_be_array);
179
83.3k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
83.3k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
83.3k
  typedef internal::BindState<RunnableType, RunType,
182
83.3k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
83.3k
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
83.3k
  return Callback<typename BindState::UnboundRunType>(
187
83.3k
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
83.3k
}
_ZN2yb4BindIMNS_7tserver26RemoteBootstrapSessionTestEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS3_10shared_ptrINS_9consensus18StateChangeContextEEEENS_8internal17UnretainedWrapperIS2_EES9_EENS_8CallbackINSI_9BindStateINSI_13FunctorTraitsIT_E12RunnableTypeENSP_7RunTypeEFvNSI_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIST_EE5valueEE11StorageTypeENSS_IT1_Xsr14IsMoveOnlyTypeISW_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESO_RKST_RKSW_
Line
Count
Source
145
4
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
4
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
4
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
4
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
4
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
4
  COMPILE_ASSERT(
162
4
      !(base::is_non_const_reference<typename
163
4
          BoundFunctorTraits::A1Type>::value ||
164
4
          base::is_non_const_reference<typename
165
4
          BoundFunctorTraits::A2Type>::value ),
166
4
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
4
  COMPILE_ASSERT(
173
4
      internal::HasIsMethodTag<RunnableType>::value ||
174
4
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
4
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
4
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
4
                     !base::is_array<P1>::value,
178
4
                 first_bound_argument_to_method_cannot_be_array);
179
4
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
4
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
4
  typedef internal::BindState<RunnableType, RunType,
182
4
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
4
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
4
  return Callback<typename BindState::UnboundRunType>(
187
4
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
4
}
_ZN2yb4BindIPFvPNS_12SynchronizerEPNSt3__110shared_ptrINS_2ql14ExecutedResultEEERKNS_6StatusERKS7_ES2_S8_EENS_8CallbackINS_8internal9BindStateINSH_13FunctorTraitsIT_E12RunnableTypeENSL_7RunTypeEFvNSH_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeISP_EE5valueEE11StorageTypeENSO_IT1_Xsr14IsMoveOnlyTypeISS_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEESK_RKSP_RKSS_
Line
Count
Source
145
181k
Bind(Functor functor, const P1& p1, const P2& p2) {
146
  // Typedefs for how to store and run the functor.
147
181k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
148
181k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
149
150
  // Use RunnableType::RunType instead of RunType above because our
151
  // checks should below for bound references need to know what the actual
152
  // functor is going to interpret the argument as.
153
181k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
154
181k
      BoundFunctorTraits;
155
156
  // Do not allow binding a non-const reference parameter. Non-const reference
157
  // parameters are disallowed by the Google style guide.  Also, binding a
158
  // non-const reference parameter can make for subtle bugs because the
159
  // invoked function will receive a reference to the stored copy of the
160
  // argument and not the original.
161
181k
  COMPILE_ASSERT(
162
181k
      !(base::is_non_const_reference<typename
163
181k
          BoundFunctorTraits::A1Type>::value ||
164
181k
          base::is_non_const_reference<typename
165
181k
          BoundFunctorTraits::A2Type>::value ),
166
181k
      do_not_bind_functions_with_nonconst_ref);
167
168
  // For methods, we need to be careful for parameter 1.  We do not require
169
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
170
  // methods. We also disallow binding of an array as the method's target
171
  // object.
172
181k
  COMPILE_ASSERT(
173
181k
      internal::HasIsMethodTag<RunnableType>::value ||
174
181k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
175
181k
      p1_is_refcounted_type_and_needs_scoped_refptr);
176
181k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
177
181k
                     !base::is_array<P1>::value,
178
181k
                 first_bound_argument_to_method_cannot_be_array);
179
181k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
180
181k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
181
181k
  typedef internal::BindState<RunnableType, RunType,
182
181k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
183
181k
      typename internal::CallbackParamTraits<P2>::StorageType)> BindState;
184
185
186
181k
  return Callback<typename BindState::UnboundRunType>(
187
181k
      new BindState(internal::MakeRunnable(functor), p1, p2));
188
181k
}
189
190
template <typename Functor, typename P1, typename P2, typename P3>
191
Callback<
192
    typename internal::BindState<
193
        typename internal::FunctorTraits<Functor>::RunnableType,
194
        typename internal::FunctorTraits<Functor>::RunType,
195
        void(typename internal::CallbackParamTraits<P1>::StorageType,
196
            typename internal::CallbackParamTraits<P2>::StorageType,
197
            typename internal::CallbackParamTraits<P3>::StorageType)>
198
            ::UnboundRunType>
199
13.1M
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3) {
200
  // Typedefs for how to store and run the functor.
201
13.1M
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
202
13.1M
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
203
204
  // Use RunnableType::RunType instead of RunType above because our
205
  // checks should below for bound references need to know what the actual
206
  // functor is going to interpret the argument as.
207
13.1M
  typedef internal::FunctionTraits<typename RunnableType::RunType>
208
13.1M
      BoundFunctorTraits;
209
210
  // Do not allow binding a non-const reference parameter. Non-const reference
211
  // parameters are disallowed by the Google style guide.  Also, binding a
212
  // non-const reference parameter can make for subtle bugs because the
213
  // invoked function will receive a reference to the stored copy of the
214
  // argument and not the original.
215
13.1M
  COMPILE_ASSERT(
216
13.1M
      !(base::is_non_const_reference<typename
217
13.1M
          BoundFunctorTraits::A1Type>::value ||
218
13.1M
          base::is_non_const_reference<typename
219
13.1M
          BoundFunctorTraits::A2Type>::value ||
220
13.1M
          base::is_non_const_reference<typename
221
13.1M
          BoundFunctorTraits::A3Type>::value ),
222
13.1M
      do_not_bind_functions_with_nonconst_ref);
223
224
  // For methods, we need to be careful for parameter 1.  We do not require
225
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
226
  // methods. We also disallow binding of an array as the method's target
227
  // object.
228
13.1M
  COMPILE_ASSERT(
229
13.1M
      internal::HasIsMethodTag<RunnableType>::value ||
230
13.1M
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
231
13.1M
      p1_is_refcounted_type_and_needs_scoped_refptr);
232
13.1M
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
233
13.1M
                     !base::is_array<P1>::value,
234
13.1M
                 first_bound_argument_to_method_cannot_be_array);
235
13.1M
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
236
13.1M
                 p2_is_refcounted_type_and_needs_scoped_refptr);
237
13.1M
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
238
13.1M
                 p3_is_refcounted_type_and_needs_scoped_refptr);
239
13.1M
  typedef internal::BindState<RunnableType, RunType,
240
13.1M
      void(typename internal::CallbackParamTraits<P1>::StorageType,
241
13.1M
      typename internal::CallbackParamTraits<P2>::StorageType,
242
13.1M
      typename internal::CallbackParamTraits<P3>::StorageType)> BindState;
243
244
245
13.1M
  return Callback<typename BindState::UnboundRunType>(
246
13.1M
      new BindState(internal::MakeRunnable(functor), p1, p2, p3));
247
13.1M
}
248
249
template <typename Functor, typename P1, typename P2, typename P3, typename P4>
250
Callback<
251
    typename internal::BindState<
252
        typename internal::FunctorTraits<Functor>::RunnableType,
253
        typename internal::FunctorTraits<Functor>::RunType,
254
        void(typename internal::CallbackParamTraits<P1>::StorageType,
255
            typename internal::CallbackParamTraits<P2>::StorageType,
256
            typename internal::CallbackParamTraits<P3>::StorageType,
257
            typename internal::CallbackParamTraits<P4>::StorageType)>
258
            ::UnboundRunType>
259
0
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4) {
260
  // Typedefs for how to store and run the functor.
261
0
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
262
0
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
263
264
  // Use RunnableType::RunType instead of RunType above because our
265
  // checks should below for bound references need to know what the actual
266
  // functor is going to interpret the argument as.
267
0
  typedef internal::FunctionTraits<typename RunnableType::RunType>
268
0
      BoundFunctorTraits;
269
270
  // Do not allow binding a non-const reference parameter. Non-const reference
271
  // parameters are disallowed by the Google style guide.  Also, binding a
272
  // non-const reference parameter can make for subtle bugs because the
273
  // invoked function will receive a reference to the stored copy of the
274
  // argument and not the original.
275
0
  COMPILE_ASSERT(
276
0
      !(base::is_non_const_reference<typename
277
0
          BoundFunctorTraits::A1Type>::value ||
278
0
          base::is_non_const_reference<typename
279
0
          BoundFunctorTraits::A2Type>::value ||
280
0
          base::is_non_const_reference<typename
281
0
          BoundFunctorTraits::A3Type>::value ||
282
0
          base::is_non_const_reference<typename
283
0
          BoundFunctorTraits::A4Type>::value ),
284
0
      do_not_bind_functions_with_nonconst_ref);
285
286
  // For methods, we need to be careful for parameter 1.  We do not require
287
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
288
  // methods. We also disallow binding of an array as the method's target
289
  // object.
290
0
  COMPILE_ASSERT(
291
0
      internal::HasIsMethodTag<RunnableType>::value ||
292
0
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
293
0
      p1_is_refcounted_type_and_needs_scoped_refptr);
294
0
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
295
0
                     !base::is_array<P1>::value,
296
0
                 first_bound_argument_to_method_cannot_be_array);
297
0
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
298
0
                 p2_is_refcounted_type_and_needs_scoped_refptr);
299
0
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
300
0
                 p3_is_refcounted_type_and_needs_scoped_refptr);
301
0
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
302
0
                 p4_is_refcounted_type_and_needs_scoped_refptr);
303
0
  typedef internal::BindState<RunnableType, RunType,
304
0
      void(typename internal::CallbackParamTraits<P1>::StorageType,
305
0
      typename internal::CallbackParamTraits<P2>::StorageType,
306
0
      typename internal::CallbackParamTraits<P3>::StorageType,
307
0
      typename internal::CallbackParamTraits<P4>::StorageType)> BindState;
308
309
310
0
  return Callback<typename BindState::UnboundRunType>(
311
0
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4));
312
0
}
Unexecuted instantiation: _ZN2yb4BindIMNS_6master10enterprise14CatalogManagerEFvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS4_10shared_ptrINS4_6vectorINS_6client11YBTableInfoENS8_ISG_EEEEEERKNS4_13unordered_mapISA_SA_NS4_4hashISA_EENS4_8equal_toISA_EENS8_INS4_4pairISB_SA_EEEEEERKNS_6StatusEENS_8internal17UnretainedWrapperIS3_EESA_SJ_SU_EENS_8CallbackINS12_9BindStateINS12_13FunctorTraitsIT_E12RunnableTypeENS19_7RunTypeEFvNS12_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS1D_EE5valueEE11StorageTypeENS1C_IT1_Xsr14IsMoveOnlyTypeIS1G_EE5valueEE11StorageTypeENS1C_IT2_Xsr14IsMoveOnlyTypeIS1J_EE5valueEE11StorageTypeENS1C_IT3_Xsr14IsMoveOnlyTypeIS1M_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES18_RKS1D_RKS1G_RKS1J_RKS1M_
Unexecuted instantiation: _ZN2yb4BindIMNS_6master10enterprise14CatalogManagerEFvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS4_10shared_ptrINS_6client11YBTableInfoEEERKNS4_13unordered_mapISA_SA_NS4_4hashISA_EENS4_8equal_toISA_EENS8_INS4_4pairISB_SA_EEEEEERKNS_6StatusEENS_8internal17UnretainedWrapperIS3_EESA_SG_SR_EENS_8CallbackINSZ_9BindStateINSZ_13FunctorTraitsIT_E12RunnableTypeENS16_7RunTypeEFvNSZ_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS1A_EE5valueEE11StorageTypeENS19_IT1_Xsr14IsMoveOnlyTypeIS1D_EE5valueEE11StorageTypeENS19_IT2_Xsr14IsMoveOnlyTypeIS1G_EE5valueEE11StorageTypeENS19_IT3_Xsr14IsMoveOnlyTypeIS1J_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES15_RKS1A_RKS1D_RKS1G_RKS1J_
313
314
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
315
    typename P5>
316
Callback<
317
    typename internal::BindState<
318
        typename internal::FunctorTraits<Functor>::RunnableType,
319
        typename internal::FunctorTraits<Functor>::RunType,
320
        void(typename internal::CallbackParamTraits<P1>::StorageType,
321
            typename internal::CallbackParamTraits<P2>::StorageType,
322
            typename internal::CallbackParamTraits<P3>::StorageType,
323
            typename internal::CallbackParamTraits<P4>::StorageType,
324
            typename internal::CallbackParamTraits<P5>::StorageType)>
325
            ::UnboundRunType>
326
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
327
334k
    const P5& p5) {
328
  // Typedefs for how to store and run the functor.
329
334k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
330
334k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
331
332
  // Use RunnableType::RunType instead of RunType above because our
333
  // checks should below for bound references need to know what the actual
334
  // functor is going to interpret the argument as.
335
334k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
336
334k
      BoundFunctorTraits;
337
338
  // Do not allow binding a non-const reference parameter. Non-const reference
339
  // parameters are disallowed by the Google style guide.  Also, binding a
340
  // non-const reference parameter can make for subtle bugs because the
341
  // invoked function will receive a reference to the stored copy of the
342
  // argument and not the original.
343
334k
  COMPILE_ASSERT(
344
334k
      !(base::is_non_const_reference<typename
345
334k
          BoundFunctorTraits::A1Type>::value ||
346
334k
          base::is_non_const_reference<typename
347
334k
          BoundFunctorTraits::A2Type>::value ||
348
334k
          base::is_non_const_reference<typename
349
334k
          BoundFunctorTraits::A3Type>::value ||
350
334k
          base::is_non_const_reference<typename
351
334k
          BoundFunctorTraits::A4Type>::value ||
352
334k
          base::is_non_const_reference<typename
353
334k
          BoundFunctorTraits::A5Type>::value ),
354
334k
      do_not_bind_functions_with_nonconst_ref);
355
356
  // For methods, we need to be careful for parameter 1.  We do not require
357
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
358
  // methods. We also disallow binding of an array as the method's target
359
  // object.
360
334k
  COMPILE_ASSERT(
361
334k
      internal::HasIsMethodTag<RunnableType>::value ||
362
334k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
363
334k
      p1_is_refcounted_type_and_needs_scoped_refptr);
364
334k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
365
334k
                     !base::is_array<P1>::value,
366
334k
                 first_bound_argument_to_method_cannot_be_array);
367
334k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
368
334k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
369
334k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
370
334k
                 p3_is_refcounted_type_and_needs_scoped_refptr);
371
334k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
372
334k
                 p4_is_refcounted_type_and_needs_scoped_refptr);
373
334k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
374
334k
                 p5_is_refcounted_type_and_needs_scoped_refptr);
375
334k
  typedef internal::BindState<RunnableType, RunType,
376
334k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
377
334k
      typename internal::CallbackParamTraits<P2>::StorageType,
378
334k
      typename internal::CallbackParamTraits<P3>::StorageType,
379
334k
      typename internal::CallbackParamTraits<P4>::StorageType,
380
334k
      typename internal::CallbackParamTraits<P5>::StorageType)> BindState;
381
382
383
334k
  return Callback<typename BindState::UnboundRunType>(
384
334k
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
385
334k
}
Unexecuted instantiation: _ZN2yb4BindIMNS_6master10enterprise14CatalogManagerEFvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS4_10shared_ptrINS4_6vectorINS_6client11YBTableInfoENS8_ISG_EEEEEESC_RKNS4_13unordered_mapISA_SA_NS4_4hashISA_EENS4_8equal_toISA_EENS8_INS4_4pairISB_SA_EEEEEERKNS_6StatusEENS_8internal17UnretainedWrapperIS3_EESA_SJ_SA_SU_EENS_8CallbackINS12_9BindStateINS12_13FunctorTraitsIT_E12RunnableTypeENS19_7RunTypeEFvNS12_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS1D_EE5valueEE11StorageTypeENS1C_IT1_Xsr14IsMoveOnlyTypeIS1G_EE5valueEE11StorageTypeENS1C_IT2_Xsr14IsMoveOnlyTypeIS1J_EE5valueEE11StorageTypeENS1C_IT3_Xsr14IsMoveOnlyTypeIS1M_EE5valueEE11StorageTypeENS1C_IT4_Xsr14IsMoveOnlyTypeIS1P_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES18_RKS1D_RKS1G_RKS1J_RKS1M_RKS1P_
_ZN2yb4BindIMNS_2ql11QLProcessorEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS1_19StatementParametersEPKNS1_9ParseTreeENS_8CallbackIFvRKNS_6StatusERKNS3_10shared_ptrINS1_14ExecutedResultEEEEEESL_SQ_ENS_8internal17UnretainedWrapperIS2_EENSV_15ConstRefWrapperIS9_EENSY_ISC_EENSV_12OwnedWrapperISG_EESS_EENSI_INSV_9BindStateINSV_13FunctorTraitsIT_E12RunnableTypeENS16_7RunTypeEFvNSV_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS1A_EE5valueEE11StorageTypeENS19_IT1_Xsr14IsMoveOnlyTypeIS1D_EE5valueEE11StorageTypeENS19_IT2_Xsr14IsMoveOnlyTypeIS1G_EE5valueEE11StorageTypeENS19_IT3_Xsr14IsMoveOnlyTypeIS1J_EE5valueEE11StorageTypeENS19_IT4_Xsr14IsMoveOnlyTypeIS1M_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES15_RKS1A_RKS1D_RKS1G_RKS1J_RKS1M_
Line
Count
Source
327
330k
    const P5& p5) {
328
  // Typedefs for how to store and run the functor.
329
330k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
330
330k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
331
332
  // Use RunnableType::RunType instead of RunType above because our
333
  // checks should below for bound references need to know what the actual
334
  // functor is going to interpret the argument as.
335
330k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
336
330k
      BoundFunctorTraits;
337
338
  // Do not allow binding a non-const reference parameter. Non-const reference
339
  // parameters are disallowed by the Google style guide.  Also, binding a
340
  // non-const reference parameter can make for subtle bugs because the
341
  // invoked function will receive a reference to the stored copy of the
342
  // argument and not the original.
343
330k
  COMPILE_ASSERT(
344
330k
      !(base::is_non_const_reference<typename
345
330k
          BoundFunctorTraits::A1Type>::value ||
346
330k
          base::is_non_const_reference<typename
347
330k
          BoundFunctorTraits::A2Type>::value ||
348
330k
          base::is_non_const_reference<typename
349
330k
          BoundFunctorTraits::A3Type>::value ||
350
330k
          base::is_non_const_reference<typename
351
330k
          BoundFunctorTraits::A4Type>::value ||
352
330k
          base::is_non_const_reference<typename
353
330k
          BoundFunctorTraits::A5Type>::value ),
354
330k
      do_not_bind_functions_with_nonconst_ref);
355
356
  // For methods, we need to be careful for parameter 1.  We do not require
357
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
358
  // methods. We also disallow binding of an array as the method's target
359
  // object.
360
330k
  COMPILE_ASSERT(
361
330k
      internal::HasIsMethodTag<RunnableType>::value ||
362
330k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
363
330k
      p1_is_refcounted_type_and_needs_scoped_refptr);
364
330k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
365
330k
                     !base::is_array<P1>::value,
366
330k
                 first_bound_argument_to_method_cannot_be_array);
367
330k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
368
330k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
369
330k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
370
330k
                 p3_is_refcounted_type_and_needs_scoped_refptr);
371
330k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
372
330k
                 p4_is_refcounted_type_and_needs_scoped_refptr);
373
330k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
374
330k
                 p5_is_refcounted_type_and_needs_scoped_refptr);
375
330k
  typedef internal::BindState<RunnableType, RunType,
376
330k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
377
330k
      typename internal::CallbackParamTraits<P2>::StorageType,
378
330k
      typename internal::CallbackParamTraits<P3>::StorageType,
379
330k
      typename internal::CallbackParamTraits<P4>::StorageType,
380
330k
      typename internal::CallbackParamTraits<P5>::StorageType)> BindState;
381
382
383
330k
  return Callback<typename BindState::UnboundRunType>(
384
330k
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
385
330k
}
Unexecuted instantiation: _ZN2yb4BindIMNS_2ql11QLProcessorEFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS1_19StatementParametersEPKNS1_9ParseTreeENS_8CallbackIFvRKNS_6StatusERKNS3_10shared_ptrINS1_14ExecutedResultEEEEEESL_SQ_ENS_8internal17UnretainedWrapperIS2_EENSV_15ConstRefWrapperIS9_EENSY_ISC_EENSW_ISF_EESS_EENSI_INSV_9BindStateINSV_13FunctorTraitsIT_E12RunnableTypeENS15_7RunTypeEFvNSV_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS19_EE5valueEE11StorageTypeENS18_IT1_Xsr14IsMoveOnlyTypeIS1C_EE5valueEE11StorageTypeENS18_IT2_Xsr14IsMoveOnlyTypeIS1F_EE5valueEE11StorageTypeENS18_IT3_Xsr14IsMoveOnlyTypeIS1I_EE5valueEE11StorageTypeENS18_IT4_Xsr14IsMoveOnlyTypeIS1L_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES14_RKS19_RKS1C_RKS1F_RKS1I_RKS1L_
_ZN2yb4BindIPFvRK13scoped_refptrINS_5tools22ChecksumResultReporterEERKNSt3__110shared_ptrINS2_16YsckTabletServerEEERKNS8_INS_13BlockingQueueINS7_4pairINS_6SchemaENS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEENS_18DefaultLogicalSizeEEEEERKSL_RKNS2_15ChecksumOptionsERKNS_6StatusEyES4_SA_SP_SL_SU_EENS_8CallbackINS_8internal9BindStateINS13_13FunctorTraitsIT_E12RunnableTypeENS17_7RunTypeEFvNS13_19CallbackParamTraitsIT0_Xsr14IsMoveOnlyTypeIS1B_EE5valueEE11StorageTypeENS1A_IT1_Xsr14IsMoveOnlyTypeIS1E_EE5valueEE11StorageTypeENS1A_IT2_Xsr14IsMoveOnlyTypeIS1H_EE5valueEE11StorageTypeENS1A_IT3_Xsr14IsMoveOnlyTypeIS1K_EE5valueEE11StorageTypeENS1A_IT4_Xsr14IsMoveOnlyTypeIS1N_EE5valueEE11StorageTypeEEE14UnboundRunTypeEEES16_RKS1B_RKS1E_RKS1H_RKS1K_RKS1N_
Line
Count
Source
327
4.19k
    const P5& p5) {
328
  // Typedefs for how to store and run the functor.
329
4.19k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
330
4.19k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
331
332
  // Use RunnableType::RunType instead of RunType above because our
333
  // checks should below for bound references need to know what the actual
334
  // functor is going to interpret the argument as.
335
4.19k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
336
4.19k
      BoundFunctorTraits;
337
338
  // Do not allow binding a non-const reference parameter. Non-const reference
339
  // parameters are disallowed by the Google style guide.  Also, binding a
340
  // non-const reference parameter can make for subtle bugs because the
341
  // invoked function will receive a reference to the stored copy of the
342
  // argument and not the original.
343
4.19k
  COMPILE_ASSERT(
344
4.19k
      !(base::is_non_const_reference<typename
345
4.19k
          BoundFunctorTraits::A1Type>::value ||
346
4.19k
          base::is_non_const_reference<typename
347
4.19k
          BoundFunctorTraits::A2Type>::value ||
348
4.19k
          base::is_non_const_reference<typename
349
4.19k
          BoundFunctorTraits::A3Type>::value ||
350
4.19k
          base::is_non_const_reference<typename
351
4.19k
          BoundFunctorTraits::A4Type>::value ||
352
4.19k
          base::is_non_const_reference<typename
353
4.19k
          BoundFunctorTraits::A5Type>::value ),
354
4.19k
      do_not_bind_functions_with_nonconst_ref);
355
356
  // For methods, we need to be careful for parameter 1.  We do not require
357
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
358
  // methods. We also disallow binding of an array as the method's target
359
  // object.
360
4.19k
  COMPILE_ASSERT(
361
4.19k
      internal::HasIsMethodTag<RunnableType>::value ||
362
4.19k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
363
4.19k
      p1_is_refcounted_type_and_needs_scoped_refptr);
364
4.19k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
365
4.19k
                     !base::is_array<P1>::value,
366
4.19k
                 first_bound_argument_to_method_cannot_be_array);
367
4.19k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
368
4.19k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
369
4.19k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
370
4.19k
                 p3_is_refcounted_type_and_needs_scoped_refptr);
371
4.19k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
372
4.19k
                 p4_is_refcounted_type_and_needs_scoped_refptr);
373
4.19k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
374
4.19k
                 p5_is_refcounted_type_and_needs_scoped_refptr);
375
4.19k
  typedef internal::BindState<RunnableType, RunType,
376
4.19k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
377
4.19k
      typename internal::CallbackParamTraits<P2>::StorageType,
378
4.19k
      typename internal::CallbackParamTraits<P3>::StorageType,
379
4.19k
      typename internal::CallbackParamTraits<P4>::StorageType,
380
4.19k
      typename internal::CallbackParamTraits<P5>::StorageType)> BindState;
381
382
383
4.19k
  return Callback<typename BindState::UnboundRunType>(
384
4.19k
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5));
385
4.19k
}
386
387
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
388
    typename P5, typename P6>
389
Callback<
390
    typename internal::BindState<
391
        typename internal::FunctorTraits<Functor>::RunnableType,
392
        typename internal::FunctorTraits<Functor>::RunType,
393
        void(typename internal::CallbackParamTraits<P1>::StorageType,
394
            typename internal::CallbackParamTraits<P2>::StorageType,
395
            typename internal::CallbackParamTraits<P3>::StorageType,
396
            typename internal::CallbackParamTraits<P4>::StorageType,
397
            typename internal::CallbackParamTraits<P5>::StorageType,
398
            typename internal::CallbackParamTraits<P6>::StorageType)>
399
            ::UnboundRunType>
400
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
401
42.9k
    const P5& p5, const P6& p6) {
402
  // Typedefs for how to store and run the functor.
403
42.9k
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
404
42.9k
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
405
406
  // Use RunnableType::RunType instead of RunType above because our
407
  // checks should below for bound references need to know what the actual
408
  // functor is going to interpret the argument as.
409
42.9k
  typedef internal::FunctionTraits<typename RunnableType::RunType>
410
42.9k
      BoundFunctorTraits;
411
412
  // Do not allow binding a non-const reference parameter. Non-const reference
413
  // parameters are disallowed by the Google style guide.  Also, binding a
414
  // non-const reference parameter can make for subtle bugs because the
415
  // invoked function will receive a reference to the stored copy of the
416
  // argument and not the original.
417
42.9k
  COMPILE_ASSERT(
418
42.9k
      !(base::is_non_const_reference<typename
419
42.9k
          BoundFunctorTraits::A1Type>::value ||
420
42.9k
          base::is_non_const_reference<typename
421
42.9k
          BoundFunctorTraits::A2Type>::value ||
422
42.9k
          base::is_non_const_reference<typename
423
42.9k
          BoundFunctorTraits::A3Type>::value ||
424
42.9k
          base::is_non_const_reference<typename
425
42.9k
          BoundFunctorTraits::A4Type>::value ||
426
42.9k
          base::is_non_const_reference<typename
427
42.9k
          BoundFunctorTraits::A5Type>::value ||
428
42.9k
          base::is_non_const_reference<typename
429
42.9k
          BoundFunctorTraits::A6Type>::value ),
430
42.9k
      do_not_bind_functions_with_nonconst_ref);
431
432
  // For methods, we need to be careful for parameter 1.  We do not require
433
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
434
  // methods. We also disallow binding of an array as the method's target
435
  // object.
436
42.9k
  COMPILE_ASSERT(
437
42.9k
      internal::HasIsMethodTag<RunnableType>::value ||
438
42.9k
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
439
42.9k
      p1_is_refcounted_type_and_needs_scoped_refptr);
440
42.9k
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
441
42.9k
                     !base::is_array<P1>::value,
442
42.9k
                 first_bound_argument_to_method_cannot_be_array);
443
42.9k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
444
42.9k
                 p2_is_refcounted_type_and_needs_scoped_refptr);
445
42.9k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
446
42.9k
                 p3_is_refcounted_type_and_needs_scoped_refptr);
447
42.9k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
448
42.9k
                 p4_is_refcounted_type_and_needs_scoped_refptr);
449
42.9k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
450
42.9k
                 p5_is_refcounted_type_and_needs_scoped_refptr);
451
42.9k
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
452
42.9k
                 p6_is_refcounted_type_and_needs_scoped_refptr);
453
42.9k
  typedef internal::BindState<RunnableType, RunType,
454
42.9k
      void(typename internal::CallbackParamTraits<P1>::StorageType,
455
42.9k
      typename internal::CallbackParamTraits<P2>::StorageType,
456
42.9k
      typename internal::CallbackParamTraits<P3>::StorageType,
457
42.9k
      typename internal::CallbackParamTraits<P4>::StorageType,
458
42.9k
      typename internal::CallbackParamTraits<P5>::StorageType,
459
42.9k
      typename internal::CallbackParamTraits<P6>::StorageType)> BindState;
460
461
462
42.9k
  return Callback<typename BindState::UnboundRunType>(
463
42.9k
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6));
464
42.9k
}
465
466
template <typename Functor, typename P1, typename P2, typename P3, typename P4,
467
    typename P5, typename P6, typename P7>
468
Callback<
469
    typename internal::BindState<
470
        typename internal::FunctorTraits<Functor>::RunnableType,
471
        typename internal::FunctorTraits<Functor>::RunType,
472
        void(typename internal::CallbackParamTraits<P1>::StorageType,
473
            typename internal::CallbackParamTraits<P2>::StorageType,
474
            typename internal::CallbackParamTraits<P3>::StorageType,
475
            typename internal::CallbackParamTraits<P4>::StorageType,
476
            typename internal::CallbackParamTraits<P5>::StorageType,
477
            typename internal::CallbackParamTraits<P6>::StorageType,
478
            typename internal::CallbackParamTraits<P7>::StorageType)>
479
            ::UnboundRunType>
480
Bind(Functor functor, const P1& p1, const P2& p2, const P3& p3, const P4& p4,
481
    const P5& p5, const P6& p6, const P7& p7) {
482
  // Typedefs for how to store and run the functor.
483
  typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
484
  typedef typename internal::FunctorTraits<Functor>::RunType RunType;
485
486
  // Use RunnableType::RunType instead of RunType above because our
487
  // checks should below for bound references need to know what the actual
488
  // functor is going to interpret the argument as.
489
  typedef internal::FunctionTraits<typename RunnableType::RunType>
490
      BoundFunctorTraits;
491
492
  // Do not allow binding a non-const reference parameter. Non-const reference
493
  // parameters are disallowed by the Google style guide.  Also, binding a
494
  // non-const reference parameter can make for subtle bugs because the
495
  // invoked function will receive a reference to the stored copy of the
496
  // argument and not the original.
497
  COMPILE_ASSERT(
498
      !(base::is_non_const_reference<typename
499
          BoundFunctorTraits::A1Type>::value ||
500
          base::is_non_const_reference<typename
501
          BoundFunctorTraits::A2Type>::value ||
502
          base::is_non_const_reference<typename
503
          BoundFunctorTraits::A3Type>::value ||
504
          base::is_non_const_reference<typename
505
          BoundFunctorTraits::A4Type>::value ||
506
          base::is_non_const_reference<typename
507
          BoundFunctorTraits::A5Type>::value ||
508
          base::is_non_const_reference<typename
509
          BoundFunctorTraits::A6Type>::value ||
510
          base::is_non_const_reference<typename
511
          BoundFunctorTraits::A7Type>::value ),
512
      do_not_bind_functions_with_nonconst_ref);
513
514
  // For methods, we need to be careful for parameter 1.  We do not require
515
  // a scoped_refptr because BindState<> itself takes care of AddRef() for
516
  // methods. We also disallow binding of an array as the method's target
517
  // object.
518
  COMPILE_ASSERT(
519
      internal::HasIsMethodTag<RunnableType>::value ||
520
          !internal::NeedsScopedRefptrButGetsRawPtr<P1>::value,
521
      p1_is_refcounted_type_and_needs_scoped_refptr);
522
  COMPILE_ASSERT(!internal::HasIsMethodTag<RunnableType>::value ||
523
                     !base::is_array<P1>::value,
524
                 first_bound_argument_to_method_cannot_be_array);
525
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P2>::value,
526
                 p2_is_refcounted_type_and_needs_scoped_refptr);
527
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P3>::value,
528
                 p3_is_refcounted_type_and_needs_scoped_refptr);
529
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P4>::value,
530
                 p4_is_refcounted_type_and_needs_scoped_refptr);
531
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P5>::value,
532
                 p5_is_refcounted_type_and_needs_scoped_refptr);
533
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P6>::value,
534
                 p6_is_refcounted_type_and_needs_scoped_refptr);
535
  COMPILE_ASSERT(!internal::NeedsScopedRefptrButGetsRawPtr<P7>::value,
536
                 p7_is_refcounted_type_and_needs_scoped_refptr);
537
  typedef internal::BindState<RunnableType, RunType,
538
      void(typename internal::CallbackParamTraits<P1>::StorageType,
539
      typename internal::CallbackParamTraits<P2>::StorageType,
540
      typename internal::CallbackParamTraits<P3>::StorageType,
541
      typename internal::CallbackParamTraits<P4>::StorageType,
542
      typename internal::CallbackParamTraits<P5>::StorageType,
543
      typename internal::CallbackParamTraits<P6>::StorageType,
544
      typename internal::CallbackParamTraits<P7>::StorageType)> BindState;
545
546
547
  return Callback<typename BindState::UnboundRunType>(
548
      new BindState(internal::MakeRunnable(functor), p1, p2, p3, p4, p5, p6,
549
          p7));
550
}
551
552
}  // namespace yb
553
554
#endif // YB_GUTIL_BIND_H_