BDE 4.14.0 Production release
Loading...
Searching...
No Matches
bdlf_bind.h
Go to the documentation of this file.
1/// @file bdlf_bind.h
2///
3/// The content of this file has been pre-processed for Doxygen.
4///
5
6
7// bdlf_bind.h -*-C++-*-
8#ifndef INCLUDED_BDLF_BIND
9#define INCLUDED_BDLF_BIND
10
11#include <bsls_ident.h>
12BSLS_IDENT("$Id: $")
13
14/// @defgroup bdlf_bind bdlf_bind
15/// @brief Provide a signature-specific function object (functor).
16/// @addtogroup bdl
17/// @{
18/// @addtogroup bdlf
19/// @{
20/// @addtogroup bdlf_bind
21/// @{
22///
23/// <h1> Outline </h1>
24/// * <a href="#bdlf_bind-purpose"> Purpose</a>
25/// * <a href="#bdlf_bind-classes"> Classes </a>
26/// * <a href="#bdlf_bind-description"> Description </a>
27/// * <a href="#bdlf_bind-supported-functionality"> Supported Functionality </a>
28/// * <a href="#bdlf_bind-elementary-construction-and-usage-of-bdlf-bind-objects"> Elementary Construction and Usage of bdlf::Bind Objects </a>
29/// * <a href="#bdlf_bind-binding-data"> Binding Data </a>
30/// * <a href="#bdlf_bind-ignoring-parameters"> Ignoring Parameters </a>
31/// * <a href="#bdlf_bind-duplicating-parameters"> Duplicating Parameters </a>
32/// * <a href="#bdlf_bind-bound-functors"> Bound Functors </a>
33/// * <a href="#bdlf_bind-binding-to-member-functions"> Binding to Member Functions </a>
34/// * <a href="#bdlf_bind-binding-to-functions-with-an-ellipsis"> Binding to Functions with an Ellipsis </a>
35/// * <a href="#bdlf_bind-binding-to-function-objects-by-value-or-by-address"> Binding to Function Objects by Value or by Address </a>
36/// * <a href="#bdlf_bind-inferring-the-signature-of-the-bound-functor"> Inferring the Signature of the Bound Functor </a>
37/// * <a href="#bdlf_bind-binding-with-constants-and-temporaries"> Binding with Constants and Temporaries </a>
38/// * <a href="#bdlf_bind-binding-with-allocators"> Binding with Allocators </a>
39/// * <a href="#bdlf_bind-usage"> Usage </a>
40/// * <a href="#bdlf_bind-example-1-implementing-a-callback"> Example 1: Implementing a Callback </a>
41/// * <a href="#bdlf_bind-example-2-binding-to-free-functions"> Example 2: Binding to Free Functions </a>
42/// * <a href="#bdlf_bind-example-3-binding-to-function-objects"> Example 3: Binding to Function Objects </a>
43/// * <a href="#bdlf_bind-example-4-binding-to-function-objects-by-reference"> Example 4: Binding to Function Objects by Reference </a>
44/// * <a href="#bdlf_bind-example-5-binding-to-member-functions"> Example 5: Binding to Member Functions </a>
45/// * <a href="#bdlf_bind-example-6-nesting-bindings"> Example 6: Nesting Bindings </a>
46/// * <a href="#bdlf_bind-example-7-binding-to-a-function-object-with-explicit-return-type"> Example 7: Binding to a Function Object with Explicit Return Type </a>
47///
48/// # Purpose {#bdlf_bind-purpose}
49/// Provide a signature-specific function object (functor).
50///
51/// # Classes {#bdlf_bind-classes}
52///
53/// - bdlf::Bind: select the proper implementation for the binder
54/// - bdlf::BindWrapper: reference counted function binder
55/// - bdlf::BindUtil: factory methods for creating the binder
56///
57/// @see bdlf_memfn, bdlf_placeholder
58///
59/// # Description {#bdlf_bind-description}
60/// This component provides a parameterized binder mechanism,
61/// `bdlf::Bind`, that is a functor object that binds an invocable object or
62/// function to a list of arguments. This component also defines factory
63/// methods in the `bdlf::BindUtil` namespace for creating `bdlf::Bind` objects
64/// (e.g., `bind` and `bindR`) and `bdlf::BindWrapper` objects (e.g., `bindS`
65/// and `bindSR`). The `bdlf::Bind` functor (called henceforth a "binder") is
66/// an object that can hold any invocable object (the "bound functor") and a
67/// number of parameters (the "bound arguments", some of which can be
68/// place-holders of type `bdlf::PlaceHolder`). When the binder is later
69/// invoked (with optional additional arguments called the "invocation
70/// arguments" used to compute the value of bound arguments that use
71/// place-holders), it returns the result of calling the bound functor with the
72/// bound arguments and invocation arguments. The `bdlf::BindWrapper` functor
73/// provides a binder with shared pointer semantics to a non-modifiable binder
74/// (both `operator*` and `operator->` accessors) and forwards its construction
75/// arguments to the underlying binder. The section "Supported functionality
76/// and limitations" details which kind of bound functors and bound arguments
77/// can be used in conjunction with this component.
78///
79/// The main use of `bdlf::Bind` is to invoke bound functors with additional
80/// data that is not available prior to the point the functor is invoked (as is
81/// often the case with callback functions). The binding is accomplished by
82/// passing place-holders instead of literal values as the bound arguments.
83/// When the binder is invoked, these place-holders are replaced by their
84/// respective invocation arguments. The section "Elementary construction and
85/// usage of bdlf::Bind objects" shows an elementary (but not realistic) usage
86/// of the `bdlf::BindUtil::bind` factory methods with free functions, that
87/// should be enough for most users to grasp the basic usage of this component.
88/// The section "Binding data" offers more details and should enable a user to
89/// make a more advanced usage of this component. The usage example presents
90/// many uses of `bdlf::Bind` and `bdlf::BindUtil` in a somewhat realistic (but
91/// a bit more involved) situation.
92///
93/// Note that `bdlf::Bind` functors are typically used with standard algorithms,
94/// or with `bsl::function`. This mechanism is similar to, but much more
95/// powerful than, `bsl::bind1st` or `bsl::bind2nd`.
96///
97/// The difference between a binder created using one of `bindS` and `bindSR`
98/// and a binder created using `bind`, and `bindR` is that in the former case
99/// the binder is returned by reference rather than by value, with shared
100/// ownership semantics. Hence its main use is for creating binders that
101/// hold a non-trivial amount of storage (i.e., the bound arguments) and will be
102/// copied, possibly several times, such as jobs enqueued in a threadpool.
103///
104/// ## Supported Functionality {#bdlf_bind-supported-functionality}
105///
106///
107/// An invocable object is any object that can be invoked in syntactically the
108/// same manner as a function. Invocable objects include function pointers, and
109/// objects that provide an `operator()` method. This component supports bound
110/// objects that can be function pointers, member function pointers (the first
111/// bound argument must evaluate to an instance of the class of which the
112/// function is a member), or function objects passed by address or by value.
113/// In addition, there is a limitation on the number of parameters that such an
114/// object can take (currently no more than 14).
115///
116/// A `bdlf::Bind` functor can be constructed, usually by one of the
117/// `bdlf::BindUtil` factory methods, from a bound functor and from 0 up to 14
118/// bound arguments that can be either literal values, place-holders of type
119/// `bdlf::PlaceHolder`, or further `bdlf::Bind` functors. The type of a binder
120/// object is a complicated expression, which is why a binder is typically a
121/// short-lived object that is returned or passed as parameter to a function
122/// template. That is also why the `bdlf::BindUtil` factory methods are the
123/// preferred way to create a binder. When a binder is later invoked with some
124/// arguments, literal values are passed to the bound functor and place-holders
125/// are substituted by their respective invocation arguments. In addition, any
126/// argument that is a binder itself is invoked recursively with the same
127/// invocation arguments and the result of that invocation is passed to the
128/// parent binder. The section "Elementary construction and usage of
129/// bdlf::Bind objects" below details the whole mechanism and offers some
130/// examples.
131///
132/// The `bdlf::Bind` functors support `bslma::Allocator *` arguments. When
133/// binders are constructed by the `bdlf::BindUtil::bind` (and `bindR`) factory
134/// methods, the currently installed default allocator is used. When binders
135/// are constructed by the `bdlf::BindUtil::bindS` (and `bindSR`) factory
136/// methods, the non-optional, user-supplied allocator is used both for the
137/// creation of the bound functor arguments and for the reference counting
138/// mechanism that manages those arguments. See the section "Binding with
139/// allocators" below for a more detailed discussion.
140///
141/// ## Elementary Construction and Usage of bdlf::Bind Objects {#bdlf_bind-elementary-construction-and-usage-of-bdlf-bind-objects}
142///
143///
144/// Bound functors are generally constructed by invoking the `bdlf::BindUtil`
145/// with an "invocation template". An invocation template is a series of one or
146/// more arguments that describe how to invoke the bound functor. Each argument
147/// can be either a place-holder or a literal value. Literal values are stored
148/// by value in the binder and directly forwarded to the bound functor when
149/// invoked. Place-holders are substituted with the respective argument
150/// provided at invocation of the binder. For example, given the following
151/// `invocable` (here a free function for simplicity):
152/// @code
153/// void invocable(int i, int j, const char *str)
154/// {
155/// // Do something with 'i', 'j' and 'str'.
156/// printf("Invoked with: %d %d %s\n", i, j, str);
157/// }
158/// @endcode
159/// and the following (global) string:
160/// @code
161/// const char *someString = "p3"; // for third parameter to 'invocable'
162/// @endcode
163/// we can bind the parameters of `invocable` to the following arguments:
164/// @code
165/// void bindTest(bslma::Allocator *allocator = 0) {
166/// bdlf::BindUtil::bind(&invocable, // bound functor and
167/// 10, 14, someString) // bound arguments
168/// @endcode
169/// and the binder declared above can be passed invocation arguments directly,
170/// as follows (here we specify zero invocation arguments since all the bound
171/// arguments are fully specified):
172/// @code
173/// (); // invocation
174/// @endcode
175/// Similarly, we can also create a reference-counted shared binder using the
176/// `bindS` method:
177/// @code
178/// bdlf::BindUtil::bindS(allocator, // allocator,
179/// &invocable, // bound object and
180/// 10, 14, (const char*)"p3")(); // bound arguments
181/// }
182/// @endcode
183/// In the function call above, the `invocable` will be bound with the arguments
184/// `10`, `14`, and `"p3"` respectively, then invoked with those bound
185/// arguments. In the next example, place-holders are used to forward
186/// user-provided arguments to the bound functor. We separate the invocation of
187/// the binder into a function template to avoid having to declare the type of
188/// the binder:
189/// @code
190/// template <class BINDER>
191/// void callBinder(BINDER const& b)
192/// {
193/// b(10, 14);
194/// }
195/// @endcode
196/// The creation of the binder is as follows:
197/// @code
198/// void bindTest1(bslma::Allocator *allocator = 0) {
199/// callBinder(bdlf::BindUtil::bind(&invocable,
200/// _1, _2, someString));
201///
202/// callBinder(bdlf::BindUtil::bindS(allocator,
203/// &invocable,
204/// _1, _2, someString));
205/// }
206/// @endcode
207/// In this code snippet, the `callBinder` template function is invoked with a
208/// binder bound to the specified `invocable` and having the invocation template
209/// `_1`, `_2`, and `"p3"` respectively. The two special parameters `_1` and
210/// `_2` are place-holders for arguments one and two, respectively, which will
211/// be specified to the binder at invocation time. Each place-holder will be
212/// substituted with the corresponding positional argument when invoked. When
213/// called within the `callBinder` function, `invocable` will be invoked as
214/// follows:
215/// @code
216/// invocable(10, 14, "p3");
217/// @endcode
218/// Place-holders can appear anywhere in the invocation template, and in any
219/// order. The same place-holder can appear multiple times. Each instance will
220/// be substituted with the same value. For example, in the following snippet
221/// of code, the `callBinder` function, is invoked with a binder such that
222/// argument one (10) of the binder is passed as parameter two and argument two
223/// (14) is passed as (i.e., bound to) parameter one:
224/// @code
225/// void bindTest2(bslma::Allocator *allocator = 0) {
226/// callBinder(bdlf::BindUtil::bind(&invocable, _2, _1, someString));
227///
228/// callBinder(bdlf::BindUtil::bindS(allocator,
229/// &invocable,
230/// _2, _1, someString));
231/// }
232/// @endcode
233/// When called within the `callBinder` function, `invocable` will be invoked as
234/// follows:
235/// @code
236/// invocable(14, 10, "p3");
237/// @endcode
238/// The following snippet of code illustrates a number of ways to call
239/// `bdlf::BindUtil` and their respective output:
240/// @code
241/// int test1(int i, int j)
242/// {
243/// return i + j;
244/// }
245///
246/// int abs(int x)
247/// {
248/// return (x > 0) ? x : -x;
249/// }
250///
251/// void bindTest3(bslma::Allocator *allocator = 0)
252/// {
253/// using namespace bdlf::PlaceHolders;
254/// assert(24 == bdlf::BindUtil::bind(&test1, _1, _2)(10, 14));
255/// assert(24 == bdlf::BindUtil::bind(&test1, _1, 14)(10));
256/// assert(24 == bdlf::BindUtil::bind(&test1, 10, _1)(14));
257/// assert(24 == bdlf::BindUtil::bind(&test1, 10, 14)());
258/// assert(24 == bdlf::BindUtil::bind(&test1,
259/// bdlf::BindUtil::bind(&abs,_1), 14)(-10));
260///
261/// assert(24 == bdlf::BindUtil::bindS(allocator, &test1, _1, _2)(10, 14));
262/// assert(24 == bdlf::BindUtil::bindS(allocator, &test1, _1, 14)(10));
263/// assert(24 == bdlf::BindUtil::bindS(allocator, &test1, 10, _1 )(14));
264/// assert(24 == bdlf::BindUtil::bindS(allocator, &test1, 10, 14)());
265/// assert(24 == bdlf::BindUtil::bindS(allocator, &test1,
266/// bdlf::BindUtil::bindS(allocator, &abs, _1), 14)(-10));
267/// }
268/// @endcode
269/// The usage example below provides a more comprehensive series of calling
270/// sequences.
271///
272/// ## Binding Data {#bdlf_bind-binding-data}
273///
274///
275/// The main use of `bdlf::Bind` is to invoke bound functors with additional
276/// data that is not available prior to the point the functor is invoked (as is
277/// often the case with callback functions). For that purpose, place-holders
278/// are key. There are a couple of issues to understand in order to properly
279/// use this component. The bound arguments must be of a value-semantic type
280/// (unless they are place-holders or `bdlf::Bind` objects). They are evaluated
281/// at binding time once and only once and their value copied into the binder
282/// (using the default allocator to supply memory unless an allocator is
283/// specified). A `bdlf::Bind` object always invokes its bound functor with
284/// only the arguments listed as bound arguments, regardless of how many
285/// arguments are specified to the binder at invocation time. Invocation
286/// arguments that are not referenced through a place-holder are simply
287/// discarded. Invocation arguments that are duplicated (by using the same
288/// place-holder several times) are simply copied several times. The following
289/// examples should make things perfectly clear.
290///
291/// ### Ignoring Parameters {#bdlf_bind-ignoring-parameters}
292///
293///
294/// It is possible to pass more invocation arguments to a binder than were
295/// specified in the signature by the number of bound arguments. Invocation
296/// arguments not referenced by any placeholder, as well as extra invocation
297/// arguments, will be ignored. Note that they will nevertheless be evaluated
298/// even though their value will be unused. Consider, for example, the
299/// following snippet of code:
300/// @code
301/// int marker = 0;
302/// int singleArgumentFunction(int x) {
303/// return x;
304/// }
305///
306/// int identityFunctionWithSideEffects(int x)
307/// {
308/// printf("Calling 'identityFunctionWithSideEffects' with %d\n", x);
309/// marker += x;
310/// return x;
311/// }
312///
313/// template <class BINDER>
314/// void callBinderWithSideEffects1(BINDER const& binder)
315/// {
316/// ASSERT(14 == binder(identityFunctionWithSideEffects(10), 14));
317/// }
318///
319/// void bindTest4(bslma::Allocator *allocator = 0) {
320/// marker = 0;
321/// callBinderWithSideEffects1(bdlf::BindUtil::bind(
322/// &singleArgumentFunction, _2));
323/// @endcode
324/// In the above snippets of code, `singleArgumentFunction` will be called with
325/// only the second argument (14) specified to the binder at invocation time in
326/// the `callBinderWithSideEffects1` function. Thus the return value of the
327/// invocation must be 14. The `identityFunctionWithSideEffects(10)` will be
328/// evaluated, even though its return value (10) will be discarded. We can
329/// check this as follows:
330/// @code
331/// assert(10 == marker);
332/// @endcode
333/// We repeat the same call using `bindS` below:
334/// @code
335/// marker = 0;
336/// callBinderWithSideEffects1(bdlf::BindUtil::bindS(
337/// allocator,
338/// &singleArgumentFunction,
339/// _2));
340/// assert(10 == marker);
341/// }
342/// @endcode
343///
344/// ### Duplicating Parameters {#bdlf_bind-duplicating-parameters}
345///
346///
347/// A place-holder can be specified multiple times, effectively passing the same
348/// value to different arguments of the function. The value will be evaluated
349/// only once. To illustrate this, consider another example that reuses the
350/// `singleArgumentFunction` of the previous example:
351/// @code
352/// int doubleArgumentFunction(int x, int y) {
353/// return x+y;
354/// }
355///
356/// template <class BINDER>
357/// void callBinderWithSideEffects2(BINDER const& binder)
358/// {
359/// const int RET1 = binder(10);
360/// ASSERT(20 == RET1);
361/// const int RET2 = binder(identityFunctionWithSideEffects(10));
362/// ASSERT(20 == RET2);
363/// }
364///
365/// void bindTest5(bslma::Allocator *allocator = 0) {
366/// marker = 0;
367/// callBinderWithSideEffects2(bdlf::BindUtil::bind(
368/// &doubleArgumentFunction, _1, _1));
369/// @endcode
370/// In the above snippet of code, `doubleArgumentFunction` will be called with
371/// the first argument (`identityFunctionWithSideEffects(10)`) specified to the
372/// binder, computed only once at invocation time. We can check this as
373/// follows:
374/// @code
375/// assert(10 == marker);
376/// @endcode
377/// We repeat the same call using `bindS` below:
378/// @code
379/// marker = 0;
380/// callBinderWithSideEffects2(bdlf::BindUtil::bindS(
381/// allocator,
382/// &doubleArgumentFunction,
383/// _1, _1));
384/// assert(marker, 10 == marker);
385/// }
386/// @endcode
387///
388/// ## Bound Functors {#bdlf_bind-bound-functors}
389///
390///
391/// There are a few issues to be aware of concerning the kind of bound functors
392/// that can successfully be used with this component.
393///
394/// ### Binding to Member Functions {#bdlf_bind-binding-to-member-functions}
395///
396///
397/// Although member function pointers are not invoked in syntactically the same
398/// manner as free functions, they can still be used directly in conjunction
399/// with `bdlf::Bind`. When the binder detects that a member function pointer
400/// was specified, it automatically wraps it in a `bdlf::MemFn` object. In this
401/// case a pointer to the object must be passed as the first argument to bind,
402/// followed by the remaining arguments. See the usage example "Binding to
403/// Member Functions" below.
404///
405/// Note that special care should be exercised when passing `this` to bind. If
406/// `this` is passed as the first argument to bind, then all other arguments
407/// must be passed by value or by const reference.
408///
409/// ### Binding to Functions with an Ellipsis {#bdlf_bind-binding-to-functions-with-an-ellipsis}
410///
411///
412/// It is possible to create a binder with a *free* function (pointer or
413/// reference) that takes an ellipsis (e.g., `int printf(const char*, ...`).
414/// This component does *not* support ellipsis in *member* function pointers,
415/// however. See the `bindTest7` example function at the end of the usage
416/// example below.
417///
418/// ### Binding to Function Objects by Value or by Address {#bdlf_bind-binding-to-function-objects-by-value-or-by-address}
419///
420///
421/// Although function objects are invoked in syntactically the same manner as
422/// free functions, they can be used by value or by address in conjunction with
423/// `bdlf::Bind`. When the binder detects that a pointer to a function object
424/// was specified, it automatically dereferences that pointer prior to invoking
425/// the function object. The difference between the two usages is that the
426/// binder object holds a copy of the whole object or of its address only. In
427/// particular, when passing by value an object that takes an allocator, the
428/// copy held by the binder uses the default allocator if constructed by
429/// `bdlf::BindUtil::bind` or `bdlf::BindUtil::bindR`, *not* the allocator of
430/// the original object.
431///
432/// For keeping the same allocator, pass the object by address to the binder, or
433/// call `bindS` or `bindSR` instead. See the section "Binding with allocators"
434/// and the usage example sections "Binding to Function Objects" and "Binding to
435/// Function Objects by Reference" below.
436///
437/// CAVEAT: When passing a function object by value, only the (non-modifiable)
438/// copy held by the binder will be invoked. Prior to this version, it was
439/// possible to modifiably invoke this copy (hence a non-`const` `operator()`)
440/// with the intent to modify the state of the function object. However, only
441/// the copy held by the binder was modified and the original function object
442/// passed to the binder was not, but this usage error went undetected. In this
443/// version, a binder cannot modifiably invoke functors held by value, and
444/// attempting to do so will trigger a compilation error. If it is desired that
445/// an invocation modifies the state of the function object, then this function
446/// object must be passed to the binder *by* *address*.
447///
448/// ### Inferring the Signature of the Bound Functor {#bdlf_bind-inferring-the-signature-of-the-bound-functor}
449///
450///
451/// When binding a function pointer or class method pointer, the pointer passed
452/// must unambiguously refer to a a single overload. When binding a functor
453/// object, it is possible for the choice of method overload called to be
454/// deferred until invocation.
455///
456/// A `bdlf::Bind` object will strive to properly and automatically resolve the
457/// signature of its bound functor between different overloads of that
458/// invocable. The signature of the bound functor is inferred from that of the
459/// bound functor and the type of the arguments either at binding or invocation
460/// time. The signature of invocables that are not function objects (i.e., free
461/// functions with C++ linkage and member functions) must be determined at
462/// binding time (in particular, overloads must be disambiguated when obtaining
463/// the address of the function). In those cases, the bound arguments will be
464/// of the corresponding type and any values passed as bound arguments (except
465/// placeholders) will be cast to the corresponding type at binding time and
466/// stored by value unless the argument type is a reference type.
467///
468/// Invocation arguments will be cast in place of their corresponding
469/// place-holder(s) to the corresponding type only at invocation time. If the
470/// signature of the bound functor is known, the invocation argument will be
471/// forwarded using the most efficient type (in particular, unnecessary copies
472/// will be avoided for non fundamental types).
473///
474/// Some invocable objects, however, may not allow the binder to detect their
475/// signature until invocation. This is the case for function objects, for free
476/// functions with C linkage (e.g., `printf`), if a bound argument is a nested
477/// binder, or if a placeholder is used in two positions in the bound arguments.
478/// In that case, the bound arguments are stored in their own types, and cast to
479/// the corresponding argument type of the signature only when the signature is
480/// determined at invocation time. Place-holders, likewise, are not typed and
481/// will acquire the type of their corresponding invocation argument when
482/// invoked, which will be cast to the corresponding argument type of the
483/// signature. In particular, the same binder constructed with a functor and
484/// place-holders in place of the bound arguments can invoke several overloads
485/// of the `operator()` of the functor, depending on the type of the invocation
486/// arguments.
487///
488/// Although function objects are invoked in syntactically the same manner as
489/// free functions, their return type cannot always be inferred. The same
490/// limitation applies to free functions with `extern "C"` linkage. In that
491/// case, the return type has to be given explicitly to the binder. This can be
492/// done by using the `bdlf::BindUtil::bindR` function. Note that all
493/// `bsl::function` objects have a standard public type `result_type` to assist
494/// the deduction of return type and can be used with `bdlf::BindUtil::bind`.
495/// See the usage example "Binding to a Function Object with Explicit Return
496/// Type" below.
497///
498/// ### Binding with Constants and Temporaries {#bdlf_bind-binding-with-constants-and-temporaries}
499///
500///
501/// Due to a technical restriction of the C++ language known as the "forwarding
502/// problem", it is not possible to match the signature of a function object
503/// exactly when passing a mix of non-`const` lvalues and rvalues as invocation
504/// arguments. Nevertheless, this component supports passing literal values and
505/// temporaries as invocation arguments to a `bdlf::Bind` object. There is
506/// however one limitation: if *any* of the arguments in the signature of the
507/// bound functor should be of a modifiable reference type, then *all* the
508/// invocation arguments need to be modifiable references. That is, it is not
509/// possible to pass a literal (`const`) value to some argument of a bound
510/// functor when another argument expects a modifiable reference. Note that a
511/// direct call to the bound functor (without the binder) would accept such an
512/// argument. This is not a severe limitation, and the workaround is to pass
513/// instead a local modifiable variable initialized to the literal value.
514///
515/// ## Binding with Allocators {#bdlf_bind-binding-with-allocators}
516///
517///
518/// The bound functor and bound arguments are created as members of the
519/// `bdlf::Bind` object, so no memory is allocated for storing them. However,
520/// if the bound functor or bound argument's copy constructor requires memory
521/// allocation, that memory is supplied by the currently installed default
522/// allocator unless `bdlf::BindUtil::bindS` (or `bindSR`) method is used. In
523/// the latter cases, the non-optional, user-supplied allocator is passed to the
524/// copy constructors of the bound functor and arguments.
525///
526/// When invoking a bound functor object, the (unbound) arguments are passed "as
527/// is" to the bound functor. Those arguments are not copied if the bound
528/// functor takes them by modifiable or non-modifiable reference.
529///
530/// In order to make clear where the allocation occurs, we will wrap "p3" into a
531/// type that takes an allocator, e.g., a class `MyString` (kept minimal here
532/// for the purpose of exposition):
533/// @code
534/// class MyString {
535/// // PRIVATE INSTANCE DATA
536/// bslma::Allocator *d_allocator_p;
537/// char *d_string_p;
538///
539/// public:
540/// // TRAITS
541/// BSLMF_NESTED_TRAIT_DECLARATION(MyString, bslma::UsesBslmaAllocator);
542///
543/// //CREATORS
544/// MyString(const char *str, bslma::Allocator *allocator = 0)
545/// : d_allocator_p(bslma::Default::allocator(allocator))
546/// , d_string_p((char*)d_allocator_p->allocate(1 + strlen(str)))
547/// {
548/// strcpy(d_string_p, str);
549/// }
550///
551/// MyString(MyString const& rhs, bslma::Allocator *allocator = 0)
552/// : d_allocator_p(bslma::Default::allocator(allocator))
553/// , d_string_p((char*)d_allocator_p->allocate(1 + strlen(rhs)))
554/// {
555/// strcpy(d_string_p, rhs);
556/// }
557///
558/// ~MyString() {
559/// d_allocator_p->deallocate(d_string_p);
560/// }
561///
562/// // ACCESSORS
563/// operator const char*() const { return d_string_p; }
564/// };
565/// @endcode
566/// We will also use a `bslma::TestAllocator` to keep track of the memory
567/// allocated:
568/// @code
569/// void bindTest6() {
570/// bslma::TestAllocator allocator;
571/// MyString myString((const char*)"p3", &allocator);
572/// const Int64 NUM_ALLOCS = allocator.numAllocations();
573/// @endcode
574/// To expose that the default allocator is not used, we will use a default
575/// allocator guard, which will re-route any default allocation to the local
576/// `defaultAllocator`:
577/// @code
578/// bslma::TestAllocator defaultAllocator("Default", globalVerbose);
579/// bslma::DefaultAllocatorGuard defaultAllocatorGuard(&defaultAllocator);
580/// const Int64 NUM_DEFAULT_ALLOCS = defaultAllocator.numAllocations();
581/// @endcode
582/// We now create a shared binder object with `allocator` using `bindS`:
583/// @code
584/// callBinder(
585/// bdlf::BindUtil::bindS(&allocator, &invocable, _1, _2, myString));
586/// @endcode
587/// When the bound object is an instance of a class taking an allocator, then
588/// `allocator` is be passed to its copy constructor as occurs in this example.
589/// Here `allocator` is used to make the copy of `myString` held by the binder.
590///
591/// We now check that memory was allocated from the test allocator, and none
592/// from the default allocator:
593/// @code
594/// assert(NUM_ALLOCS != allocator.numAllocations());
595/// assert(NUM_DEFAULT_ALLOCS == defaultAllocator.numAllocations());
596/// }
597/// @endcode
598///
599/// ## Usage {#bdlf_bind-usage}
600///
601///
602/// This section illustrates intended use of this component.
603///
604/// ### Example 1: Implementing a Callback {#bdlf_bind-example-1-implementing-a-callback}
605///
606///
607/// What follows is a series of code snippets illustrating detailed aspects of
608/// typical usage of `bdlf::Bind` and `bdlf::BindUtil`. For these examples, we
609/// will use a typical pair of event and event dispatcher classes, where the
610/// event is defined as:
611/// @code
612/// struct MyEvent {
613/// // Event data, for illustration purpose here:
614/// int d_value;
615///
616/// MyEvent() : d_value(0) {}
617/// };
618/// @endcode
619/// and the event dispatcher is defined as follows:
620/// @code
621/// class MyEventDispatcher {
622/// // This class owns a callback function object that takes an 'int' and
623/// // an instance of 'MyEvent'. When the 'dispatch' method is called, it
624/// // invokes the callback with a series of events that it obtains using
625/// // its own stream of events.
626///
627/// // PRIVATE INSTANCE DATA
628/// bsl::function<void(int, MyEvent)> d_callback;
629///
630/// // PRIVATE MANIPULATORS
631/// int getNextEvent(MyEvent *eventBuffer) {
632/// // Create a copy of the next event in the specified 'eventBuffer'
633/// // Return 0 on success, and non-zero if no event is available.
634///
635/// // Implementation elided
636/// // ...
637/// }
638/// @endcode
639/// A dispatcher is created with a callback function object as follows:
640/// @code
641/// public:
642/// // CREATORS
643/// MyEventDispatcher(bsl::function<void(int, MyEvent)> const& cb)
644/// : d_callback(cb)
645/// {
646/// }
647/// @endcode
648/// and its main function is to invoke the callback on the series of events as
649/// obtained by `getNextEvent`:
650/// @code
651/// // MANIPULATORS
652/// void dispatch(int id)
653/// {
654/// MyEvent e;
655/// while (!getNextEvent(&e)) {
656/// d_callback(id, e);
657/// }
658/// }
659/// };
660/// @endcode
661///
662/// ### Example 2: Binding to Free Functions {#bdlf_bind-example-2-binding-to-free-functions}
663///
664///
665/// We illustrate how to use the dispatcher with free callback functions that
666/// have various signatures by passing a binder as the callback function of the
667/// dispatcher, and how to use the binder to match the signature of the callback
668/// function. Note that at the point of invocation in `dispatch` the binder
669/// will be invoked with two invocation arguments, thus we may use only
670/// place-holders `_1` and `_2`. In the following snippet of code, the binder
671/// passes its invocation arguments straight through to the callback:
672/// @code
673/// void myCallback(int id, MyEvent const& event)
674/// {
675/// // Do something ...
676/// }
677///
678/// void myMainLoop(bslma::Allocator *allocator = 0)
679/// {
680/// MyEventDispatcher schedA(bdlf::BindUtil::bind(&myCallback, _1, _2));
681/// schedA.dispatch(10);
682///
683/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
684/// &myCallback, _1, _2));
685/// schedB.run(10);
686/// }
687/// @endcode
688/// Next we show how to bind some of the callback arguments at binding time,
689/// while letting the invocation arguments straight through to the callback as
690/// the first two arguments:
691/// @code
692/// void myCallbackWithUserArgs(int id,
693/// MyEvent const& event,
694/// int userArg1,
695/// double userArg2)
696/// {
697/// // Do something ...
698/// }
699///
700/// void myMainLoop2(bslma::Allocator *allocator = 0)
701/// {
702/// MyEventDispatcher schedA(bdlf::BindUtil::bind(&myCallbackWithUserArgs,
703/// _1, _2, 360, 3.14));
704/// schedA.dispatch(10);
705///
706/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
707/// &myCallbackWithUserArgs,
708/// _1, _2, 360, 3.14));
709/// schedB.run(10);
710/// }
711/// @endcode
712/// In the next snippet of code, we show how to reorder the invocation arguments
713/// before they are passed to the callback:
714/// @code
715/// void myCallbackWithUserArgsReordered(int id,
716/// int userArg1,
717/// double userArg2,
718/// MyEvent const& event)
719/// {
720/// // Do something ...
721/// }
722///
723/// void myMainLoop3(bslma::Allocator *allocator = 0)
724/// {
725/// MyEventDispatcher schedA(bdlf::BindUtil::bind(
726/// &myCallbackWithUserArgsReordered, _1, 360, 3.14, _2));
727/// schedA.dispatch(10);
728///
729/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
730/// &myCallbackWithUserArgsReordered, _1, 360, 3.14, _2));
731/// schedB.run(10);
732/// }
733/// @endcode
734/// And finally, we illustrate that the signature of the callback can be
735/// *smaller* than expected by the dispatcher by letting the binder ignore its
736/// first argument:
737/// @code
738/// void myCallbackThatDiscardsResult(MyEvent const& event)
739/// {
740/// // Do something ...
741/// }
742///
743/// void myMainLoop4(bslma::Allocator *allocator = 0)
744/// {
745/// MyEventDispatcher schedA(bdlf::BindUtil::bind(
746/// &myCallbackThatDiscardsResult, _2));
747/// schedA.dispatch(10);
748///
749/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
750/// &myCallbackThatDiscardsResult, _2));
751/// schedB.run(10);
752/// }
753/// @endcode
754///
755/// ### Example 3: Binding to Function Objects {#bdlf_bind-example-3-binding-to-function-objects}
756///
757///
758/// In the next example, we wrap the callback function into a function object
759/// which is bound by value. For brevity, we only present the basic example of
760/// passing the arguments straight through to the actual callback `operator()`,
761/// but all the variations of the previous example could be given as well.
762/// @code
763/// struct MyCallbackObject {
764/// typedef void ResultType;
765/// void operator() (int id, MyEvent const& event) const
766/// {
767/// myCallback(id, event);
768/// }
769/// };
770///
771/// void myMainLoop5(bslma::Allocator *allocator = 0)
772/// {
773/// MyCallbackObject objA;
774/// MyEventDispatcher schedA(bdlf::BindUtil::bind(objA, _1, _2));
775/// schedA.dispatch(10);
776///
777/// MyCallbackObject objB;
778/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
779/// objB, _1, _2));
780/// schedB.run(10);
781/// }
782/// @endcode
783///
784/// ### Example 4: Binding to Function Objects by Reference {#bdlf_bind-example-4-binding-to-function-objects-by-reference}
785///
786///
787/// The following example reuses the `MyCallbackObject` of the previous example,
788/// but illustrates that it can be passed by reference as well as by value:
789/// @code
790/// void myMainLoop6(bslma::Allocator *allocator = 0)
791/// {
792/// MyCallbackObject objA;
793/// MyEventScheduler schedA(bdlf::BindUtil::bind(&objA, _1, _2));
794/// schedA.run(10);
795///
796/// MyCallbackObject objB;
797/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
798/// &objB, _1, _2));
799/// schedB.run(10);
800/// }
801/// @endcode
802/// When passed by reference, only the address of the function object is copied.
803/// Hence the function object must remain valid throughout the lifetime of the
804/// binder.
805///
806/// ### Example 5: Binding to Member Functions {#bdlf_bind-example-5-binding-to-member-functions}
807///
808///
809/// In the next example, we show that the callback function can be a member
810/// function, in which case there are three, not two, bound arguments. The
811/// first bound argument must be a pointer to an instance of the class owning
812/// the member function.
813/// @code
814/// struct MyStatefulObject {
815///
816/// // DATA
817/// // ...
818///
819/// public:
820/// void callback(int, MyEvent const& event)
821/// {
822/// // Do something that may modify the state info...
823/// }
824/// };
825///
826/// void myMainLoop7(bslma::Allocator *allocator = 0)
827/// {
828/// MyStatefulObject objA;
829/// MyEventScheduler schedA(bdlf::BindUtil::bind(
830/// &MyStatefulObject::callback, &objA, _1, _2));
831/// schedA.run(10);
832///
833/// MyStatefulObject objB;
834/// MyEventScheduler schedB(bdlf::BindUtil::bindS(allocator,
835/// &MyStatefulObject::callback, &objB, _1, _2));
836/// schedB.run(10);
837/// }
838/// @endcode
839///
840/// ### Example 6: Nesting Bindings {#bdlf_bind-example-6-nesting-bindings}
841///
842///
843/// We now show that it is possible to provide a binder as an argument to
844/// `bdlf::BindUtil`. Upon invocation, the invocation arguments are forwarded
845/// to the nested binder.
846/// @code
847/// MyEvent annotateEvent(int, MyEvent const& event) {
848/// // Do something to 'event' ...
849/// return event;
850/// }
851///
852/// void myMainLoop8(bslma::Allocator *allocator = 0)
853/// {
854/// MyCallbackObject objA;
855/// MyEventScheduler schedA(
856/// bdlf::BindUtil::bind(&objA, _1,
857/// bdlf::BindUtil::bind(&annotateEvent, _1, _2)));
858/// schedA.run(10);
859///
860/// MyCallbackObject objB;
861/// MyEventScheduler schedB(
862/// bdlf::BindUtil::bindS(allocator, &objB, _1,
863/// bdlf::BindUtil::bindS(allocator, &annotateEvent, _1, _2)));
864/// schedB.run(10);
865/// }
866/// @endcode
867///
868/// ### Example 7: Binding to a Function Object with Explicit Return Type {#bdlf_bind-example-7-binding-to-a-function-object-with-explicit-return-type}
869///
870///
871/// When the return type cannot be inferred from the bound functor (using
872/// `typename t_FUNC::ResultType`), the binder needs an explicit specification.
873/// This is done by using the `bdlf::BindUtil::bindR` function template as
874/// exemplified below:
875/// @code
876/// typedef void GlobalResultType;
877/// struct MyCallbackObjectWithoutResultType {
878/// GlobalResultType operator() (int id, MyEvent const& event) const
879/// {
880/// myCallback(id, event);
881/// }
882/// };
883///
884/// void myMainLoop9(bslma::Allocator *allocator = 0)
885/// {
886/// MyCallbackObjectWithoutResultType objA;
887/// MyEventScheduler schedA(bdlf::BindUtil::
888/// bindR<GlobalResultType>(objA, _1, _2));
889/// schedA.run(10);
890///
891/// MyCallbackObjectWithoutResultType objB;
892/// MyEventScheduler schedB(bdlf::BindUtil::
893/// bindSR<GlobalResultType>(allocator, objB, _1, _2));
894/// schedB.run(10);
895/// }
896/// @endcode
897/// Another situation where the return type (in fact, the whole signature)
898/// cannot be inferred from the bound functor is the use of the free function
899/// with C linkage and variable number of arguments `printf(const char*, ...)`.
900/// In the following code snippet, we show how the argument to the `callBinder`
901/// function (redefined below for the reader's convenience) of section
902/// "Elementary construction and usage of bdlf::Bind objects" above can be
903/// bound to `printf`:
904/// @code
905/// template <class BINDER>
906/// void callBinder(BINDER const& b)
907/// {
908/// b(10, 14);
909/// }
910///
911/// void bindTest7(bslma::Allocator *allocator = 0)
912/// {
913/// const char *formatString = "Here it is: %d %d\n";
914/// callBinder(bdlf::BindUtil::bindR<int>(&printf, formatString, _1, _2));
915/// }
916/// @endcode
917/// When called, `bindTest7` will create a binder, pass it to `callBinder` which
918/// will invoke it with arguments `10` and `14`, and the output will be:
919/// @code
920/// Here it is: 10 14
921/// @endcode
922/// @}
923/** @} */
924/** @} */
925
926/** @addtogroup bdl
927 * @{
928 */
929/** @addtogroup bdlf
930 * @{
931 */
932/** @addtogroup bdlf_bind
933 * @{
934 */
935
936#include <bdlscm_version.h>
937
938#include <bdlf_memfn.h>
939#include <bdlf_placeholder.h>
940
941#include <bslalg_constructorproxy.h>
942
943#include <bslma_allocator.h>
944#include <bslma_usesbslmaallocator.h>
945
946#include <bslmf_arraytopointer.h>
947#include <bslmf_conditional.h>
948#include <bslmf_forwardingtype.h>
949#include <bslmf_forwardingreftype.h>
950#include <bslmf_functionpointertraits.h>
951#include <bslmf_haspointersemantics.h>
952#include <bslmf_isbitwisemoveable.h>
953#include <bslmf_isnothrowmoveconstructible.h>
954#include <bslmf_matchanytype.h>
955#include <bslmf_memberfunctionpointertraits.h>
956#include <bslmf_nestedtraitdeclaration.h>
957#include <bslmf_nil.h>
958#include <bslmf_removecv.h>
959#include <bslmf_resulttype.h>
960#include <bslmf_tag.h>
961#include <bslmf_typelist.h>
962#include <bslmf_voidtype.h>
963
964#include <bsls_compilerfeatures.h>
965#include <bsls_keyword.h>
966
967#include <bsl_functional.h>
968#include <bsl_memory.h>
969
970#ifndef BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
971#include <bslmf_if.h>
972#endif // BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
973
974
975
976namespace bdlf {
977
978template <class t_RET, class t_FUNC> struct Bind_FuncTraits;
979template <class t_RET, int NUMARGS> struct Bind_Invoker;
980template <class BINDER, class t_ARG_TUPLE> struct Bind_Evaluator;
981
982} // close package namespace
983
984namespace bdlf {
985 struct Bind_BoundTuple0;
986template <class A1>
987 struct Bind_BoundTuple1;
988template <class A1, class A2>
989 struct Bind_BoundTuple2;
990template <class A1, class A2, class A3>
991 struct Bind_BoundTuple3;
992template <class A1, class A2, class A3, class A4>
993 struct Bind_BoundTuple4;
994template <class A1, class A2, class A3, class A4, class A5>
995 struct Bind_BoundTuple5;
996template <class A1, class A2, class A3, class A4, class A5, class A6>
997 struct Bind_BoundTuple6;
998template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
999 struct Bind_BoundTuple7;
1000template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1001 class A8>
1002 struct Bind_BoundTuple8;
1003template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1004 class A8, class A9>
1005 struct Bind_BoundTuple9;
1006template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1007 class A8, class A9, class A10>
1008 struct Bind_BoundTuple10;
1009template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1010 class A8, class A9, class A10, class A11>
1011 struct Bind_BoundTuple11;
1012template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1013 class A8, class A9, class A10, class A11, class A12>
1014 struct Bind_BoundTuple12;
1015template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1016 class A8, class A9, class A10, class A11, class A12, class A13>
1017 struct Bind_BoundTuple13;
1018template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1019 class A8, class A9, class A10, class A11, class A12, class A13,
1020 class A14>
1021 struct Bind_BoundTuple14;
1022 // 'Bind_BoundTuple ## N' is used by 'Bind' and 'BindWrapper' to
1023 // contain 'N' objects of independent types (some of which may be place
1024 // holders) bound to the functor.
1025
1026} // close package namespace
1027
1028namespace bdlf {
1029
1030 struct Bind_ArgTuple0;
1031template <class A1>
1032 struct Bind_ArgTuple1;
1033template <class A1, class A2>
1034 struct Bind_ArgTuple2;
1035template <class A1, class A2, class A3>
1036 struct Bind_ArgTuple3;
1037template <class A1, class A2, class A3, class A4>
1038 struct Bind_ArgTuple4;
1039template <class A1, class A2, class A3, class A4, class A5>
1040 struct Bind_ArgTuple5;
1041template <class A1, class A2, class A3, class A4, class A5, class A6>
1042 struct Bind_ArgTuple6;
1043template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1044 struct Bind_ArgTuple7;
1045template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1046 class A8>
1047 struct Bind_ArgTuple8;
1048template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1049 class A8, class A9>
1050 struct Bind_ArgTuple9;
1051template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1052 class A8, class A9, class A10>
1053 struct Bind_ArgTuple10;
1054template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1055 class A8, class A9, class A10, class A11>
1056 struct Bind_ArgTuple11;
1057template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1058 class A8, class A9, class A10, class A11, class A12>
1059 struct Bind_ArgTuple12;
1060template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1061 class A8, class A9, class A10, class A11, class A12, class A13>
1062 struct Bind_ArgTuple13;
1063template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1064 class A8, class A9, class A10, class A11, class A12, class A13,
1065 class A14>
1066 struct Bind_ArgTuple14;
1067 // 'Bind_ArgTuple ## N' is used by a call to a bound function to
1068 // contain 'N' objects (or references to objects) of independent types
1069 // being passed to a call to a bound fuction, to be forwarded to the
1070 // place holder arguments.
1071
1072template <class t_BOUND_TUPLE> struct Bind_CalcParameterMask;
1073template <class t_FUNC, class t_ARG_TUPLE, int INDEX, int OFFSET>
1074 struct Bind_MapParameter;
1075template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1076 struct Bind_ImplSelector;
1077
1078 // ==========================
1079 // class Bind_BoundTupleValue
1080 // ==========================
1081
1082// IMPLEMENTATION NOTE: This class template, as well as the
1083// 'bind_BoundTuple[0-14]' class templates, are always instantiated with
1084// template argument 'TYPE'. 'TYPE' is one of the 'A[0-14]' template
1085// parameters for 'bind_BoundTuple[0-14]'. Since 'TYPE' is *not* a reference
1086// or const types, it is always appropriate to take any value of these types by
1087// 'const&' to avoid unnecessary copies until the only one and final copy is
1088// done in the constructor proxy.
1089
1090/// This local class provides storage for a value of the specified `TYPE`
1091/// suitable for storing an argument value in one of the `Bind_BoundTuple*`
1092/// local classes. This general template definition ensures that the
1093/// allocator passed to the creators is passed through to the value if it
1094/// uses an allocator, using the `bslalg::ConstructorProxy` mechanism.
1095///
1096/// See @ref bdlf_bind
1097template <class TYPE>
1098class Bind_BoundTupleValue {
1099
1100 BSLMF_ASSERT(!bslmf::MovableRefUtil::IsReference<TYPE>::value);
1101
1102 // PRIVATE INSTANCE DATA
1103 bslalg::ConstructorProxy<TYPE> d_value;
1104
1105 public:
1106 // CREATORS
1107
1108 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1109 /// specified `original` value, using `basicAllocator` to supply any
1110 /// memory.
1111 Bind_BoundTupleValue(const Bind_BoundTupleValue<TYPE>& original,
1112 bslma::Allocator *basicAllocator)
1113 : d_value(original.d_value, basicAllocator)
1114 {
1115 }
1116
1117 /// Create a `Bind_BoundTupleValue` object holding the moved value of
1118 /// the specified `original` value, using `basicAllocator` to supply any
1119 /// memory.
1120 Bind_BoundTupleValue(
1121 bslmf::MovableRef<Bind_BoundTupleValue<TYPE> > original,
1122 bslma::Allocator *basicAllocator)
1123 : d_value(bslmf::MovableRefUtil::move(
1124 bslmf::MovableRefUtil::access(original).d_value),
1125 basicAllocator)
1126 {
1127 }
1128
1129 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1130 /// specified `value`, using `basicAllocator` to supply any memory.
1131 Bind_BoundTupleValue(const TYPE& value,
1132 bslma::Allocator *basicAllocator)
1133 : d_value(value, basicAllocator)
1134 {
1135 }
1136
1137 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1138 /// specified `value`, using `basicAllocator` to supply any memory.
1139 Bind_BoundTupleValue(bslmf::MovableRef<TYPE> value,
1140 bslma::Allocator *basicAllocator)
1141 : d_value(bslmf::MovableRefUtil::move(value), basicAllocator)
1142 {
1143 }
1144
1145 // MANIPULATORS
1146
1147 /// Return a reference to the modifiable object held by this proxy.
1148 TYPE& value() { return d_value.object(); }
1149
1150 // ACCESSORS
1151
1152 /// Return a reference to the non-modifiable object held by this proxy.
1153 const TYPE& value() const { return d_value.object(); }
1154};
1155
1156 // ======================
1157 // class Bind_BoundTuple*
1158 // ======================
1159
1160/// This `struct` provides the creators for a list of zero arguments.
1161struct Bind_BoundTuple0 : bslmf::TypeList0 {
1162
1163 // TRAITS
1164 BSLMF_NESTED_TRAIT_DECLARATION(Bind_BoundTuple0,
1165 bslmf::IsBitwiseMoveable);
1166
1167 // CREATORS
1168 Bind_BoundTuple0()
1169 {
1170 }
1171
1175};
1176
1177/// This `struct` stores a list of one argument. It does *not* use the
1178/// const-forwarding type of its argument, unlike `Bind_ArgTuple1` which
1179/// applies that optimization to avoid unnecessary copying.
1180template <class A1>
1181struct Bind_BoundTuple1 : bslmf::TypeList1<A1>
1182{
1183
1184 // TRAITS
1185 BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple1,
1186 bslmf::IsBitwiseMoveable,
1187 bslmf::IsBitwiseMoveable<A1>::value);
1188
1189 // INSTANCE DATA
1190 Bind_BoundTupleValue<A1> d_a1;
1191
1192 // CREATORS
1193 Bind_BoundTuple1(const Bind_BoundTuple1<A1>& orig,
1194 bslma::Allocator *allocator = 0)
1195 : d_a1(orig.d_a1, allocator)
1196 {
1197 }
1198
1199 Bind_BoundTuple1(bslmf::MovableRef<Bind_BoundTuple1<A1> > orig,
1200 bslma::Allocator *allocator = 0)
1201 : d_a1(bslmf::MovableRefUtil::move(
1202 bslmf::MovableRefUtil::access(orig).d_a1),
1203 allocator)
1204 {
1205 }
1206
1207 explicit Bind_BoundTuple1(A1 const& a1, bslma::Allocator *allocator = 0)
1208 : d_a1(a1, allocator)
1209 {
1210 }
1211
1212 explicit Bind_BoundTuple1(bslmf::MovableRef<A1> a1,
1213 bslma::Allocator *allocator = 0)
1214 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
1215 {
1216 }
1217};
1218
1219 // ==========
1220 // class Bind
1221 // ==========
1222
1223/// This bind class select the implementation for the given template
1224/// arguments. Note that instances of this class should not be created
1225/// explicitly, instead use the `BindUtil` factory methods.
1226///
1227/// See @ref bdlf_bind
1228template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1229class Bind : public Bind_ImplSelector<t_RET, t_FUNC, t_BOUND_TUPLE>::Type {
1230
1231 // PRIVATE TYPES
1232 typedef typename Bind_ImplSelector<t_RET,
1233 t_FUNC,
1234 t_BOUND_TUPLE>::Type Base;
1235
1236 public:
1237 // TRAITS
1238 BSLMF_NESTED_TRAIT_DECLARATION(Bind, bslma::UsesBslmaAllocator);
1239 BSLMF_NESTED_TRAIT_DECLARATION_IF(
1240 Bind,
1241 bslmf::IsBitwiseMoveable,
1242 bslmf::IsBitwiseMoveable<t_FUNC>::value &&
1243 bslmf::IsBitwiseMoveable<t_BOUND_TUPLE>::value)
1244
1245 // CREATORS
1246
1247 /// Create a `Bind` object that is bound to the specified `func`
1248 /// invocable object with the specified argument list `list`.
1249 /// Optionally specify an `allocator` used to supply memory. If
1250 /// `allocator` is 0, the currently installed default allocator is used.
1251 Bind(typename bslmf::ForwardingType<t_FUNC>::Type func,
1252 t_BOUND_TUPLE const& list,
1253 bslma::Allocator *allocator = 0)
1254 : Base(func, list, allocator)
1255 {
1256 }
1257
1258 /// Create a `Bind` object that is bound to the specified `func`
1259 /// invocable object with the specified argument list `list` moved into
1260 /// the object. Optionally specify an `allocator` used to supply
1261 /// memory. If `allocator` is 0, the currently installed default
1262 /// allocator is used.
1263 Bind(typename bslmf::ForwardingType<t_FUNC>::Type func,
1264 bslmf::MovableRef<t_BOUND_TUPLE> list,
1265 bslma::Allocator *allocator = 0)
1266 : Base(func, bslmf::MovableRefUtil::move(list), allocator)
1267 {
1268 }
1269
1270 /// Create a `Bind` object that is bound to the same invocable object
1271 /// with the same bound parameters as the specified `other`. Optionally
1272 /// specify an `allocator` used to supply memory. If `allocator` is 0,
1273 /// the currently installed default allocator is used.
1274 Bind(const Bind& other, bslma::Allocator *allocator = 0)
1275 : Base(other, allocator)
1276 {
1277 }
1278
1279 // NOTE: This should probably be conditionally noexcept based on
1280 // bsl::is_nothrow_move_constructible for 't_FUNC' and 't_BOUND_TUPLE'.
1281 // Not sure if Bind_BoundTupleValue could be made conditionally nothrow
1282 // move constructible though due to its use of ConstructorProxy
1283
1284 /// Create a `Bind` object that is bound to the same invocable object
1285 /// with the same bound parameters as the specified `other`. Optionally
1286 /// specify an `allocator` used to supply memory. If `allocator` is 0,
1287 /// the currently installed default allocator is used.
1288 Bind(bslmf::MovableRef<Bind> other, bslma::Allocator *allocator = 0)
1289 : Base(bslmf::MovableRefUtil::move(other), allocator)
1290 {
1291 }
1292};
1293
1294 // =================
1295 // class BindWrapper
1296 // =================
1297
1298/// This wrapper class provides a binder with shared pointer semantics to a
1299/// non-modifiable binder (both `operator*` and `operator->` accessors) and
1300/// forward its construction arguments to the underlying binder. Note that
1301/// instances of this class should not be created explicitly, instead use
1302/// the `BindUtil` factory methods. Note also that instances of this class
1303/// can be invoked directly, in order to meet user expectations that the
1304/// result of `BindUtil::bind` be an invocable just as the result of
1305/// `bdlf::BindUtil::bind` is; in that case, the invocation parameters are
1306/// simply forwarded to the shared binder. Note finally that even though
1307/// this wrapper has pointer semantics for the `operator*` and `operator->`,
1308/// it has value semantics for the invocation: invoking a non-modifiable
1309/// wrapper will forward the invocation to the non-modifiable binder shared
1310/// by that wrapper, even though pointer semantics have it .
1311///
1312/// See @ref bdlf_bind
1313template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1314class BindWrapper {
1315
1316 private:
1317 // PRIVATE TYPES
1318
1319 /// This `typedef` is a convenient alias for the utility associated with
1320 /// movable references.
1321 typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
1322
1323 // DATA
1324 bsl::shared_ptr<const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE> > d_impl;
1325
1326 public:
1327 // TRAITS
1328 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::HasPointerSemantics);
1329 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::IsBitwiseMoveable);
1330 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper,
1331 bsl::is_nothrow_move_constructible);
1332
1333 // PUBLIC TYPES
1334
1335 /// The return type of this binder object.
1336 typedef typename bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
1337 ResultType;
1338
1339 // CREATORS
1340
1341 /// Create a wrapper with shared pointer semantics around a binder
1342 /// constructed with the specified `func` invocable and specified
1343 /// `tuple` bound arguments. Optionally specify the `allocator`.
1344 BindWrapper(typename bslmf::ForwardingType<t_FUNC>::Type func,
1345 const t_BOUND_TUPLE& tuple,
1346 bslma::Allocator *allocator = 0)
1347 {
1348 this->d_impl.createInplace(allocator, func, tuple, allocator);
1349 }
1350
1351 /// Create a wrapper with shared pointer semantics around a binder
1352 /// constructed with the specified `func` invocable and specified
1353 /// `tuple` bound arguments. Optionally specify the `allocator`.
1354 BindWrapper(typename bslmf::ForwardingType<t_FUNC>::Type func,
1355 bslmf::MovableRef<t_BOUND_TUPLE> tuple,
1356 bslma::Allocator *allocator = 0)
1357 {
1358 this->d_impl.createInplace(allocator,
1359 func,
1360 bslmf::MovableRefUtil::move(tuple),
1361 allocator);
1362 }
1363
1364 /// Create a wrapper that shares ownership of the binder of the
1365 /// specified `original`.
1366 BindWrapper(const BindWrapper<t_RET,t_FUNC,t_BOUND_TUPLE>& original)
1367 : d_impl(original.d_impl)
1368 {
1369 }
1370
1371 /// Create a wrapper that assumes ownership of the binder of the
1372 /// specified `original`.
1373 BindWrapper(bslmf::MovableRef<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE> >
1374 original) BSLS_KEYWORD_NOEXCEPT
1375 : d_impl(MoveUtil::move(MoveUtil::access(original).d_impl))
1376 {
1377 }
1378
1379 //ACCESSORS
1380
1381 /// Invoke the bound object using the invocation parameters provided at
1382 /// construction of this `bdlf::Bind` object, substituting place-holders
1383 /// for their respective values in the specified `arguments`.
1384 template <class t_ARG_TUPLE>
1385 inline ResultType invoke(t_ARG_TUPLE& arguments) const
1386 {
1387 return d_impl->invoke(arguments);
1388 }
1389
1390 /// Return a reference to the non-modifiable binder shared by this
1391 /// wrapper.
1392 const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>& operator*() const
1393 {
1394 return *(this->d_impl);
1395 }
1396
1397 /// Return the address of the non-modifiable binder shared by this
1398 /// wrapper.
1399 const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>* operator->() const
1400 {
1401 return this->d_impl.ptr();
1402 }
1403
1404 /// Invoke the bound object using only the invocation parameters
1405 /// provided at construction of this `bdlf::Bind` object and return the
1406 /// result.
1407 inline ResultType operator()() const
1408 {
1409 return (*d_impl)();
1410 }
1411
1412 /// Invoke the bound object using the invocation template provided at
1413 /// construction of this `bdlf::Bind` object, substituting place-holders
1414 /// for argument 1 with the value of the specified argument `p1`.
1415 /// Return the result.
1416 template <class P1>
1417 inline ResultType operator()(P1& p1) const
1418 {
1419 return (*d_impl)(p1);
1420 }
1421
1422 /// Invoke the bound object using the invocation template provided at
1423 /// construction of this `bdlf::Bind` object, substituting place-holders
1424 /// for argument 1 with the value of the specified argument `p1`.
1425 /// Return the result.
1426 template <class P1>
1427 inline ResultType operator()(P1 const& p1) const
1428 {
1429 return (*d_impl)(p1);
1430 }
1431
1432 /// Invoke the bound object using the invocation template provided at
1433 /// construction of this `bdlf::Bind` object, substituting place-holders
1434 /// for arguments 1 and 2 with the value of the specified arguments
1435 /// `p1`, and `p2` respectively. Return the result.
1436 template <class P1, class P2>
1437 inline ResultType operator()(P1& p1, P2& p2) const
1438 {
1439 return (*d_impl)(p1, p2);
1440 }
1441
1442 /// Invoke the bound object using the invocation template provided at
1443 /// construction of this `bdlf::Bind` object, substituting place-holders
1444 /// for arguments 1 and 2 with the value of the specified arguments
1445 /// `p1`, and `p2` respectively. Return the result.
1446 template <class P1, class P2>
1447 inline ResultType operator()(P1 const& p1, P2 const& p2) const
1448 {
1449 return (*d_impl)(p1, p2);
1450 }
1451
1452 /// Invoke the bound object using the invocation template provided at
1453 /// construction of this `bdlf::Bind` object, substituting place-holders
1454 /// for arguments 1, 2, and 3 with the values of the specified arguments
1455 /// `p1`, `p2` and `p3` respectively. Return the result.
1456 template <class P1, class P2, class P3>
1457 inline ResultType operator()(P1& p1, P2& p2, P3& p3) const
1458 {
1459 return (*d_impl)(p1, p2, p3);
1460 }
1461
1462 /// Invoke the bound object using the invocation template provided at
1463 /// construction of this `bdlf::Bind` object, substituting place-holders
1464 /// for arguments 1, 2, and 3 with the values of the specified arguments
1465 /// `p1`, `p2` and `p3` respectively. Return the result.
1466 template <class P1, class P2, class P3>
1467 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3)
1468 const
1469 {
1470 return (*d_impl)(p1, p2, p3);
1471 }
1472
1473 /// Invoke the bound object using the invocation template provided at
1474 /// construction of this `bdlf::Bind` object, substituting place-holders
1475 /// for arguments 1 - 4 with the values of the specified arguments `p1`
1476 /// - `p4` respectively. Return the result.
1477 template <class P1, class P2, class P3, class P4>
1478 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4) const
1479 {
1480 return (*d_impl)(p1, p2, p3, p4);
1481 }
1482
1483 /// Invoke the bound object using the invocation template provided at
1484 /// construction of this `bdlf::Bind` object, substituting place-holders
1485 /// for arguments 1 - 4 with the values of the specified arguments `p1`
1486 /// - `p4` respectively. Return the result.
1487 template <class P1, class P2, class P3, class P4>
1488 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1489 P4 const& p4) const
1490 {
1491 return (*d_impl)(p1, p2, p3, p4);
1492 }
1493
1494 /// Invoke the bound object using the invocation template provided at
1495 /// construction of this `bdlf::Bind` object, substituting place-holders
1496 /// for arguments 1 - 5 with the values of the specified arguments `p1`
1497 /// - `p5` respectively. Return the result.
1498 template <class P1, class P2, class P3, class P4, class P5>
1499 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5) const
1500 {
1501 return (*d_impl)(p1, p2, p3, p4, p5);
1502 }
1503
1504 /// Invoke the bound object using the invocation template provided at
1505 /// construction of this `bdlf::Bind` object, substituting place-holders
1506 /// for arguments 1 - 5 with the values of the specified arguments `p1`
1507 /// - `p5` respectively. Return the result.
1508 template <class P1, class P2, class P3, class P4, class P5>
1509 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1510 P4 const& p4, P5 const& p5) const
1511 {
1512 return (*d_impl)(p1, p2, p3, p4, p5);
1513 }
1514
1515 /// Invoke the bound object using the invocation template provided at
1516 /// construction of this `bdlf::Bind` object, substituting place-holders
1517 /// for arguments 1 - 6 with the values of the specified arguments `p1`
1518 /// - `p7` respectively. Return the result.
1519 template <class P1, class P2, class P3, class P4, class P5, class P6>
1520 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1521 P6& p6) const
1522 {
1523 return (*d_impl)(p1, p2, p3, p4, p5, p6);
1524 }
1525
1526 /// Invoke the bound object using the invocation template provided at
1527 /// construction of this `bdlf::Bind` object, substituting place-holders
1528 /// for arguments 1 - 6 with the values of the specified arguments `p1`
1529 /// - `p7` respectively. Return the result.
1530 template <class P1, class P2, class P3, class P4, class P5, class P6>
1531 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1532 P4 const& p4, P5 const& p5, P6 const& p6)
1533 const
1534 {
1535 return (*d_impl)(p1, p2, p3, p4, p5, p6);
1536 }
1537
1538 /// Invoke the bound object using the invocation template provided at
1539 /// construction of this `bdlf::Bind` object, substituting place-holders
1540 /// for arguments 1 - 7 with the values of the specified arguments `p1`
1541 /// - `p7` respectively. Return the result.
1542 template <class P1, class P2, class P3, class P4, class P5, class P6,
1543 class P7>
1544 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1545 P6& p6, P7& p7) const
1546
1547 {
1548 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7);
1549 }
1550
1551 /// Invoke the bound object using the invocation template provided at
1552 /// construction of this `bdlf::Bind` object, substituting place-holders
1553 /// for arguments 1 - 7 with the values of the specified arguments `p1`
1554 /// - `p7` respectively. Return the result.
1555 template <class P1, class P2, class P3, class P4, class P5, class P6,
1556 class P7>
1557 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1558 P4 const& p4, P5 const& p5, P6 const& p6,
1559 P7 const& p7) const
1560
1561 {
1562 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7);
1563 }
1564
1565 /// Invoke the bound object using the invocation template provided at
1566 /// construction of this `bdlf::Bind` object, substituting place-holders
1567 /// for arguments 1 - 8 with the values of the specified arguments `p1`
1568 /// - `p8` respectively. Return the result.
1569 template <class P1, class P2, class P3, class P4, class P5, class P6,
1570 class P7, class P8>
1571 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1572 P6& p6, P7& p7, P8& p8) const
1573 {
1574 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8);
1575 }
1576
1577 /// Invoke the bound object using the invocation template provided at
1578 /// construction of this `bdlf::Bind` object, substituting place-holders
1579 /// for arguments 1 - 8 with the values of the specified arguments `p1`
1580 /// - `p8` respectively. Return the result.
1581 template <class P1, class P2, class P3, class P4, class P5, class P6,
1582 class P7, class P8>
1583 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1584 P4 const& p4, P5 const& p5, P6 const& p6,
1585 P7 const& p7, P8 const& p8) const
1586 {
1587 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8);
1588 }
1589
1590 /// Invoke the bound object using the invocation template provided at
1591 /// construction of this `bdlf::Bind` object, substituting place-holders
1592 /// for arguments 1 - 9 with the values of the specified arguments `p1`
1593 /// - `p9` respectively. Return the result.
1594 template <class P1, class P2, class P3, class P4, class P5, class P6,
1595 class P7, class P8, class P9>
1596 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1597 P6& p6, P7& p7, P8& p8, P9& p9) const
1598 {
1599 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1600 }
1601
1602 /// Invoke the bound object using the invocation template provided at
1603 /// construction of this `bdlf::Bind` object, substituting place-holders
1604 /// for arguments 1 - 9 with the values of the specified arguments `p1`
1605 /// - `p9` respectively. Return the result.
1606 template <class P1, class P2, class P3, class P4, class P5, class P6,
1607 class P7, class P8, class P9>
1608 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1609 P4 const& p4, P5 const& p5, P6 const& p6,
1610 P7 const& p7, P8 const& p8, P9 const& p9)
1611 const
1612 {
1613 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1614 }
1615
1616 /// Invoke the bound object using the invocation template provided at
1617 /// construction of this `bdlf::Bind` object, substituting place-holders
1618 /// for arguments 1 - 10 with the values of the specified arguments `p1`
1619 /// - `p10` respectively. Return the result.
1620 template <class P1, class P2, class P3, class P4, class P5, class P6,
1621 class P7, class P8, class P9, class P10>
1622 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1623 P6& p6, P7& p7, P8& p8, P9& p9,
1624 P10& p10) const
1625 {
1626 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1627 }
1628
1629 /// Invoke the bound object using the invocation template provided at
1630 /// construction of this `bdlf::Bind` object, substituting place-holders
1631 /// for arguments 1 - 10 with the values of the specified arguments `p1`
1632 /// - `p10` respectively. Return the result.
1633 template <class P1, class P2, class P3, class P4, class P5, class P6,
1634 class P7, class P8, class P9, class P10>
1635 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1636 P4 const& p4, P5 const& p5, P6 const& p6,
1637 P7 const& p7, P8 const& p8, P9 const& p9,
1638 P10 const& p10) const
1639 {
1640 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1641 }
1642
1643 /// Invoke the bound object using the invocation template provided at
1644 /// construction of this `bdlf::Bind` object, substituting place-holders
1645 /// for arguments 1 - 11 with the values of the specified arguments `p1`
1646 /// - `p11` respectively. Return the result.
1647 template <class P1, class P2, class P3, class P4, class P5, class P6,
1648 class P7, class P8, class P9, class P10, class P11>
1649 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1650 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1651 P11& p11) const
1652 {
1653 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
1654 }
1655
1656 /// Invoke the bound object using the invocation template provided at
1657 /// construction of this `bdlf::Bind` object, substituting place-holders
1658 /// for arguments 1 - 11 with the values of the specified arguments `p1`
1659 /// - `p11` respectively. Return the result.
1660 template <class P1, class P2, class P3, class P4, class P5, class P6,
1661 class P7, class P8, class P9, class P10, class P11>
1662 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1663 P4 const& p4, P5 const& p5, P6 const& p6,
1664 P7 const& p7, P8 const& p8, P9 const& p9,
1665 P10 const& p10, P11 const& p11) const
1666 {
1667 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
1668 }
1669
1670 /// Invoke the bound object using the invocation template provided at
1671 /// construction of this `bdlf::Bind` object, substituting place-holders
1672 /// for arguments 1 - 12 with the values of the specified arguments `p1`
1673 /// - `p12` respectively. Return the result.
1674 template <class P1, class P2, class P3, class P4, class P5, class P6,
1675 class P7, class P8, class P9, class P10, class P11, class P12>
1676 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1677 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1678 P11& p11, P12& p12) const
1679 {
1680 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
1681 }
1682
1683 /// Invoke the bound object using the invocation template provided at
1684 /// construction of this `bdlf::Bind` object, substituting place-holders
1685 /// for arguments 1 - 12 with the values of the specified arguments `p1`
1686 /// - `p12` respectively. Return the result.
1687 template <class P1, class P2, class P3, class P4, class P5, class P6,
1688 class P7, class P8, class P9, class P10, class P11, class P12>
1689 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1690 P4 const& p4, P5 const& p5, P6 const& p6,
1691 P7 const& p7, P8 const& p8, P9 const& p9,
1692 P10 const& p10, P11 const& p11,
1693 P12 const& p12) const
1694 {
1695 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
1696 }
1697
1698 /// Invoke the bound object using the invocation template provided at
1699 /// construction of this `bdlf::Bind` object, substituting place-holders
1700 /// for arguments 1 - 13 with the values of the specified arguments `p1`
1701 /// - `p13` respectively. Return the result.
1702 template <class P1, class P2, class P3, class P4, class P5, class P6,
1703 class P7, class P8, class P9, class P10, class P11, class P12,
1704 class P13>
1705 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1706 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1707 P11& p11, P12& p12, P13& p13) const
1708 {
1709 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1710 p13);
1711 }
1712
1713 /// Invoke the bound object using the invocation template provided at
1714 /// construction of this `bdlf::Bind` object, substituting place-holders
1715 /// for arguments 1 - 13 with the values of the specified arguments `p1`
1716 /// - `p13` respectively. Return the result.
1717 template <class P1, class P2, class P3, class P4, class P5, class P6,
1718 class P7, class P8, class P9, class P10, class P11, class P12,
1719 class P13>
1720 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1721 P4 const& p4, P5 const& p5, P6 const& p6,
1722 P7 const& p7, P8 const& p8, P9 const& p9,
1723 P10 const& p10, P11 const& p11,
1724 P12 const& p12, P13 const& p13) const
1725 {
1726 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1727 p13);
1728 }
1729
1730 /// Invoke the bound object using the invocation template provided at
1731 /// construction of this `bdlf::Bind` object, substituting place-holders
1732 /// for arguments 1 - 14 with the values of the specified arguments `p1`
1733 /// - `p14` respectively. Return the result.
1734 template <class P1, class P2, class P3, class P4, class P5, class P6,
1735 class P7, class P8, class P9, class P10, class P11, class P12,
1736 class P13, class P14>
1737 inline ResultType operator()(P1& p1, P2& p2, P3& p3,
1738 P4& p4, P5& p5, P6& p6,
1739 P7& p7, P8& p8, P9& p9,
1740 P10& p10, P11& p11, P12& p12,
1741 P13& p13, P14& p14) const
1742 {
1743 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1744 p13, p14);
1745 }
1746
1747 /// Invoke the bound object using the invocation template provided at
1748 /// construction of this `bdlf::Bind` object, substituting place-holders
1749 /// for arguments 1 - 14 with the values of the specified arguments `p1`
1750 /// - `p14` respectively. Return the result.
1751 template <class P1, class P2, class P3, class P4, class P5, class P6,
1752 class P7, class P8, class P9, class P10, class P11, class P12,
1753 class P13, class P14>
1754 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1755 P4 const& p4, P5 const& p5, P6 const& p6,
1756 P7 const& p7, P8 const& p8, P9 const& p9,
1757 P10 const& p10, P11 const& p11,
1758 P12 const& p12, P13 const& p13,
1759 P14 const& p14) const
1760 {
1761 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1762 p13, p14);
1763 }
1764};
1765
1766 // ==============
1767 // class BindUtil
1768 // ==============
1769
1770/// This `struct` provides a namespace for utility functions used to
1771/// construct `Bind` and `BindWrapper` objects. Four families of factory
1772/// methods are provided: `bind`, `bindR`, `bindS`, and `bindSR`.
1773/// All factory methods accept an invocable object, optionally followed by
1774/// up to fourteen additional arguments. Each argument can be either a
1775/// literal value, a place-holder, or another `Bind` or `BindWrapper`
1776/// object.
1777///
1778/// The `BindUtil` class methods compute the signature of the function
1779/// object automatically, including the return type, and return a binder
1780/// object with the specified bound functor and bound arguments. Memory for
1781/// copying the bound functor and bound arguments is supplied by the user
1782/// specified allocator if `bindS`, or `bindSR` is used, or the currently
1783/// installed default allocator, if `bind` or `bindR` is used. The return
1784/// type is inferred by using `bslmf::FunctionPointerTraits` for free
1785/// function references and pointers, `bslmf::MemberFunctionPointerTraits`
1786/// for member function pointers, and `typenname t_FUNC::ResultType` for a
1787/// functor of type `t_FUNC`.
1788///
1789/// The `bindR` and `bindSR` variations must be used when binding to an
1790/// object for which a result type cannot be automatically determined.
1791///
1792/// See @ref bdlf_bind
1793class BindUtil {
1794
1795 // PRIVATE TYPES
1796
1797 /// Decay the type of the argument to the `bind*` function into the type
1798 /// of storage needed to store in in the `Bind_BoundTuple`. We cannot
1799 /// just use `bslmf::MovableRefUtil::Decay` because it will turn
1800 /// `const Type(&)[]` into `Type *` which cannot be constructed from
1801 /// `const Type(&)[]`, so we use `ArrayToConstPointer` to turn such
1802 /// arrays into `const Type *`.
1803 ///
1804 /// See @ref bdlf_bind
1805 template <class TYPE>
1806 class Storage_Type {
1807
1808 // PRIVATE TYPES
1809 typedef typename bslmf::MovableRefUtil::RemoveReference<TYPE>::type
1810 TypeA;
1811 typedef typename bslmf::ArrayToConstPointer<TypeA>::Type TypeB;
1812
1813 public:
1814 // PUBLIC TYPES
1815 typedef typename bsl::remove_cv<TypeB>::type type;
1816 };
1817
1818 typedef bslmf::MovableRefUtil MoveUtil;
1819
1820 public:
1821 // CLASS METHODS
1822
1823 // - - - - 'bind' methods - - - -
1824
1825 /// Return a `Bind` object that is bound to the specified `func`
1826 /// invocable object, which can be invoked with no parameters.
1827 template <class t_FUNC>
1828 static
1829 Bind<bslmf::Nil, t_FUNC, Bind_BoundTuple0>
1830 bind(t_FUNC func)
1831 {
1832 return Bind<bslmf::Nil, t_FUNC, Bind_BoundTuple0>
1833 (func, Bind_BoundTuple0());
1834 }
1835
1836 /// Return a `Bind` object that is bound to the specified invocable
1837 /// object `func`, which can be invoked with one parameter.
1838 template <class t_FUNC, class P1>
1839 static
1840 Bind<bslmf::Nil,
1841 t_FUNC,
1842 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
1843 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
1844 {
1845 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
1846 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1));
1847
1848 return Bind<bslmf::Nil,
1849 t_FUNC,
1850 BoundList>(func, MoveUtil::move(list));
1851 }
1852
1853 /// Return a `Bind` object that is bound to the specified invocable
1854 /// object `func`, which can be invoked with two parameters.
1855 template <class t_FUNC, class P1, class P2>
1856 static
1857 Bind<bslmf::Nil,
1858 t_FUNC,
1859 Bind_BoundTuple2<typename Storage_Type<P1>::type,
1860 typename Storage_Type<P2>::type> >
1861 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1862 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
1863 {
1864 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
1865 typename Storage_Type<P2>::type> BoundList;
1866
1867 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1868 BSLS_COMPILERFEATURES_FORWARD(P2, p2));
1869
1870 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1871 }
1872
1873 /// Return a `Bind` object that is bound to the specified invocable
1874 /// object `func`, which can be invoked with three parameters.
1875 template <class t_FUNC, class P1, class P2, class P3>
1876 static
1877 Bind<bslmf::Nil,
1878 t_FUNC,
1879 Bind_BoundTuple3<typename Storage_Type<P1>::type,
1880 typename Storage_Type<P2>::type,
1881 typename Storage_Type<P3>::type> >
1882 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1883 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1884 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
1885 {
1886 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
1887 typename Storage_Type<P2>::type,
1888 typename Storage_Type<P3>::type> BoundList;
1889
1890 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1891 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1892 BSLS_COMPILERFEATURES_FORWARD(P3, p3));
1893
1894 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1895 }
1896
1897 /// Return a `Bind` object that is bound to the specified invocable
1898 /// object `func`, which can be invoked with four parameters.
1899 template <class t_FUNC, class P1, class P2, class P3, class P4>
1900 static
1901 Bind<bslmf::Nil,
1902 t_FUNC,
1903 Bind_BoundTuple4<typename Storage_Type<P1>::type,
1904 typename Storage_Type<P2>::type,
1905 typename Storage_Type<P3>::type,
1906 typename Storage_Type<P4>::type> >
1907 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1908 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1909 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1910 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
1911 {
1912 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
1913 typename Storage_Type<P2>::type,
1914 typename Storage_Type<P3>::type,
1915 typename Storage_Type<P4>::type> BoundList;
1916
1917 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1918 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1919 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1920 BSLS_COMPILERFEATURES_FORWARD(P4, p4));
1921
1922 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1923 }
1924
1925 /// Return a `Bind` object that is bound to the specified invocable
1926 /// object `func`, which can be invoked with five parameters.
1927 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5>
1928 static
1929 Bind<bslmf::Nil,
1930 t_FUNC,
1931 Bind_BoundTuple5<typename Storage_Type<P1>::type,
1932 typename Storage_Type<P2>::type,
1933 typename Storage_Type<P3>::type,
1934 typename Storage_Type<P4>::type,
1935 typename Storage_Type<P5>::type> >
1936 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1937 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1938 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1939 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
1940 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
1941 {
1942 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
1943 typename Storage_Type<P2>::type,
1944 typename Storage_Type<P3>::type,
1945 typename Storage_Type<P4>::type,
1946 typename Storage_Type<P5>::type> BoundList;
1947
1948 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1949 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1950 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1951 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
1952 BSLS_COMPILERFEATURES_FORWARD(P5, p5));
1953
1954 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1955 }
1956
1957 /// Return a `Bind` object that is bound to the specified invocable
1958 /// object `func`, which can be invoked with six parameters.
1959 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
1960 class P6>
1961 static
1962 Bind<bslmf::Nil,
1963 t_FUNC,
1964 Bind_BoundTuple6<typename Storage_Type<P1>::type,
1965 typename Storage_Type<P2>::type,
1966 typename Storage_Type<P3>::type,
1967 typename Storage_Type<P4>::type,
1968 typename Storage_Type<P5>::type,
1969 typename Storage_Type<P6>::type> >
1970 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1971 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1972 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1973 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
1974 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
1975 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
1976 {
1977 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
1978 typename Storage_Type<P2>::type,
1979 typename Storage_Type<P3>::type,
1980 typename Storage_Type<P4>::type,
1981 typename Storage_Type<P5>::type,
1982 typename Storage_Type<P6>::type> BoundList;
1983
1984 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1985 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1986 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1987 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
1988 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
1989 BSLS_COMPILERFEATURES_FORWARD(P6, p6));
1990
1991 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1992 }
1993
1994 /// Return a `Bind` object that is bound to the specified invocable
1995 /// object `func`, which can be invoked with seven parameters.
1996 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
1997 class P6, class P7>
1998 static
1999 Bind<bslmf::Nil,
2000 t_FUNC,
2001 Bind_BoundTuple7<typename Storage_Type<P1>::type,
2002 typename Storage_Type<P2>::type,
2003 typename Storage_Type<P3>::type,
2004 typename Storage_Type<P4>::type,
2005 typename Storage_Type<P5>::type,
2006 typename Storage_Type<P6>::type,
2007 typename Storage_Type<P7>::type> >
2008 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2009 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2010 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2011 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2012 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2013 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2014 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
2015 {
2016 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
2017 typename Storage_Type<P2>::type,
2018 typename Storage_Type<P3>::type,
2019 typename Storage_Type<P4>::type,
2020 typename Storage_Type<P5>::type,
2021 typename Storage_Type<P6>::type,
2022 typename Storage_Type<P7>::type> BoundList;
2023
2024 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2025 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2026 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2027 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2028 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2029 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2030 BSLS_COMPILERFEATURES_FORWARD(P7, p7));
2031
2032 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2033 }
2034
2035 /// Return a `Bind` object that is bound to the specified invocable
2036 /// object `func`, which can be invoked with eight parameters.
2037 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2038 class P6, class P7, class P8>
2039 static
2040 Bind<bslmf::Nil,
2041 t_FUNC,
2042 Bind_BoundTuple8<typename Storage_Type<P1>::type,
2043 typename Storage_Type<P2>::type,
2044 typename Storage_Type<P3>::type,
2045 typename Storage_Type<P4>::type,
2046 typename Storage_Type<P5>::type,
2047 typename Storage_Type<P6>::type,
2048 typename Storage_Type<P7>::type,
2049 typename Storage_Type<P8>::type> >
2050 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2051 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2052 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2053 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2054 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2055 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2056 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2057 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
2058 {
2059 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
2060 typename Storage_Type<P2>::type,
2061 typename Storage_Type<P3>::type,
2062 typename Storage_Type<P4>::type,
2063 typename Storage_Type<P5>::type,
2064 typename Storage_Type<P6>::type,
2065 typename Storage_Type<P7>::type,
2066 typename Storage_Type<P8>::type> BoundList;
2067
2068 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2069 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2070 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2071 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2072 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2073 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2074 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2075 BSLS_COMPILERFEATURES_FORWARD(P8, p8));
2076
2077 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2078 }
2079
2080 /// Return a `Bind` object that is bound to the specified invocable
2081 /// object `func`, which can be invoked with nine parameters.
2082 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2083 class P6, class P7, class P8, class P9>
2084 static
2085 Bind<bslmf::Nil,
2086 t_FUNC,
2087 Bind_BoundTuple9<typename Storage_Type<P1>::type,
2088 typename Storage_Type<P2>::type,
2089 typename Storage_Type<P3>::type,
2090 typename Storage_Type<P4>::type,
2091 typename Storage_Type<P5>::type,
2092 typename Storage_Type<P6>::type,
2093 typename Storage_Type<P7>::type,
2094 typename Storage_Type<P8>::type,
2095 typename Storage_Type<P9>::type> >
2096 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2097 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2098 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2099 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2100 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2101 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2102 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2103 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2104 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
2105 {
2106 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
2107 typename Storage_Type<P2>::type,
2108 typename Storage_Type<P3>::type,
2109 typename Storage_Type<P4>::type,
2110 typename Storage_Type<P5>::type,
2111 typename Storage_Type<P6>::type,
2112 typename Storage_Type<P7>::type,
2113 typename Storage_Type<P8>::type,
2114 typename Storage_Type<P9>::type> BoundList;
2115
2116 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2117 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2118 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2119 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2120 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2121 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2122 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2123 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2124 BSLS_COMPILERFEATURES_FORWARD(P9, p9));
2125
2126 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2127 }
2128
2129 /// Return a `Bind` object that is bound to the specified invocable
2130 /// object `func`, which can be invoked with ten parameters.
2131 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2132 class P6, class P7, class P8, class P9, class P10>
2133 static
2134 Bind<bslmf::Nil,
2135 t_FUNC,
2136 Bind_BoundTuple10<typename Storage_Type<P1>::type,
2137 typename Storage_Type<P2>::type,
2138 typename Storage_Type<P3>::type,
2139 typename Storage_Type<P4>::type,
2140 typename Storage_Type<P5>::type,
2141 typename Storage_Type<P6>::type,
2142 typename Storage_Type<P7>::type,
2143 typename Storage_Type<P8>::type,
2144 typename Storage_Type<P9>::type,
2145 typename Storage_Type<P10>::type> >
2146 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2147 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2148 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2149 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2150 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2151 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2152 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2153 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2154 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2155 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
2156 {
2157 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
2158 typename Storage_Type<P2>::type,
2159 typename Storage_Type<P3>::type,
2160 typename Storage_Type<P4>::type,
2161 typename Storage_Type<P5>::type,
2162 typename Storage_Type<P6>::type,
2163 typename Storage_Type<P7>::type,
2164 typename Storage_Type<P8>::type,
2165 typename Storage_Type<P9>::type,
2166 typename Storage_Type<P10>::type> BoundList;
2167
2168 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2169 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2170 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2171 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2172 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2173 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2174 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2175 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2176 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2177 BSLS_COMPILERFEATURES_FORWARD(P10, p10));
2178
2179 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2180 }
2181
2182 /// Return a `Bind` object that is bound to the specified invocable
2183 /// object `func`, which can be invoked with eleven parameters.
2184 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2185 class P6, class P7, class P8, class P9, class P10, class P11>
2186 static
2187 Bind<bslmf::Nil,
2188 t_FUNC,
2189 Bind_BoundTuple11<typename Storage_Type<P1>::type,
2190 typename Storage_Type<P2>::type,
2191 typename Storage_Type<P3>::type,
2192 typename Storage_Type<P4>::type,
2193 typename Storage_Type<P5>::type,
2194 typename Storage_Type<P6>::type,
2195 typename Storage_Type<P7>::type,
2196 typename Storage_Type<P8>::type,
2197 typename Storage_Type<P9>::type,
2198 typename Storage_Type<P10>::type,
2199 typename Storage_Type<P11>::type> >
2200 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2201 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2202 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2203 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2204 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2205 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2206 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2207 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2208 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2209 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2210 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
2211 {
2212 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
2213 typename Storage_Type<P2>::type,
2214 typename Storage_Type<P3>::type,
2215 typename Storage_Type<P4>::type,
2216 typename Storage_Type<P5>::type,
2217 typename Storage_Type<P6>::type,
2218 typename Storage_Type<P7>::type,
2219 typename Storage_Type<P8>::type,
2220 typename Storage_Type<P9>::type,
2221 typename Storage_Type<P10>::type,
2222 typename Storage_Type<P11>::type> BoundList;
2223
2224 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2225 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2226 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2227 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2228 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2229 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2230 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2231 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2232 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2233 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2234 BSLS_COMPILERFEATURES_FORWARD(P11, p11));
2235
2236 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2237 }
2238
2239 /// Return a `Bind` object that is bound to the specified invocable
2240 /// object `func`, which can be invoked with twelve parameters.
2241 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2242 class P6, class P7, class P8, class P9, class P10, class P11,
2243 class P12>
2244 static
2245 Bind<bslmf::Nil,
2246 t_FUNC,
2247 Bind_BoundTuple12<typename Storage_Type<P1>::type,
2248 typename Storage_Type<P2>::type,
2249 typename Storage_Type<P3>::type,
2250 typename Storage_Type<P4>::type,
2251 typename Storage_Type<P5>::type,
2252 typename Storage_Type<P6>::type,
2253 typename Storage_Type<P7>::type,
2254 typename Storage_Type<P8>::type,
2255 typename Storage_Type<P9>::type,
2256 typename Storage_Type<P10>::type,
2257 typename Storage_Type<P11>::type,
2258 typename Storage_Type<P12>::type> >
2259 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2260 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2261 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2262 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2263 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2264 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2265 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2266 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2267 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2268 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2269 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2270 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
2271 {
2272 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
2273 typename Storage_Type<P2>::type,
2274 typename Storage_Type<P3>::type,
2275 typename Storage_Type<P4>::type,
2276 typename Storage_Type<P5>::type,
2277 typename Storage_Type<P6>::type,
2278 typename Storage_Type<P7>::type,
2279 typename Storage_Type<P8>::type,
2280 typename Storage_Type<P9>::type,
2281 typename Storage_Type<P10>::type,
2282 typename Storage_Type<P11>::type,
2283 typename Storage_Type<P12>::type> BoundList;
2284
2285 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2286 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2287 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2288 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2289 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2290 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2291 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2292 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2293 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2294 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2295 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2296 BSLS_COMPILERFEATURES_FORWARD(P12, p12));
2297
2298 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2299 }
2300
2301 /// Return a `Bind` object that is bound to the specified invocable
2302 /// object `func`, which can be invoked with thirteen parameters.
2303 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2304 class P6, class P7, class P8, class P9, class P10, class P11,
2305 class P12, class P13>
2306 static
2307 Bind<bslmf::Nil,
2308 t_FUNC,
2309 Bind_BoundTuple13<typename Storage_Type<P1>::type,
2310 typename Storage_Type<P2>::type,
2311 typename Storage_Type<P3>::type,
2312 typename Storage_Type<P4>::type,
2313 typename Storage_Type<P5>::type,
2314 typename Storage_Type<P6>::type,
2315 typename Storage_Type<P7>::type,
2316 typename Storage_Type<P8>::type,
2317 typename Storage_Type<P9>::type,
2318 typename Storage_Type<P10>::type,
2319 typename Storage_Type<P11>::type,
2320 typename Storage_Type<P12>::type,
2321 typename Storage_Type<P13>::type> >
2322 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2323 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2324 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2325 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2326 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2327 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2328 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2329 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2330 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2331 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2332 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2333 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2334 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
2335 {
2336 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
2337 typename Storage_Type<P2>::type,
2338 typename Storage_Type<P3>::type,
2339 typename Storage_Type<P4>::type,
2340 typename Storage_Type<P5>::type,
2341 typename Storage_Type<P6>::type,
2342 typename Storage_Type<P7>::type,
2343 typename Storage_Type<P8>::type,
2344 typename Storage_Type<P9>::type,
2345 typename Storage_Type<P10>::type,
2346 typename Storage_Type<P11>::type,
2347 typename Storage_Type<P12>::type,
2348 typename Storage_Type<P13>::type> BoundList;
2349
2350 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2351 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2352 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2353 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2354 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2355 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2356 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2357 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2358 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2359 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2360 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2361 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
2362 BSLS_COMPILERFEATURES_FORWARD(P13, p13));
2363
2364 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2365 }
2366
2367 /// Return a `Bind` object that is bound to the specified invocable
2368 /// object `func`, which can be invoked with fourteen parameters.
2369 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2370 class P6, class P7, class P8, class P9, class P10, class P11,
2371 class P12, class P13, class P14>
2372 static
2373 Bind<bslmf::Nil,
2374 t_FUNC,
2375 Bind_BoundTuple14<typename Storage_Type<P1>::type,
2376 typename Storage_Type<P2>::type,
2377 typename Storage_Type<P3>::type,
2378 typename Storage_Type<P4>::type,
2379 typename Storage_Type<P5>::type,
2380 typename Storage_Type<P6>::type,
2381 typename Storage_Type<P7>::type,
2382 typename Storage_Type<P8>::type,
2383 typename Storage_Type<P9>::type,
2384 typename Storage_Type<P10>::type,
2385 typename Storage_Type<P11>::type,
2386 typename Storage_Type<P12>::type,
2387 typename Storage_Type<P13>::type,
2388 typename Storage_Type<P14>::type> >
2389 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2390 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2391 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2392 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2393 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2394 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2395 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2396 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2397 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2398 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2399 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2400 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2401 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
2402 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
2403 {
2404 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
2405 typename Storage_Type<P2>::type,
2406 typename Storage_Type<P3>::type,
2407 typename Storage_Type<P4>::type,
2408 typename Storage_Type<P5>::type,
2409 typename Storage_Type<P6>::type,
2410 typename Storage_Type<P7>::type,
2411 typename Storage_Type<P8>::type,
2412 typename Storage_Type<P9>::type,
2413 typename Storage_Type<P10>::type,
2414 typename Storage_Type<P11>::type,
2415 typename Storage_Type<P12>::type,
2416 typename Storage_Type<P13>::type,
2417 typename Storage_Type<P14>::type> BoundList;
2418
2419 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2420 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2421 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2422 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2423 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2424 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2425 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2426 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2427 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2428 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2429 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2430 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
2431 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
2432 BSLS_COMPILERFEATURES_FORWARD(P14, p14));
2433
2434 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2435 }
2436
2437 // - - - - 'bindR' methods - - - -
2438
2439 /// Return a `Bind` object that is bound to the specified invocable
2440 /// object `func`, which can be invoked with no parameters and returns a
2441 /// value of type `t_RET`.
2442 template <class t_RET, class t_FUNC>
2443 static
2444 Bind<t_RET, t_FUNC, Bind_BoundTuple0>
2445 bindR(t_FUNC func)
2446 {
2447 return Bind<t_RET, t_FUNC, Bind_BoundTuple0>
2448 (func, Bind_BoundTuple0());
2449 }
2450
2451 /// Return a `Bind` object that is bound to the specified invocable
2452 /// object `func`, which can be invoked with one parameter and returns a
2453 /// value of type `t_RET`.
2454 template <class t_RET, class t_FUNC, class P1>
2455 static
2456 Bind<t_RET,
2457 t_FUNC,
2458 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
2459 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
2460 {
2461 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
2462 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1));
2463
2464 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2465 }
2466
2467 /// Return a `Bind` object that is bound to the specified invocable
2468 /// object `func`, which can be invoked with two parameters and returns
2469 /// a value of type `t_RET`.
2470 template <class t_RET, class t_FUNC, class P1, class P2>
2471 static
2472 Bind<t_RET,
2473 t_FUNC,
2474 Bind_BoundTuple2<typename Storage_Type<P1>::type,
2475 typename Storage_Type<P2>::type> >
2476 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2477 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
2478 {
2479 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
2480 typename Storage_Type<P2>::type> BoundList;
2481
2482 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2483 BSLS_COMPILERFEATURES_FORWARD(P2, p2));
2484
2485 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2486 }
2487
2488 /// Return a `Bind` object that is bound to the specified invocable
2489 /// object `func`, which can be invoked with three parameters and
2490 /// returns a value of type `t_RET`.
2491 template <class t_RET, class t_FUNC, class P1, class P2, class P3>
2492 static
2493 Bind<t_RET,
2494 t_FUNC,
2495 Bind_BoundTuple3<typename Storage_Type<P1>::type,
2496 typename Storage_Type<P2>::type,
2497 typename Storage_Type<P3>::type> >
2498 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2499 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2500 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
2501 {
2502 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
2503 typename Storage_Type<P2>::type,
2504 typename Storage_Type<P3>::type> BoundList;
2505
2506 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2507 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2508 BSLS_COMPILERFEATURES_FORWARD(P3, p3));
2509
2510 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2511 }
2512
2513 /// Return a `Bind` object that is bound to the specified invocable
2514 /// object `func`, which can be invoked with four parameters and returns
2515 /// a value of type `t_RET`.
2516 template <class t_RET, class t_FUNC, class P1, class P2,
2517 class P3, class P4>
2518 static
2519 Bind<t_RET,
2520 t_FUNC,
2521 Bind_BoundTuple4<typename Storage_Type<P1>::type,
2522 typename Storage_Type<P2>::type,
2523 typename Storage_Type<P3>::type,
2524 typename Storage_Type<P4>::type> >
2525 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2526 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2527 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2528 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
2529 {
2530 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
2531 typename Storage_Type<P2>::type,
2532 typename Storage_Type<P3>::type,
2533 typename Storage_Type<P4>::type> BoundList;
2534
2535 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2536 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2537 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2538 BSLS_COMPILERFEATURES_FORWARD(P4, p4));
2539
2540 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2541 }
2542
2543 /// Return a `Bind` object that is bound to the specified invocable
2544 /// object `func`, which can be invoked with five parameters and returns
2545 /// a value of type `t_RET`.
2546 template <class t_RET, class t_FUNC, class P1, class P2,
2547 class P3, class P4, class P5>
2548 static
2549 Bind<t_RET,
2550 t_FUNC,
2551 Bind_BoundTuple5<typename Storage_Type<P1>::type,
2552 typename Storage_Type<P2>::type,
2553 typename Storage_Type<P3>::type,
2554 typename Storage_Type<P4>::type,
2555 typename Storage_Type<P5>::type> >
2556 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2557 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2558 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2559 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2560 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
2561 {
2562 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
2563 typename Storage_Type<P2>::type,
2564 typename Storage_Type<P3>::type,
2565 typename Storage_Type<P4>::type,
2566 typename Storage_Type<P5>::type> BoundList;
2567
2568 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2569 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2570 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2571 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2572 BSLS_COMPILERFEATURES_FORWARD(P5, p5));
2573
2574 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2575 }
2576
2577 /// Return a `Bind` object that is bound to the specified invocable
2578 /// object `func`, which can be invoked with six parameters and returns
2579 /// a value of type `t_RET`.
2580 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2581 class P4, class P5, class P6>
2582 static
2583 Bind<t_RET,
2584 t_FUNC,
2585 Bind_BoundTuple6<typename Storage_Type<P1>::type,
2586 typename Storage_Type<P2>::type,
2587 typename Storage_Type<P3>::type,
2588 typename Storage_Type<P4>::type,
2589 typename Storage_Type<P5>::type,
2590 typename Storage_Type<P6>::type> >
2591 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2592 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2593 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2594 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2595 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2596 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
2597 {
2598 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
2599 typename Storage_Type<P2>::type,
2600 typename Storage_Type<P3>::type,
2601 typename Storage_Type<P4>::type,
2602 typename Storage_Type<P5>::type,
2603 typename Storage_Type<P6>::type> BoundList;
2604
2605 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2606 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2607 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2608 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2609 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2610 BSLS_COMPILERFEATURES_FORWARD(P6, p6));
2611
2612 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2613 }
2614
2615 /// Return a `Bind` object that is bound to the specified invocable
2616 /// object `func`, which can be invoked with seven parameters and
2617 /// returns a value of type `t_RET`.
2618 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2619 class P4, class P5, class P6,
2620 class P7>
2621 static
2622 Bind<t_RET,
2623 t_FUNC,
2624 Bind_BoundTuple7<typename Storage_Type<P1>::type,
2625 typename Storage_Type<P2>::type,
2626 typename Storage_Type<P3>::type,
2627 typename Storage_Type<P4>::type,
2628 typename Storage_Type<P5>::type,
2629 typename Storage_Type<P6>::type,
2630 typename Storage_Type<P7>::type> >
2631 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2632 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2633 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2634 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2635 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2636 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2637 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
2638 {
2639 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
2640 typename Storage_Type<P2>::type,
2641 typename Storage_Type<P3>::type,
2642 typename Storage_Type<P4>::type,
2643 typename Storage_Type<P5>::type,
2644 typename Storage_Type<P6>::type,
2645 typename Storage_Type<P7>::type> BoundList;
2646
2647 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2648 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2649 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2650 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2651 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2652 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2653 BSLS_COMPILERFEATURES_FORWARD(P7, p7));
2654
2655 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2656 }
2657
2658 /// Return a `Bind` object that is bound to the specified invocable
2659 /// object `func`, which can be invoked with eight parameters and
2660 /// returns a value of type `t_RET`.
2661 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2662 class P4, class P5, class P6,
2663 class P7, class P8>
2664 static
2665 Bind<t_RET,
2666 t_FUNC,
2667 Bind_BoundTuple8<typename Storage_Type<P1>::type,
2668 typename Storage_Type<P2>::type,
2669 typename Storage_Type<P3>::type,
2670 typename Storage_Type<P4>::type,
2671 typename Storage_Type<P5>::type,
2672 typename Storage_Type<P6>::type,
2673 typename Storage_Type<P7>::type,
2674 typename Storage_Type<P8>::type> >
2675 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2676 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2677 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2678 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2679 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2680 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2681 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2682 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
2683 {
2684 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
2685 typename Storage_Type<P2>::type,
2686 typename Storage_Type<P3>::type,
2687 typename Storage_Type<P4>::type,
2688 typename Storage_Type<P5>::type,
2689 typename Storage_Type<P6>::type,
2690 typename Storage_Type<P7>::type,
2691 typename Storage_Type<P8>::type> BoundList;
2692
2693 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2694 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2695 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2696 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2697 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2698 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2699 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2700 BSLS_COMPILERFEATURES_FORWARD(P8, p8));
2701
2702 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2703 }
2704
2705 /// Return a `Bind` object that is bound to the specified invocable
2706 /// object `func`, which can be invoked with nine parameters and returns
2707 /// a value of type `t_RET`.
2708 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2709 class P4, class P5, class P6,
2710 class P7, class P8, class P9>
2711 static
2712 Bind<t_RET,
2713 t_FUNC,
2714 Bind_BoundTuple9<typename Storage_Type<P1>::type,
2715 typename Storage_Type<P2>::type,
2716 typename Storage_Type<P3>::type,
2717 typename Storage_Type<P4>::type,
2718 typename Storage_Type<P5>::type,
2719 typename Storage_Type<P6>::type,
2720 typename Storage_Type<P7>::type,
2721 typename Storage_Type<P8>::type,
2722 typename Storage_Type<P9>::type> >
2723 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2724 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2725 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2726 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2727 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2728 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2729 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2730 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2731 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
2732 {
2733 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
2734 typename Storage_Type<P2>::type,
2735 typename Storage_Type<P3>::type,
2736 typename Storage_Type<P4>::type,
2737 typename Storage_Type<P5>::type,
2738 typename Storage_Type<P6>::type,
2739 typename Storage_Type<P7>::type,
2740 typename Storage_Type<P8>::type,
2741 typename Storage_Type<P9>::type> BoundList;
2742
2743 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2744 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2745 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2746 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2747 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2748 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2749 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2750 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2751 BSLS_COMPILERFEATURES_FORWARD(P9, p9));
2752
2753 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2754 }
2755
2756 /// Return a `Bind` object that is bound to the specified invocable
2757 /// object `func`, which can be invoked with ten parameters and returns
2758 /// a value of type `t_RET`.
2759 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2760 class P4, class P5, class P6,
2761 class P7, class P8, class P9,
2762 class P10>
2763 static
2764 Bind<t_RET,
2765 t_FUNC,
2766 Bind_BoundTuple10<typename Storage_Type<P1>::type,
2767 typename Storage_Type<P2>::type,
2768 typename Storage_Type<P3>::type,
2769 typename Storage_Type<P4>::type,
2770 typename Storage_Type<P5>::type,
2771 typename Storage_Type<P6>::type,
2772 typename Storage_Type<P7>::type,
2773 typename Storage_Type<P8>::type,
2774 typename Storage_Type<P9>::type,
2775 typename Storage_Type<P10>::type> >
2776 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2777 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2778 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2779 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2780 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2781 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2782 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2783 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2784 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2785 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
2786 {
2787 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
2788 typename Storage_Type<P2>::type,
2789 typename Storage_Type<P3>::type,
2790 typename Storage_Type<P4>::type,
2791 typename Storage_Type<P5>::type,
2792 typename Storage_Type<P6>::type,
2793 typename Storage_Type<P7>::type,
2794 typename Storage_Type<P8>::type,
2795 typename Storage_Type<P9>::type,
2796 typename Storage_Type<P10>::type> BoundList;
2797
2798 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2799 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2800 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2801 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2802 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2803 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2804 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2805 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2806 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2807 BSLS_COMPILERFEATURES_FORWARD(P10, p10));
2808
2809 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2810 }
2811
2812 /// Return a `Bind` object that is bound to the specified invocable
2813 /// object `func`, which can be invoked with eleven parameters and
2814 /// returns a value of type `t_RET`.
2815 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2816 class P4, class P5, class P6,
2817 class P7, class P8, class P9,
2818 class P10, class P11>
2819 static
2820 Bind<t_RET,
2821 t_FUNC,
2822 Bind_BoundTuple11<typename Storage_Type<P1>::type,
2823 typename Storage_Type<P2>::type,
2824 typename Storage_Type<P3>::type,
2825 typename Storage_Type<P4>::type,
2826 typename Storage_Type<P5>::type,
2827 typename Storage_Type<P6>::type,
2828 typename Storage_Type<P7>::type,
2829 typename Storage_Type<P8>::type,
2830 typename Storage_Type<P9>::type,
2831 typename Storage_Type<P10>::type,
2832 typename Storage_Type<P11>::type> >
2833 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2834 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2835 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2836 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2837 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2838 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2839 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2840 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2841 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2842 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2843 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
2844 {
2845 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
2846 typename Storage_Type<P2>::type,
2847 typename Storage_Type<P3>::type,
2848 typename Storage_Type<P4>::type,
2849 typename Storage_Type<P5>::type,
2850 typename Storage_Type<P6>::type,
2851 typename Storage_Type<P7>::type,
2852 typename Storage_Type<P8>::type,
2853 typename Storage_Type<P9>::type,
2854 typename Storage_Type<P10>::type,
2855 typename Storage_Type<P11>::type> BoundList;
2856
2857 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2858 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2859 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2860 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2861 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2862 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2863 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2864 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2865 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2866 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2867 BSLS_COMPILERFEATURES_FORWARD(P11, p11));
2868
2869 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2870 }
2871
2872 /// Return a `Bind` object that is bound to the specified invocable
2873 /// object `func`, which can be invoked with twelve parameters and
2874 /// returns a value of type `t_RET`.
2875 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2876 class P4, class P5, class P6,
2877 class P7, class P8, class P9,
2878 class P10, class P11, class P12>
2879 static
2880 Bind<t_RET,
2881 t_FUNC,
2882 Bind_BoundTuple12<typename Storage_Type<P1>::type,
2883 typename Storage_Type<P2>::type,
2884 typename Storage_Type<P3>::type,
2885 typename Storage_Type<P4>::type,
2886 typename Storage_Type<P5>::type,
2887 typename Storage_Type<P6>::type,
2888 typename Storage_Type<P7>::type,
2889 typename Storage_Type<P8>::type,
2890 typename Storage_Type<P9>::type,
2891 typename Storage_Type<P10>::type,
2892 typename Storage_Type<P11>::type,
2893 typename Storage_Type<P12>::type> >
2894 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2895 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2896 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2897 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2898 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2899 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2900 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2901 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2902 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2903 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2904 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2905 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
2906 {
2907 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
2908 typename Storage_Type<P2>::type,
2909 typename Storage_Type<P3>::type,
2910 typename Storage_Type<P4>::type,
2911 typename Storage_Type<P5>::type,
2912 typename Storage_Type<P6>::type,
2913 typename Storage_Type<P7>::type,
2914 typename Storage_Type<P8>::type,
2915 typename Storage_Type<P9>::type,
2916 typename Storage_Type<P10>::type,
2917 typename Storage_Type<P11>::type,
2918 typename Storage_Type<P12>::type> BoundList;
2919
2920 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2921 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2922 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2923 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2924 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2925 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2926 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2927 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2928 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2929 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2930 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2931 BSLS_COMPILERFEATURES_FORWARD(P12, p12));
2932
2933 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2934 }
2935
2936 /// Return a `Bind` object that is bound to the specified invocable
2937 /// object `func`, which can be invoked with thirteen parameters and
2938 /// returns a value of type `t_RET`.
2939 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2940 class P4, class P5, class P6,
2941 class P7, class P8, class P9,
2942 class P10, class P11, class P12,
2943 class P13>
2944 static
2945 Bind<t_RET,
2946 t_FUNC,
2947 Bind_BoundTuple13<typename Storage_Type<P1>::type,
2948 typename Storage_Type<P2>::type,
2949 typename Storage_Type<P3>::type,
2950 typename Storage_Type<P4>::type,
2951 typename Storage_Type<P5>::type,
2952 typename Storage_Type<P6>::type,
2953 typename Storage_Type<P7>::type,
2954 typename Storage_Type<P8>::type,
2955 typename Storage_Type<P9>::type,
2956 typename Storage_Type<P10>::type,
2957 typename Storage_Type<P11>::type,
2958 typename Storage_Type<P12>::type,
2959 typename Storage_Type<P13>::type> >
2960 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2961 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2962 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2963 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2964 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2965 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2966 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2967 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2968 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2969 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2970 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2971 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2972 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
2973 {
2974 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
2975 typename Storage_Type<P2>::type,
2976 typename Storage_Type<P3>::type,
2977 typename Storage_Type<P4>::type,
2978 typename Storage_Type<P5>::type,
2979 typename Storage_Type<P6>::type,
2980 typename Storage_Type<P7>::type,
2981 typename Storage_Type<P8>::type,
2982 typename Storage_Type<P9>::type,
2983 typename Storage_Type<P10>::type,
2984 typename Storage_Type<P11>::type,
2985 typename Storage_Type<P12>::type,
2986 typename Storage_Type<P13>::type> BoundList;
2987
2988 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2989 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2990 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2991 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2992 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2993 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2994 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2995 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2996 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2997 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2998 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2999 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3000 BSLS_COMPILERFEATURES_FORWARD(P13, p13));
3001
3002 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
3003 }
3004
3005 /// Return a `Bind` object that is bound to the specified invocable
3006 /// object `func`, which can be invoked with fourteen parameters and
3007 /// returns a value of type `t_RET`.
3008 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3009 class P4, class P5, class P6,
3010 class P7, class P8, class P9,
3011 class P10, class P11, class P12,
3012 class P13, class P14>
3013 static
3014 Bind<t_RET,
3015 t_FUNC,
3016 Bind_BoundTuple14<typename Storage_Type<P1>::type,
3017 typename Storage_Type<P2>::type,
3018 typename Storage_Type<P3>::type,
3019 typename Storage_Type<P4>::type,
3020 typename Storage_Type<P5>::type,
3021 typename Storage_Type<P6>::type,
3022 typename Storage_Type<P7>::type,
3023 typename Storage_Type<P8>::type,
3024 typename Storage_Type<P9>::type,
3025 typename Storage_Type<P10>::type,
3026 typename Storage_Type<P11>::type,
3027 typename Storage_Type<P12>::type,
3028 typename Storage_Type<P13>::type,
3029 typename Storage_Type<P14>::type> >
3030 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3031 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3032 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3033 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3034 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3035 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3036 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3037 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3038 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3039 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3040 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3041 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3042 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
3043 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
3044 {
3045 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
3046 typename Storage_Type<P2>::type,
3047 typename Storage_Type<P3>::type,
3048 typename Storage_Type<P4>::type,
3049 typename Storage_Type<P5>::type,
3050 typename Storage_Type<P6>::type,
3051 typename Storage_Type<P7>::type,
3052 typename Storage_Type<P8>::type,
3053 typename Storage_Type<P9>::type,
3054 typename Storage_Type<P10>::type,
3055 typename Storage_Type<P11>::type,
3056 typename Storage_Type<P12>::type,
3057 typename Storage_Type<P13>::type,
3058 typename Storage_Type<P14>::type> BoundList;
3059
3060 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3061 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3062 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3063 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3064 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3065 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3066 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3067 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3068 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3069 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3070 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3071 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3072 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3073 BSLS_COMPILERFEATURES_FORWARD(P14, p14));
3074
3075 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
3076 }
3077
3078 // - - - - 'bindS' methods - - - -
3079
3080 /// Return a `BindWrapper` object that is bound to the specified `func`
3081 /// invocable object which can be invoked with no parameters, using the
3082 /// specified `allocator` to supply memory, or the currently installed
3083 /// default allocator if `allocator == 0`.
3084 template <class t_FUNC>
3085 static
3086 BindWrapper<bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0 >
3087 bindS(bslma::Allocator *allocator, t_FUNC func)
3088 {
3089 return BindWrapper<bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0>
3090 (func, bdlf::Bind_BoundTuple0(),allocator);
3091 }
3092
3093 /// Return a `BindWrapper` object that is bound to the specified
3094 /// invocable object `func`, which can be invoked with one parameters,
3095 /// using the specified `allocator` to supply memory, or the currently
3096 /// installed default allocator if `allocator == 0`.
3097 template <class t_FUNC, class P1>
3098 static
3099 BindWrapper<bslmf::Nil,
3100 t_FUNC,
3101 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
3102 bindS(bslma::Allocator *allocator,
3103 t_FUNC func,
3104 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
3105 {
3106 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
3107 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1), allocator);
3108
3109 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3110 (func, MoveUtil::move(list), allocator);
3111 }
3112
3113 /// Return a `BindWrapper` object that is bound to the specified
3114 /// invocable object `func`, which can be invoked with two parameters,
3115 /// using the specified `allocator` to supply memory, or the currently
3116 /// installed default allocator if `allocator == 0`.
3117 template <class t_FUNC, class P1, class P2>
3118 static
3119 BindWrapper<bslmf::Nil,
3120 t_FUNC,
3121 Bind_BoundTuple2<typename Storage_Type<P1>::type,
3122 typename Storage_Type<P2>::type> >
3123 bindS(bslma::Allocator *allocator,
3124 t_FUNC func,
3125 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3126 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
3127 {
3128 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
3129 typename Storage_Type<P2>::type> BoundList;
3130
3131 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3132 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3133 allocator);
3134
3135 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3136 (func, MoveUtil::move(list), allocator);
3137 }
3138
3139 /// Return a `BindWrapper` object that is bound to the specified
3140 /// invocable object `func`, which can be invoked with three parameters,
3141 /// using the specified `allocator` to supply memory, or the currently
3142 /// installed default allocator if `allocator == 0`.
3143 template <class t_FUNC, class P1, class P2, class P3>
3144 static
3145 BindWrapper<bslmf::Nil,
3146 t_FUNC,
3147 Bind_BoundTuple3<typename Storage_Type<P1>::type,
3148 typename Storage_Type<P2>::type,
3149 typename Storage_Type<P3>::type> >
3150 bindS(bslma::Allocator *allocator,
3151 t_FUNC func,
3152 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3153 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3154 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
3155 {
3156 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
3157 typename Storage_Type<P2>::type,
3158 typename Storage_Type<P3>::type> BoundList;
3159
3160 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3161 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3162 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3163 allocator);
3164
3165 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3166 (func, MoveUtil::move(list), allocator);
3167 }
3168
3169 /// Return a `BindWrapper` object that is bound to the specified
3170 /// invocable object `func`, which can be invoked with four parameters,
3171 /// using the specified `allocator` to supply memory, or the currently
3172 /// installed default allocator if `allocator == 0`.
3173 template <class t_FUNC, class P1, class P2, class P3, class P4>
3174 static
3175 BindWrapper<bslmf::Nil,
3176 t_FUNC,
3177 Bind_BoundTuple4<typename Storage_Type<P1>::type,
3178 typename Storage_Type<P2>::type,
3179 typename Storage_Type<P3>::type,
3180 typename Storage_Type<P4>::type> >
3181 bindS(bslma::Allocator *allocator,
3182 t_FUNC func,
3183 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3184 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3185 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3186 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
3187 {
3188 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
3189 typename Storage_Type<P2>::type,
3190 typename Storage_Type<P3>::type,
3191 typename Storage_Type<P4>::type> BoundList;
3192
3193 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3194 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3195 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3196 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3197 allocator);
3198
3199 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3200 (func, MoveUtil::move(list), allocator);
3201 }
3202
3203 /// Return a `BindWrapper` object that is bound to the specified
3204 /// invocable object `func`, which can be invoked with five parameters,
3205 /// using the specified `allocator` to supply memory, or the currently
3206 /// installed default allocator if `allocator == 0`.
3207 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5>
3208 static
3209 BindWrapper<bslmf::Nil,
3210 t_FUNC,
3211 Bind_BoundTuple5<typename Storage_Type<P1>::type,
3212 typename Storage_Type<P2>::type,
3213 typename Storage_Type<P3>::type,
3214 typename Storage_Type<P4>::type,
3215 typename Storage_Type<P5>::type> >
3216 bindS(bslma::Allocator *allocator,
3217 t_FUNC func,
3218 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3219 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3220 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3221 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3222 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
3223 {
3224 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
3225 typename Storage_Type<P2>::type,
3226 typename Storage_Type<P3>::type,
3227 typename Storage_Type<P4>::type,
3228 typename Storage_Type<P5>::type> BoundList;
3229
3230 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3231 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3232 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3233 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3234 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3235 allocator);
3236
3237 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3238 (func, MoveUtil::move(list), allocator);
3239 }
3240
3241 /// Return a `BindWrapper` object that is bound to the specified
3242 /// invocable object `func`, which can be invoked with six parameters,
3243 /// using the specified `allocator` to supply memory, or the currently
3244 /// installed default allocator if `allocator == 0`.
3245 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3246 class P6>
3247 static
3248 BindWrapper<bslmf::Nil,
3249 t_FUNC,
3250 Bind_BoundTuple6<typename Storage_Type<P1>::type,
3251 typename Storage_Type<P2>::type,
3252 typename Storage_Type<P3>::type,
3253 typename Storage_Type<P4>::type,
3254 typename Storage_Type<P5>::type,
3255 typename Storage_Type<P6>::type> >
3256 bindS(bslma::Allocator *allocator,
3257 t_FUNC func,
3258 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3259 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3260 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3261 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3262 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3263 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
3264 {
3265 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
3266 typename Storage_Type<P2>::type,
3267 typename Storage_Type<P3>::type,
3268 typename Storage_Type<P4>::type,
3269 typename Storage_Type<P5>::type,
3270 typename Storage_Type<P6>::type> BoundList;
3271
3272 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3273 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3274 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3275 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3276 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3277 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3278 allocator);
3279
3280 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3281 (func, MoveUtil::move(list), allocator);
3282 }
3283
3284 /// Return a `BindWrapper` object that is bound to the specified
3285 /// invocable object `func`, which can be invoked with seven parameters,
3286 /// using the specified `allocator` to supply memory, or the currently
3287 /// installed default allocator if `allocator == 0`.
3288 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3289 class P6, class P7>
3290 static
3291 BindWrapper<bslmf::Nil,
3292 t_FUNC,
3293 Bind_BoundTuple7<typename Storage_Type<P1>::type,
3294 typename Storage_Type<P2>::type,
3295 typename Storage_Type<P3>::type,
3296 typename Storage_Type<P4>::type,
3297 typename Storage_Type<P5>::type,
3298 typename Storage_Type<P6>::type,
3299 typename Storage_Type<P7>::type> >
3300 bindS(bslma::Allocator *allocator,
3301 t_FUNC func,
3302 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3303 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3304 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3305 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3306 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3307 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3308 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
3309 {
3310 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
3311 typename Storage_Type<P2>::type,
3312 typename Storage_Type<P3>::type,
3313 typename Storage_Type<P4>::type,
3314 typename Storage_Type<P5>::type,
3315 typename Storage_Type<P6>::type,
3316 typename Storage_Type<P7>::type> BoundList;
3317
3318 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3319 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3320 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3321 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3322 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3323 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3324 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3325 allocator);
3326
3327 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3328 (func, MoveUtil::move(list), allocator);
3329 }
3330
3331 /// Return a `BindWrapper` object that is bound to the specified
3332 /// invocable object `func`, which can be invoked with eight parameters,
3333 /// using the specified `allocator` to supply memory, or the currently
3334 /// installed default allocator if `allocator == 0`.
3335 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3336 class P6, class P7, class P8>
3337 static
3338 BindWrapper<bslmf::Nil,
3339 t_FUNC,
3340 Bind_BoundTuple8<typename Storage_Type<P1>::type,
3341 typename Storage_Type<P2>::type,
3342 typename Storage_Type<P3>::type,
3343 typename Storage_Type<P4>::type,
3344 typename Storage_Type<P5>::type,
3345 typename Storage_Type<P6>::type,
3346 typename Storage_Type<P7>::type,
3347 typename Storage_Type<P8>::type> >
3348 bindS(bslma::Allocator *allocator,
3349 t_FUNC func,
3350 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3351 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3352 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3353 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3354 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3355 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3356 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3357 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
3358 {
3359 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
3360 typename Storage_Type<P2>::type,
3361 typename Storage_Type<P3>::type,
3362 typename Storage_Type<P4>::type,
3363 typename Storage_Type<P5>::type,
3364 typename Storage_Type<P6>::type,
3365 typename Storage_Type<P7>::type,
3366 typename Storage_Type<P8>::type> BoundList;
3367
3368 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3369 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3370 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3371 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3372 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3373 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3374 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3375 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3376 allocator);
3377
3378 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3379 (func, MoveUtil::move(list), allocator);
3380 }
3381
3382 /// Return a `BindWrapper` object that is bound to the specified
3383 /// invocable object `func`, which can be invoked with nine parameters,
3384 /// using the specified `allocator` to supply memory, or the currently
3385 /// installed default allocator if `allocator == 0`.
3386 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3387 class P6, class P7, class P8, class P9>
3388 static
3389 BindWrapper<bslmf::Nil,
3390 t_FUNC,
3391 Bind_BoundTuple9<typename Storage_Type<P1>::type,
3392 typename Storage_Type<P2>::type,
3393 typename Storage_Type<P3>::type,
3394 typename Storage_Type<P4>::type,
3395 typename Storage_Type<P5>::type,
3396 typename Storage_Type<P6>::type,
3397 typename Storage_Type<P7>::type,
3398 typename Storage_Type<P8>::type,
3399 typename Storage_Type<P9>::type> >
3400 bindS(bslma::Allocator *allocator,
3401 t_FUNC func,
3402 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3403 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3404 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3405 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3406 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3407 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3408 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3409 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3410 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
3411 {
3412 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
3413 typename Storage_Type<P2>::type,
3414 typename Storage_Type<P3>::type,
3415 typename Storage_Type<P4>::type,
3416 typename Storage_Type<P5>::type,
3417 typename Storage_Type<P6>::type,
3418 typename Storage_Type<P7>::type,
3419 typename Storage_Type<P8>::type,
3420 typename Storage_Type<P9>::type> BoundList;
3421
3422 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3423 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3424 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3425 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3426 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3427 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3428 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3429 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3430 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3431 allocator);
3432
3433 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3434 (func, MoveUtil::move(list), allocator);
3435 }
3436
3437 /// Return a `BindWrapper` object that is bound to the specified
3438 /// invocable object `func`, which can be invoked with ten parameters,
3439 /// using the specified `allocator` to supply memory, or the currently
3440 /// installed default allocator if `allocator == 0`.
3441 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3442 class P6, class P7, class P8, class P9, class P10>
3443 static
3444 BindWrapper<bslmf::Nil,
3445 t_FUNC,
3446 Bind_BoundTuple10<typename Storage_Type<P1>::type,
3447 typename Storage_Type<P2>::type,
3448 typename Storage_Type<P3>::type,
3449 typename Storage_Type<P4>::type,
3450 typename Storage_Type<P5>::type,
3451 typename Storage_Type<P6>::type,
3452 typename Storage_Type<P7>::type,
3453 typename Storage_Type<P8>::type,
3454 typename Storage_Type<P9>::type,
3455 typename Storage_Type<P10>::type> >
3456 bindS(bslma::Allocator *allocator,
3457 t_FUNC func,
3458 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3459 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3460 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3461 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3462 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3463 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3464 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3465 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3466 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3467 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
3468 {
3469 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
3470 typename Storage_Type<P2>::type,
3471 typename Storage_Type<P3>::type,
3472 typename Storage_Type<P4>::type,
3473 typename Storage_Type<P5>::type,
3474 typename Storage_Type<P6>::type,
3475 typename Storage_Type<P7>::type,
3476 typename Storage_Type<P8>::type,
3477 typename Storage_Type<P9>::type,
3478 typename Storage_Type<P10>::type> BoundList;
3479
3480 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3481 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3482 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3483 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3484 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3485 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3486 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3487 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3488 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3489 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3490 allocator);
3491
3492 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3493 (func, MoveUtil::move(list), allocator);
3494 }
3495
3496 /// Return a `BindWrapper` object that is bound to the specified
3497 /// invocable object `func`, which can be invoked with eleven
3498 /// parameters, using the specified `allocator` to supply memory, or the
3499 /// currently installed default allocator if `allocator == 0`.
3500 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3501 class P6, class P7, class P8, class P9, class P10, class P11>
3502 static
3503 BindWrapper<bslmf::Nil,
3504 t_FUNC,
3505 Bind_BoundTuple11<typename Storage_Type<P1>::type,
3506 typename Storage_Type<P2>::type,
3507 typename Storage_Type<P3>::type,
3508 typename Storage_Type<P4>::type,
3509 typename Storage_Type<P5>::type,
3510 typename Storage_Type<P6>::type,
3511 typename Storage_Type<P7>::type,
3512 typename Storage_Type<P8>::type,
3513 typename Storage_Type<P9>::type,
3514 typename Storage_Type<P10>::type,
3515 typename Storage_Type<P11>::type> >
3516 bindS(bslma::Allocator *allocator,
3517 t_FUNC func,
3518 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3519 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3520 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3521 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3522 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3523 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3524 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3525 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3526 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3527 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3528 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
3529 {
3530 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
3531 typename Storage_Type<P2>::type,
3532 typename Storage_Type<P3>::type,
3533 typename Storage_Type<P4>::type,
3534 typename Storage_Type<P5>::type,
3535 typename Storage_Type<P6>::type,
3536 typename Storage_Type<P7>::type,
3537 typename Storage_Type<P8>::type,
3538 typename Storage_Type<P9>::type,
3539 typename Storage_Type<P10>::type,
3540 typename Storage_Type<P11>::type> BoundList;
3541
3542 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3543 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3544 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3545 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3546 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3547 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3548 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3549 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3550 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3551 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3552 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3553 allocator);
3554
3555 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3556 (func, MoveUtil::move(list), allocator);
3557 }
3558
3559 /// Return a `BindWrapper` object that is bound to the specified
3560 /// invocable object `func`, which can be invoked with twelve
3561 /// parameters, using the specified `allocator` to supply memory, or the
3562 /// currently installed default allocator if `allocator == 0`.
3563 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3564 class P6, class P7, class P8, class P9, class P10, class P11,
3565 class P12>
3566 static
3567 BindWrapper<bslmf::Nil,
3568 t_FUNC,
3569 Bind_BoundTuple12<typename Storage_Type<P1>::type,
3570 typename Storage_Type<P2>::type,
3571 typename Storage_Type<P3>::type,
3572 typename Storage_Type<P4>::type,
3573 typename Storage_Type<P5>::type,
3574 typename Storage_Type<P6>::type,
3575 typename Storage_Type<P7>::type,
3576 typename Storage_Type<P8>::type,
3577 typename Storage_Type<P9>::type,
3578 typename Storage_Type<P10>::type,
3579 typename Storage_Type<P11>::type,
3580 typename Storage_Type<P12>::type> >
3581 bindS(bslma::Allocator *allocator,
3582 t_FUNC func,
3583 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3584 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3585 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3586 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3587 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3588 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3589 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3590 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3591 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3592 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3593 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3594 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
3595 {
3596 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
3597 typename Storage_Type<P2>::type,
3598 typename Storage_Type<P3>::type,
3599 typename Storage_Type<P4>::type,
3600 typename Storage_Type<P5>::type,
3601 typename Storage_Type<P6>::type,
3602 typename Storage_Type<P7>::type,
3603 typename Storage_Type<P8>::type,
3604 typename Storage_Type<P9>::type,
3605 typename Storage_Type<P10>::type,
3606 typename Storage_Type<P11>::type,
3607 typename Storage_Type<P12>::type> BoundList;
3608
3609 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3610 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3611 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3612 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3613 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3614 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3615 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3616 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3617 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3618 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3619 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3620 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3621 allocator);
3622
3623 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3624 (func, MoveUtil::move(list), allocator);
3625 }
3626
3627 /// Return a `BindWrapper` object that is bound to the specified
3628 /// invocable object `func`, which can be invoked with thirteen
3629 /// parameters, using the specified `allocator` to supply memory, or the
3630 /// currently installed default allocator if `allocator == 0`.
3631 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3632 class P6, class P7, class P8, class P9, class P10, class P11,
3633 class P12, class P13>
3634 static
3635 BindWrapper<bslmf::Nil,
3636 t_FUNC,
3637 Bind_BoundTuple13<typename Storage_Type<P1>::type,
3638 typename Storage_Type<P2>::type,
3639 typename Storage_Type<P3>::type,
3640 typename Storage_Type<P4>::type,
3641 typename Storage_Type<P5>::type,
3642 typename Storage_Type<P6>::type,
3643 typename Storage_Type<P7>::type,
3644 typename Storage_Type<P8>::type,
3645 typename Storage_Type<P9>::type,
3646 typename Storage_Type<P10>::type,
3647 typename Storage_Type<P11>::type,
3648 typename Storage_Type<P12>::type,
3649 typename Storage_Type<P13>::type> >
3650 bindS(bslma::Allocator *allocator,
3651 t_FUNC func,
3652 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3653 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3654 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3655 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3656 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3657 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3658 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3659 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3660 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3661 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3662 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3663 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3664 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
3665 {
3666 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
3667 typename Storage_Type<P2>::type,
3668 typename Storage_Type<P3>::type,
3669 typename Storage_Type<P4>::type,
3670 typename Storage_Type<P5>::type,
3671 typename Storage_Type<P6>::type,
3672 typename Storage_Type<P7>::type,
3673 typename Storage_Type<P8>::type,
3674 typename Storage_Type<P9>::type,
3675 typename Storage_Type<P10>::type,
3676 typename Storage_Type<P11>::type,
3677 typename Storage_Type<P12>::type,
3678 typename Storage_Type<P13>::type> BoundList;
3679
3680 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3681 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3682 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3683 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3684 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3685 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3686 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3687 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3688 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3689 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3690 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3691 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3692 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3693 allocator);
3694
3695 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3696 (func, MoveUtil::move(list), allocator);
3697 }
3698
3699 /// Return a `BindWrapper` object that is bound to the specified
3700 /// invocable object `func`, which can be invoked with fourteen
3701 /// parameters, using the specified `allocator` to supply memory, or the
3702 /// currently installed default allocator if `allocator == 0`.
3703 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3704 class P6, class P7, class P8, class P9, class P10, class P11,
3705 class P12, class P13, class P14>
3706 static
3707 BindWrapper<bslmf::Nil,
3708 t_FUNC,
3709 Bind_BoundTuple14<typename Storage_Type<P1>::type,
3710 typename Storage_Type<P2>::type,
3711 typename Storage_Type<P3>::type,
3712 typename Storage_Type<P4>::type,
3713 typename Storage_Type<P5>::type,
3714 typename Storage_Type<P6>::type,
3715 typename Storage_Type<P7>::type,
3716 typename Storage_Type<P8>::type,
3717 typename Storage_Type<P9>::type,
3718 typename Storage_Type<P10>::type,
3719 typename Storage_Type<P11>::type,
3720 typename Storage_Type<P12>::type,
3721 typename Storage_Type<P13>::type,
3722 typename Storage_Type<P14>::type> >
3723 bindS(bslma::Allocator *allocator,
3724 t_FUNC func,
3725 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3726 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3727 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3728 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3729 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3730 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3731 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3732 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3733 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3734 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3735 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3736 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3737 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
3738 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
3739 {
3740 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
3741 typename Storage_Type<P2>::type,
3742 typename Storage_Type<P3>::type,
3743 typename Storage_Type<P4>::type,
3744 typename Storage_Type<P5>::type,
3745 typename Storage_Type<P6>::type,
3746 typename Storage_Type<P7>::type,
3747 typename Storage_Type<P8>::type,
3748 typename Storage_Type<P9>::type,
3749 typename Storage_Type<P10>::type,
3750 typename Storage_Type<P11>::type,
3751 typename Storage_Type<P12>::type,
3752 typename Storage_Type<P13>::type,
3753 typename Storage_Type<P14>::type> BoundList;
3754
3755 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3756 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3757 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3758 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3759 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3760 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3761 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3762 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3763 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3764 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3765 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3766 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3767 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3768 BSLS_COMPILERFEATURES_FORWARD(P14, p14),
3769 allocator);
3770
3771 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3772 (func, MoveUtil::move(list), allocator);
3773 }
3774
3775 // - - - - 'bindSR' methods - - - -
3776
3777 /// Return a `BindWrapper` object that is bound to the specified
3778 /// invocable object `func`, which can be invoked with no parameters and
3779 /// returns a value of type `t_RET`, using the specified `allocator` to
3780 /// supply memory, or the currently installed default allocator if
3781 /// `allocator == 0`.
3782 template <class t_RET, class t_FUNC>
3783 static
3784 BindWrapper<t_RET, t_FUNC, bdlf::Bind_BoundTuple0 >
3785 bindSR(bslma::Allocator *allocator, t_FUNC func)
3786 {
3787 return BindWrapper<t_RET, t_FUNC, bdlf::Bind_BoundTuple0>
3788 (func, bdlf::Bind_BoundTuple0(), allocator);
3789 }
3790
3791 /// Return a `BindWrapper` object that is bound to the specified
3792 /// invocable object `func`, which can be invoked with one parameter and
3793 /// returns a value of type `t_RET`, using the specified `allocator` to
3794 /// supply memory, or the currently installed default allocator if
3795 /// `allocator == 0`.
3796 template <class t_RET, class t_FUNC, class P1>
3797 static
3798 BindWrapper<t_RET,
3799 t_FUNC,
3800 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
3801 bindSR(bslma::Allocator *allocator,
3802 t_FUNC func,
3803 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
3804 {
3805 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
3806 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1), allocator);
3807
3808 return BindWrapper<t_RET, t_FUNC, BoundList>
3809 (func, MoveUtil::move(list), allocator);
3810 }
3811
3812 /// Return a `BindWrapper` object that is bound to the specified
3813 /// invocable object `func`, which can be invoked with two parameters
3814 /// and returns a value of type `t_RET`, using the specified `allocator`
3815 /// to supply memory, or the currently installed default allocator if
3816 /// `allocator == 0`.
3817 template <class t_RET, class t_FUNC, class P1, class P2>
3818 static
3819 BindWrapper<t_RET,
3820 t_FUNC,
3821 Bind_BoundTuple2<typename Storage_Type<P1>::type,
3822 typename Storage_Type<P2>::type> >
3823 bindSR(bslma::Allocator *allocator,
3824 t_FUNC func,
3825 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3826 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
3827 {
3828 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
3829 typename Storage_Type<P2>::type> BoundList;
3830
3831 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3832 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3833 allocator);
3834
3835 return BindWrapper<t_RET, t_FUNC, BoundList>
3836 (func, MoveUtil::move(list), allocator);
3837 }
3838
3839 /// Return a `BindWrapper` object that is bound to the specified
3840 /// invocable object `func`, which can be invoked with three parameters
3841 /// and returns a value of type `t_RET`, using the specified `allocator`
3842 /// to supply memory, or the currently installed default allocator if
3843 /// `allocator == 0`.
3844 template <class t_RET, class t_FUNC, class P1, class P2, class P3>
3845 static
3846 BindWrapper<t_RET,
3847 t_FUNC,
3848 Bind_BoundTuple3<typename Storage_Type<P1>::type,
3849 typename Storage_Type<P2>::type,
3850 typename Storage_Type<P3>::type> >
3851 bindSR(bslma::Allocator *allocator,
3852 t_FUNC func,
3853 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3854 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3855 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
3856 {
3857 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
3858 typename Storage_Type<P2>::type,
3859 typename Storage_Type<P3>::type> BoundList;
3860
3861 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3862 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3863 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3864 allocator);
3865
3866 return BindWrapper<t_RET, t_FUNC, BoundList>
3867 (func, MoveUtil::move(list), allocator);
3868 }
3869
3870 /// Return a `BindWrapper` object that is bound to the specified
3871 /// invocable object `func`, which can be invoked with four parameters
3872 /// and returns a value of type `t_RET`, using the specified `allocator`
3873 /// to supply memory, or the currently installed default allocator if
3874 /// `allocator == 0`.
3875 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3876 class P4>
3877 static
3878 BindWrapper<t_RET,
3879 t_FUNC,
3880 Bind_BoundTuple4<typename Storage_Type<P1>::type,
3881 typename Storage_Type<P2>::type,
3882 typename Storage_Type<P3>::type,
3883 typename Storage_Type<P4>::type> >
3884 bindSR(bslma::Allocator *allocator,
3885 t_FUNC func,
3886 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3887 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3888 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3889 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
3890 {
3891 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
3892 typename Storage_Type<P2>::type,
3893 typename Storage_Type<P3>::type,
3894 typename Storage_Type<P4>::type> BoundList;
3895
3896 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3897 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3898 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3899 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3900 allocator);
3901
3902 return BindWrapper<t_RET, t_FUNC, BoundList>
3903 (func, MoveUtil::move(list), allocator);
3904 }
3905
3906 /// Return a `BindWrapper` object that is bound to the specified
3907 /// invocable object `func`, which can be invoked with five parameters
3908 /// and returns a value of type `t_RET`, using the specified `allocator`
3909 /// to supply memory, or the currently installed default allocator if
3910 /// `allocator == 0`.
3911 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3912 class P4, class P5>
3913 static
3914 BindWrapper<t_RET,
3915 t_FUNC,
3916 Bind_BoundTuple5<typename Storage_Type<P1>::type,
3917 typename Storage_Type<P2>::type,
3918 typename Storage_Type<P3>::type,
3919 typename Storage_Type<P4>::type,
3920 typename Storage_Type<P5>::type> >
3921 bindSR(bslma::Allocator *allocator,
3922 t_FUNC func,
3923 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3924 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3925 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3926 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3927 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
3928 {
3929 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
3930 typename Storage_Type<P2>::type,
3931 typename Storage_Type<P3>::type,
3932 typename Storage_Type<P4>::type,
3933 typename Storage_Type<P5>::type> BoundList;
3934
3935 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3936 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3937 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3938 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3939 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3940 allocator);
3941
3942 return BindWrapper<t_RET, t_FUNC, BoundList>
3943 (func, MoveUtil::move(list), allocator);
3944 }
3945
3946 /// Return a `BindWrapper` object that is bound to the specified
3947 /// invocable object `func`, which can be invoked with six parameters
3948 /// and returns a value of type `t_RET`, using the specified `allocator`
3949 /// to supply memory, or the currently installed default allocator if
3950 /// `allocator == 0`.
3951 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3952 class P4, class P5, class P6>
3953 static
3954 BindWrapper<t_RET,
3955 t_FUNC,
3956 Bind_BoundTuple6<typename Storage_Type<P1>::type,
3957 typename Storage_Type<P2>::type,
3958 typename Storage_Type<P3>::type,
3959 typename Storage_Type<P4>::type,
3960 typename Storage_Type<P5>::type,
3961 typename Storage_Type<P6>::type> >
3962 bindSR(bslma::Allocator *allocator,
3963 t_FUNC func,
3964 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3965 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3966 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3967 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3968 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3969 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
3970 {
3971 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
3972 typename Storage_Type<P2>::type,
3973 typename Storage_Type<P3>::type,
3974 typename Storage_Type<P4>::type,
3975 typename Storage_Type<P5>::type,
3976 typename Storage_Type<P6>::type> BoundList;
3977
3978 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3979 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3980 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3981 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3982 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3983 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3984 allocator);
3985
3986 return BindWrapper<t_RET, t_FUNC, BoundList>
3987 (func, MoveUtil::move(list), allocator);
3988 }
3989
3990 /// Return a `BindWrapper` object that is bound to the specified
3991 /// invocable object `func`, which can be invoked with seven parameters
3992 /// and returns a value of type `t_RET`, using the specified `allocator`
3993 /// to supply memory, or the currently installed default allocator if
3994 /// `allocator == 0`.
3995 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3996 class P4, class P5, class P6,
3997 class P7>
3998 static
3999 BindWrapper<t_RET,
4000 t_FUNC,
4001 Bind_BoundTuple7<typename Storage_Type<P1>::type,
4002 typename Storage_Type<P2>::type,
4003 typename Storage_Type<P3>::type,
4004 typename Storage_Type<P4>::type,
4005 typename Storage_Type<P5>::type,
4006 typename Storage_Type<P6>::type,
4007 typename Storage_Type<P7>::type> >
4008 bindSR(bslma::Allocator *allocator,
4009 t_FUNC func,
4010 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4011 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4012 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4013 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4014 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4015 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4016 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
4017 {
4018 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
4019 typename Storage_Type<P2>::type,
4020 typename Storage_Type<P3>::type,
4021 typename Storage_Type<P4>::type,
4022 typename Storage_Type<P5>::type,
4023 typename Storage_Type<P6>::type,
4024 typename Storage_Type<P7>::type> BoundList;
4025
4026 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4027 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4028 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4029 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4030 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4031 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4032 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4033 allocator);
4034
4035 return BindWrapper<t_RET, t_FUNC, BoundList>
4036 (func, MoveUtil::move(list), allocator);
4037 }
4038
4039 /// Return a `BindWrapper` object that is bound to the specified
4040 /// invocable object `func`, which can be invoked with eight parameters
4041 /// and returns a value of type `t_RET`, using the specified `allocator`
4042 /// to supply memory, or the currently installed default allocator if
4043 /// `allocator == 0`.
4044 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4045 class P4, class P5, class P6,
4046 class P7, class P8>
4047 static
4048 BindWrapper<t_RET,
4049 t_FUNC,
4050 Bind_BoundTuple8<typename Storage_Type<P1>::type,
4051 typename Storage_Type<P2>::type,
4052 typename Storage_Type<P3>::type,
4053 typename Storage_Type<P4>::type,
4054 typename Storage_Type<P5>::type,
4055 typename Storage_Type<P6>::type,
4056 typename Storage_Type<P7>::type,
4057 typename Storage_Type<P8>::type> >
4058 bindSR(bslma::Allocator *allocator,
4059 t_FUNC func,
4060 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4061 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4062 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4063 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4064 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4065 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4066 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4067 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
4068 {
4069 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
4070 typename Storage_Type<P2>::type,
4071 typename Storage_Type<P3>::type,
4072 typename Storage_Type<P4>::type,
4073 typename Storage_Type<P5>::type,
4074 typename Storage_Type<P6>::type,
4075 typename Storage_Type<P7>::type,
4076 typename Storage_Type<P8>::type> BoundList;
4077
4078 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4079 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4080 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4081 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4082 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4083 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4084 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4085 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4086 allocator);
4087
4088 return BindWrapper<t_RET, t_FUNC, BoundList>
4089 (func, MoveUtil::move(list), allocator);
4090 }
4091
4092 /// Return a `BindWrapper` object that is bound to the specified
4093 /// invocable object `func`, which can be invoked with nine parameters
4094 /// and returns a value of type `t_RET`, using the specified `allocator`
4095 /// to supply memory, or the currently installed default allocator if
4096 /// `allocator == 0`.
4097 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4098 class P4, class P5, class P6,
4099 class P7, class P8, class P9>
4100 static
4101 BindWrapper<t_RET,
4102 t_FUNC,
4103 Bind_BoundTuple9<typename Storage_Type<P1>::type,
4104 typename Storage_Type<P2>::type,
4105 typename Storage_Type<P3>::type,
4106 typename Storage_Type<P4>::type,
4107 typename Storage_Type<P5>::type,
4108 typename Storage_Type<P6>::type,
4109 typename Storage_Type<P7>::type,
4110 typename Storage_Type<P8>::type,
4111 typename Storage_Type<P9>::type> >
4112 bindSR(bslma::Allocator *allocator,
4113 t_FUNC func,
4114 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4115 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4116 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4117 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4118 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4119 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4120 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4121 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4122 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
4123 {
4124 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
4125 typename Storage_Type<P2>::type,
4126 typename Storage_Type<P3>::type,
4127 typename Storage_Type<P4>::type,
4128 typename Storage_Type<P5>::type,
4129 typename Storage_Type<P6>::type,
4130 typename Storage_Type<P7>::type,
4131 typename Storage_Type<P8>::type,
4132 typename Storage_Type<P9>::type> BoundList;
4133
4134 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4135 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4136 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4137 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4138 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4139 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4140 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4141 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4142 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4143 allocator);
4144
4145 return BindWrapper<t_RET, t_FUNC, BoundList>
4146 (func, MoveUtil::move(list), allocator);
4147 }
4148
4149 /// Return a `BindWrapper` object that is bound to the specified
4150 /// invocable object `func`, which can be invoked with ten parameters
4151 /// and returns a value of type `t_RET`, using the specified `allocator`
4152 /// to supply memory, or the currently installed default allocator if
4153 /// `allocator == 0`.
4154 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4155 class P4, class P5, class P6,
4156 class P7, class P8, class P9,
4157 class P10>
4158 static
4159 BindWrapper<t_RET,
4160 t_FUNC,
4161 Bind_BoundTuple10<typename Storage_Type<P1>::type,
4162 typename Storage_Type<P2>::type,
4163 typename Storage_Type<P3>::type,
4164 typename Storage_Type<P4>::type,
4165 typename Storage_Type<P5>::type,
4166 typename Storage_Type<P6>::type,
4167 typename Storage_Type<P7>::type,
4168 typename Storage_Type<P8>::type,
4169 typename Storage_Type<P9>::type,
4170 typename Storage_Type<P10>::type> >
4171 bindSR(bslma::Allocator *allocator,
4172 t_FUNC func,
4173 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4174 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4175 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4176 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4177 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4178 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4179 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4180 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4181 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4182 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
4183 {
4184 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
4185 typename Storage_Type<P2>::type,
4186 typename Storage_Type<P3>::type,
4187 typename Storage_Type<P4>::type,
4188 typename Storage_Type<P5>::type,
4189 typename Storage_Type<P6>::type,
4190 typename Storage_Type<P7>::type,
4191 typename Storage_Type<P8>::type,
4192 typename Storage_Type<P9>::type,
4193 typename Storage_Type<P10>::type> BoundList;
4194
4195 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4196 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4197 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4198 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4199 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4200 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4201 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4202 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4203 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4204 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4205 allocator);
4206
4207 return BindWrapper<t_RET, t_FUNC, BoundList>
4208 (func, MoveUtil::move(list), allocator);
4209 }
4210
4211 /// Return a `BindWrapper` object that is bound to the specified
4212 /// invocable object `func`, which can be invoked with eleven parameters
4213 /// and returns a value of type `t_RET`, using the specified `allocator`
4214 /// to supply memory, or the currently installed default allocator if
4215 /// `allocator == 0`.
4216 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4217 class P4, class P5, class P6,
4218 class P7, class P8, class P9,
4219 class P10, class P11>
4220 static
4221 BindWrapper<t_RET,
4222 t_FUNC,
4223 Bind_BoundTuple11<typename Storage_Type<P1>::type,
4224 typename Storage_Type<P2>::type,
4225 typename Storage_Type<P3>::type,
4226 typename Storage_Type<P4>::type,
4227 typename Storage_Type<P5>::type,
4228 typename Storage_Type<P6>::type,
4229 typename Storage_Type<P7>::type,
4230 typename Storage_Type<P8>::type,
4231 typename Storage_Type<P9>::type,
4232 typename Storage_Type<P10>::type,
4233 typename Storage_Type<P11>::type> >
4234 bindSR(bslma::Allocator *allocator,
4235 t_FUNC func,
4236 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4237 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4238 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4239 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4240 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4241 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4242 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4243 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4244 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4245 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4246 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
4247 {
4248 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
4249 typename Storage_Type<P2>::type,
4250 typename Storage_Type<P3>::type,
4251 typename Storage_Type<P4>::type,
4252 typename Storage_Type<P5>::type,
4253 typename Storage_Type<P6>::type,
4254 typename Storage_Type<P7>::type,
4255 typename Storage_Type<P8>::type,
4256 typename Storage_Type<P9>::type,
4257 typename Storage_Type<P10>::type,
4258 typename Storage_Type<P11>::type> BoundList;
4259
4260 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4261 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4262 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4263 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4264 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4265 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4266 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4267 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4268 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4269 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4270 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4271 allocator);
4272
4273 return BindWrapper<t_RET, t_FUNC, BoundList>
4274 (func, MoveUtil::move(list), allocator);
4275 }
4276
4277 /// Return a `BindWrapper` object that is bound to the specified
4278 /// invocable object `func`, which can be invoked with twelve parameters
4279 /// and returns a value of type `t_RET`, using the specified `allocator`
4280 /// to supply memory, or the currently installed default allocator if
4281 /// `allocator == 0`.
4282 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4283 class P4, class P5, class P6,
4284 class P7, class P8, class P9,
4285 class P10, class P11, class P12>
4286 static
4287 BindWrapper<t_RET,
4288 t_FUNC,
4289 Bind_BoundTuple12<typename Storage_Type<P1>::type,
4290 typename Storage_Type<P2>::type,
4291 typename Storage_Type<P3>::type,
4292 typename Storage_Type<P4>::type,
4293 typename Storage_Type<P5>::type,
4294 typename Storage_Type<P6>::type,
4295 typename Storage_Type<P7>::type,
4296 typename Storage_Type<P8>::type,
4297 typename Storage_Type<P9>::type,
4298 typename Storage_Type<P10>::type,
4299 typename Storage_Type<P11>::type,
4300 typename Storage_Type<P12>::type> >
4301 bindSR(bslma::Allocator *allocator,
4302 t_FUNC func,
4303 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4304 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4305 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4306 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4307 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4308 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4309 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4310 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4311 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4312 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4313 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4314 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
4315 {
4316 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
4317 typename Storage_Type<P2>::type,
4318 typename Storage_Type<P3>::type,
4319 typename Storage_Type<P4>::type,
4320 typename Storage_Type<P5>::type,
4321 typename Storage_Type<P6>::type,
4322 typename Storage_Type<P7>::type,
4323 typename Storage_Type<P8>::type,
4324 typename Storage_Type<P9>::type,
4325 typename Storage_Type<P10>::type,
4326 typename Storage_Type<P11>::type,
4327 typename Storage_Type<P12>::type> BoundList;
4328
4329 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4330 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4331 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4332 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4333 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4334 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4335 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4336 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4337 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4338 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4339 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4340 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4341 allocator);
4342
4343 return BindWrapper<t_RET, t_FUNC, BoundList>
4344 (func, MoveUtil::move(list), allocator);
4345 }
4346
4347 /// Return a `BindWrapper` object that is bound to the specified
4348 /// invocable object `func`, which can be invoked with thirteen
4349 /// parameters and returns a value of type `t_RET`, using the specified
4350 /// `allocator` to supply memory, or the currently installed default
4351 /// allocator if `allocator == 0`.
4352 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4353 class P4, class P5, class P6,
4354 class P7, class P8, class P9,
4355 class P10, class P11, class P12,
4356 class P13>
4357 static
4358 BindWrapper<t_RET,
4359 t_FUNC,
4360 Bind_BoundTuple13<typename Storage_Type<P1>::type,
4361 typename Storage_Type<P2>::type,
4362 typename Storage_Type<P3>::type,
4363 typename Storage_Type<P4>::type,
4364 typename Storage_Type<P5>::type,
4365 typename Storage_Type<P6>::type,
4366 typename Storage_Type<P7>::type,
4367 typename Storage_Type<P8>::type,
4368 typename Storage_Type<P9>::type,
4369 typename Storage_Type<P10>::type,
4370 typename Storage_Type<P11>::type,
4371 typename Storage_Type<P12>::type,
4372 typename Storage_Type<P13>::type> >
4373 bindSR(bslma::Allocator *allocator,
4374 t_FUNC func,
4375 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4376 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4377 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4378 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4379 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4380 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4381 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4382 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4383 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4384 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4385 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4386 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
4387 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
4388 {
4389 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
4390 typename Storage_Type<P2>::type,
4391 typename Storage_Type<P3>::type,
4392 typename Storage_Type<P4>::type,
4393 typename Storage_Type<P5>::type,
4394 typename Storage_Type<P6>::type,
4395 typename Storage_Type<P7>::type,
4396 typename Storage_Type<P8>::type,
4397 typename Storage_Type<P9>::type,
4398 typename Storage_Type<P10>::type,
4399 typename Storage_Type<P11>::type,
4400 typename Storage_Type<P12>::type,
4401 typename Storage_Type<P13>::type> BoundList;
4402
4403 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4404 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4405 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4406 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4407 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4408 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4409 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4410 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4411 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4412 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4413 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4414 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4415 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
4416 allocator);
4417
4418 return BindWrapper<t_RET, t_FUNC, BoundList>
4419 (func, MoveUtil::move(list), allocator);
4420 }
4421
4422 /// Return a `BindWrapper` object that is bound to the specified
4423 /// invocable object `func`, which can be invoked with fourteen
4424 /// parameters and returns a value of type `t_RET`, using the specified
4425 /// `allocator` to supply memory, or the currently installed default
4426 /// allocator if `allocator == 0`.
4427 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4428 class P4, class P5, class P6,
4429 class P7, class P8, class P9,
4430 class P10, class P11, class P12,
4431 class P13, class P14>
4432 static
4433 BindWrapper<t_RET,
4434 t_FUNC,
4435 Bind_BoundTuple14<typename Storage_Type<P1>::type,
4436 typename Storage_Type<P2>::type,
4437 typename Storage_Type<P3>::type,
4438 typename Storage_Type<P4>::type,
4439 typename Storage_Type<P5>::type,
4440 typename Storage_Type<P6>::type,
4441 typename Storage_Type<P7>::type,
4442 typename Storage_Type<P8>::type,
4443 typename Storage_Type<P9>::type,
4444 typename Storage_Type<P10>::type,
4445 typename Storage_Type<P11>::type,
4446 typename Storage_Type<P12>::type,
4447 typename Storage_Type<P13>::type,
4448 typename Storage_Type<P14>::type> >
4449 bindSR(bslma::Allocator *allocator,
4450 t_FUNC func,
4451 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4452 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4453 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4454 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4455 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4456 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4457 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4458 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4459 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4460 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4461 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4462 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
4463 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
4464 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
4465 {
4466 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
4467 typename Storage_Type<P2>::type,
4468 typename Storage_Type<P3>::type,
4469 typename Storage_Type<P4>::type,
4470 typename Storage_Type<P5>::type,
4471 typename Storage_Type<P6>::type,
4472 typename Storage_Type<P7>::type,
4473 typename Storage_Type<P8>::type,
4474 typename Storage_Type<P9>::type,
4475 typename Storage_Type<P10>::type,
4476 typename Storage_Type<P11>::type,
4477 typename Storage_Type<P12>::type,
4478 typename Storage_Type<P13>::type,
4479 typename Storage_Type<P14>::type> BoundList;
4480
4481 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4482 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4483 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4484 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4485 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4486 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4487 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4488 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4489 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4490 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4491 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4492 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4493 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
4494 BSLS_COMPILERFEATURES_FORWARD(P14, p14),
4495 allocator);
4496
4497 return BindWrapper<t_RET, t_FUNC, BoundList>
4498 (func, MoveUtil::move(list), allocator);
4499 }
4500
4501};
4502
4503// ---- Anything below this line is implementation specific. Do not use. ----
4504
4505 // ========================
4506 // class Bind_ArgTupleValue
4507 // ========================
4508
4509/// This local class provides storage for a value of the specified `TYPE`
4510/// suitable for storing an argument value in one of the
4511/// `Bind_ArgTuple[0-14]` local classes. `TYPE` must already be a
4512/// `bslmf::ForwardingType`, meaning no extra copies will be made (unless
4513/// the type is a fundamental type, which is meant to be copied for
4514/// efficiency).
4515///
4516/// See @ref bdlf_bind
4517template <class TYPE>
4518class Bind_ArgTupleValue {
4519
4520 // PRIVATE TYPES
4521 typedef typename bslmf::ArrayToConstPointer<TYPE>::Type STORAGE_TYPE;
4522
4523 // PRIVATE INSTANCE DATA
4524 STORAGE_TYPE d_value;
4525
4526 public:
4527 // CREATORS
4528
4529 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4530 /// `original` value.
4531 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE>& original)
4532 : d_value(original.d_value)
4533 {
4534 }
4535
4536 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4537 /// `value`.
4538 Bind_ArgTupleValue(TYPE value) // IMPLICIT
4539 : d_value(value)
4540 {
4541 }
4542
4543 // MANIPULATORS
4544
4545 /// Return a reference to the modifiable object held by this proxy.
4546 STORAGE_TYPE& value() { return d_value; }
4547
4548 // ACCESSORS
4549
4550 /// Return a reference to the non-modifiable object held by this proxy.
4551 const STORAGE_TYPE& value() const { return d_value; }
4552};
4553
4554/// This local class provides storage for a value of the specified `TYPE`
4555/// suitable for storing an argument value in one of the `Bind_ArgTuple*`
4556/// local classes. This full specialization for reference types simply
4557/// stores the address of the argument value.
4558template <class TYPE>
4559class Bind_ArgTupleValue<TYPE&> {
4560
4561 // PRIVATE INSTANCE DATA
4562 TYPE *d_value;
4563
4564 public:
4565 // CREATORS
4566
4567 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4568 /// `original` reference.
4569 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE&>& original)
4570 : d_value(original.d_value)
4571 {
4572 }
4573
4574 /// Create a `Bind_ArgTupleValue` object holding the address of the
4575 /// specified `value`.
4576 Bind_ArgTupleValue(TYPE& value) // IMPLICIT
4577 : d_value(&value)
4578 {
4579 }
4580
4581 // MANIPULATORS
4582
4583 /// Return a reference to the modifiable object held by this proxy.
4584 TYPE& value() { return *d_value; }
4585
4586 // ACCESSORS
4587
4588 /// Return a reference to the non-modifiable object held by this proxy.
4589 const TYPE& value() const { return *d_value; }
4590};
4591
4592/// This local class provides storage for a value of the specified `TYPE`
4593/// suitable for storing an argument value in one of the `Bind_ArgTuple*`
4594/// local classes. This full specialization for const reference types
4595/// simply stores the address of the argument value.
4596template <class TYPE>
4597class Bind_ArgTupleValue<TYPE const&> {
4598
4599 // PRIVATE INSTANCE DATA
4600 const TYPE *d_value;
4601
4602 public:
4603 // CREATORS
4604
4605 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4606 /// `original` reference.
4607 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE const&>& original)
4608 : d_value(original.d_value)
4609 {
4610 }
4611
4612 /// Create a `Bind_ArgTupleValue` object holding the address of the
4613 /// specified `value`.
4614 Bind_ArgTupleValue(const TYPE& value) // IMPLICIT
4615 : d_value(&value)
4616 {
4617 }
4618
4619 // MANIPULATORS
4620
4621 /// Return a reference to the non-modifiable object held by this proxy.
4622 const TYPE& value() { return *d_value; }
4623
4624 // ACCESSORS
4625
4626 /// Return a reference to the non-modifiable object held by this proxy.
4627 const TYPE& value() const { return *d_value; }
4628};
4629
4630 // ====================
4631 // class Bind_ArgTuple*
4632 // ====================
4633
4634/// This `struct` provides the creators for a list of zero arguments.
4635struct Bind_ArgTuple0 : bslmf::TypeList0
4636{
4637
4638 // CREATORS
4641
4642 Bind_ArgTuple0(const Bind_ArgTuple0&)
4643 {
4644 }
4645};
4646
4647/// This `struct` stores a list of one argument.
4648template <class A1>
4649struct Bind_ArgTuple1 : bslmf::TypeList1<A1>
4650{
4651
4652 // TYPES
4653 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4654
4655 // INSTANCE DATA
4656 Bind_ArgTupleValue<FA1> d_a1;
4657
4658 // CREATORS
4659 Bind_ArgTuple1(const Bind_ArgTuple1<A1>& orig)
4660 : d_a1(orig.d_a1)
4661 {
4662 }
4663
4664 explicit Bind_ArgTuple1(FA1 a1)
4665 : d_a1(a1)
4666 {
4667 }
4668};
4669
4670/// This `struct` stores a list of two arguments.
4671template <class A1, class A2>
4672struct Bind_ArgTuple2 : bslmf::TypeList2<A1,A2>
4673{
4674
4675 // TYPES
4676 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4677 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4678
4679 // INSTANCE DATA
4680 Bind_ArgTupleValue<FA1> d_a1;
4681 Bind_ArgTupleValue<FA2> d_a2;
4682
4683 // CREATORS
4684 Bind_ArgTuple2(const Bind_ArgTuple2<A1,A2>& orig)
4685 : d_a1(orig.d_a1)
4686 , d_a2(orig.d_a2)
4687 {
4688 }
4689
4690 Bind_ArgTuple2(FA1 a1, FA2 a2)
4691 : d_a1(a1)
4692 , d_a2(a2)
4693 {
4694 }
4695};
4696
4697/// This `struct` stores a list of three arguments.
4698template <class A1, class A2, class A3>
4699struct Bind_ArgTuple3 : bslmf::TypeList3<A1,A2,A3>
4700{
4701
4702 // TYPES
4703 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4704 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4705 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4706
4707 // INSTANCE DATA
4708 Bind_ArgTupleValue<FA1> d_a1;
4709 Bind_ArgTupleValue<FA2> d_a2;
4710 Bind_ArgTupleValue<FA3> d_a3;
4711
4712 // CREATORS
4713 Bind_ArgTuple3(const Bind_ArgTuple3<A1,A2,A3>& orig)
4714 : d_a1(orig.d_a1)
4715 , d_a2(orig.d_a2)
4716 , d_a3(orig.d_a3)
4717 {
4718 }
4719
4720 Bind_ArgTuple3(FA1 a1, FA2 a2, FA3 a3)
4721 : d_a1(a1)
4722 , d_a2(a2)
4723 , d_a3(a3)
4724 {
4725 }
4726};
4727
4728/// This `struct` stores a list of four arguments.
4729template <class A1, class A2, class A3, class A4>
4730struct Bind_ArgTuple4 : bslmf::TypeList4<A1,A2,A3,A4>
4731{
4732
4733 // TYPES
4734 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4735 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4736 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4737 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4738
4739 // INSTANCE DATA
4740 Bind_ArgTupleValue<FA1> d_a1;
4741 Bind_ArgTupleValue<FA2> d_a2;
4742 Bind_ArgTupleValue<FA3> d_a3;
4743 Bind_ArgTupleValue<FA4> d_a4;
4744
4745 // CREATORS
4746 Bind_ArgTuple4(const Bind_ArgTuple4<A1,A2,A3,A4>& orig)
4747 : d_a1(orig.d_a1)
4748 , d_a2(orig.d_a2)
4749 , d_a3(orig.d_a3)
4750 , d_a4(orig.d_a4)
4751 {
4752 }
4753
4754 Bind_ArgTuple4(FA1 a1, FA2 a2, FA3 a3, FA4 a4)
4755 : d_a1(a1)
4756 , d_a2(a2)
4757 , d_a3(a3)
4758 , d_a4(a4)
4759 {
4760 }
4761};
4762
4763/// This `struct` stores a list of five arguments.
4764template <class A1, class A2, class A3, class A4, class A5>
4765struct Bind_ArgTuple5 : bslmf::TypeList5<A1,A2,A3,A4,A5>
4766{
4767
4768 // TYPES
4769 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4770 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4771 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4772 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4773 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4774
4775 // INSTANCE DATA
4776 Bind_ArgTupleValue<FA1> d_a1;
4777 Bind_ArgTupleValue<FA2> d_a2;
4778 Bind_ArgTupleValue<FA3> d_a3;
4779 Bind_ArgTupleValue<FA4> d_a4;
4780 Bind_ArgTupleValue<FA5> d_a5;
4781
4782 // CREATORS
4783 Bind_ArgTuple5(const Bind_ArgTuple5<A1,A2,A3,A4,A5>& orig)
4784 : d_a1(orig.d_a1)
4785 , d_a2(orig.d_a2)
4786 , d_a3(orig.d_a3)
4787 , d_a4(orig.d_a4)
4788 , d_a5(orig.d_a5)
4789 {
4790 }
4791
4792 Bind_ArgTuple5(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5)
4793 : d_a1(a1)
4794 , d_a2(a2)
4795 , d_a3(a3)
4796 , d_a4(a4)
4797 , d_a5(a5)
4798 {
4799 }
4800};
4801
4802/// This `struct` stores a list of six arguments.
4803template <class A1, class A2, class A3, class A4, class A5, class A6>
4804struct Bind_ArgTuple6 : bslmf::TypeList6<A1,A2,A3,A4,A5,A6>
4805{
4806
4807 // TYPES
4808 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4809 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4810 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4811 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4812 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4813 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4814
4815 // INSTANCE DATA
4816 Bind_ArgTupleValue<FA1> d_a1;
4817 Bind_ArgTupleValue<FA2> d_a2;
4818 Bind_ArgTupleValue<FA3> d_a3;
4819 Bind_ArgTupleValue<FA4> d_a4;
4820 Bind_ArgTupleValue<FA5> d_a5;
4821 Bind_ArgTupleValue<FA6> d_a6;
4822
4823 // CREATORS
4824 Bind_ArgTuple6(const Bind_ArgTuple6<A1,A2,A3,A4,A5,A6>& orig)
4825 : d_a1(orig.d_a1)
4826 , d_a2(orig.d_a2)
4827 , d_a3(orig.d_a3)
4828 , d_a4(orig.d_a4)
4829 , d_a5(orig.d_a5)
4830 , d_a6(orig.d_a6)
4831 {
4832 }
4833
4834 Bind_ArgTuple6(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6)
4835 : d_a1(a1)
4836 , d_a2(a2)
4837 , d_a3(a3)
4838 , d_a4(a4)
4839 , d_a5(a5)
4840 , d_a6(a6)
4841 {
4842 }
4843};
4844
4845/// This `struct` stores a list of seven arguments.
4846template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
4847struct Bind_ArgTuple7 : bslmf::TypeList7<A1,A2,A3,A4,A5,A6,A7>
4848{
4849
4850 // TYPES
4851 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4852 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4853 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4854 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4855 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4856 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4857 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4858
4859 // INSTANCE DATA
4860 Bind_ArgTupleValue<FA1> d_a1;
4861 Bind_ArgTupleValue<FA2> d_a2;
4862 Bind_ArgTupleValue<FA3> d_a3;
4863 Bind_ArgTupleValue<FA4> d_a4;
4864 Bind_ArgTupleValue<FA5> d_a5;
4865 Bind_ArgTupleValue<FA6> d_a6;
4866 Bind_ArgTupleValue<FA7> d_a7;
4867
4868 // CREATORS
4869 inline
4870 Bind_ArgTuple7(const Bind_ArgTuple7<A1,A2,A3,A4,A5,A6,A7>& orig)
4871 : d_a1(orig.d_a1)
4872 , d_a2(orig.d_a2)
4873 , d_a3(orig.d_a3)
4874 , d_a4(orig.d_a4)
4875 , d_a5(orig.d_a5)
4876 , d_a6(orig.d_a6)
4877 , d_a7(orig.d_a7)
4878 {
4879 }
4880
4881 Bind_ArgTuple7(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7)
4882 : d_a1(a1)
4883 , d_a2(a2)
4884 , d_a3(a3)
4885 , d_a4(a4)
4886 , d_a5(a5)
4887 , d_a6(a6)
4888 , d_a7(a7)
4889 {
4890 }
4891};
4892
4893/// This `struct` stores a list of eight arguments.
4894template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
4895 class A8>
4896struct Bind_ArgTuple8 : bslmf::TypeList8<A1,A2,A3,A4,A5,A6,A7,A8>
4897{
4898
4899 // TYPES
4900 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4901 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4902 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4903 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4904 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4905 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4906 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4907 typedef typename bslmf::ForwardingType<A8>::Type FA8;
4908
4909 // INSTANCE DATA
4910 Bind_ArgTupleValue<FA1> d_a1;
4911 Bind_ArgTupleValue<FA2> d_a2;
4912 Bind_ArgTupleValue<FA3> d_a3;
4913 Bind_ArgTupleValue<FA4> d_a4;
4914 Bind_ArgTupleValue<FA5> d_a5;
4915 Bind_ArgTupleValue<FA6> d_a6;
4916 Bind_ArgTupleValue<FA7> d_a7;
4917 Bind_ArgTupleValue<FA8> d_a8;
4918
4919 // CREATORS
4920 inline
4921 Bind_ArgTuple8(const Bind_ArgTuple8<A1,A2,A3,A4,A5,A6,A7,A8>& orig)
4922 : d_a1(orig.d_a1)
4923 , d_a2(orig.d_a2)
4924 , d_a3(orig.d_a3)
4925 , d_a4(orig.d_a4)
4926 , d_a5(orig.d_a5)
4927 , d_a6(orig.d_a6)
4928 , d_a7(orig.d_a7)
4929 , d_a8(orig.d_a8)
4930 {
4931 }
4932
4933 Bind_ArgTuple8(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
4934 FA7 a7, FA8 a8)
4935 : d_a1(a1)
4936 , d_a2(a2)
4937 , d_a3(a3)
4938 , d_a4(a4)
4939 , d_a5(a5)
4940 , d_a6(a6)
4941 , d_a7(a7)
4942 , d_a8(a8)
4943 {
4944 }
4945};
4946
4947/// This `struct` stores a list of nine arguments.
4948template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
4949 class A8, class A9>
4950struct Bind_ArgTuple9 : bslmf::TypeList9<A1,A2,A3,A4,A5,A6,A7,A8,A9>
4951{
4952
4953 // TYPES
4954 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4955 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4956 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4957 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4958 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4959 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4960 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4961 typedef typename bslmf::ForwardingType<A8>::Type FA8;
4962 typedef typename bslmf::ForwardingType<A9>::Type FA9;
4963
4964 // INSTANCE DATA
4965 Bind_ArgTupleValue<FA1> d_a1;
4966 Bind_ArgTupleValue<FA2> d_a2;
4967 Bind_ArgTupleValue<FA3> d_a3;
4968 Bind_ArgTupleValue<FA4> d_a4;
4969 Bind_ArgTupleValue<FA5> d_a5;
4970 Bind_ArgTupleValue<FA6> d_a6;
4971 Bind_ArgTupleValue<FA7> d_a7;
4972 Bind_ArgTupleValue<FA8> d_a8;
4973 Bind_ArgTupleValue<FA9> d_a9;
4974
4975 // CREATORS
4976 inline
4977 Bind_ArgTuple9(const Bind_ArgTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>& orig)
4978 : d_a1(orig.d_a1)
4979 , d_a2(orig.d_a2)
4980 , d_a3(orig.d_a3)
4981 , d_a4(orig.d_a4)
4982 , d_a5(orig.d_a5)
4983 , d_a6(orig.d_a6)
4984 , d_a7(orig.d_a7)
4985 , d_a8(orig.d_a8)
4986 , d_a9(orig.d_a9)
4987 {
4988 }
4989
4990 Bind_ArgTuple9(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
4991 FA7 a7, FA8 a8, FA9 a9)
4992 : d_a1(a1)
4993 , d_a2(a2)
4994 , d_a3(a3)
4995 , d_a4(a4)
4996 , d_a5(a5)
4997 , d_a6(a6)
4998 , d_a7(a7)
4999 , d_a8(a8)
5000 , d_a9(a9)
5001 {
5002 }
5003};
5004
5005/// This `struct` stores a list of ten arguments.
5006template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5007 class A8, class A9, class A10>
5008struct Bind_ArgTuple10 : bslmf::TypeList10<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5009 A10>
5010{
5011
5012 // TYPES
5013 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5014 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5015 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5016 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5017 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5018 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5019 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5020 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5021 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5022 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5023
5024 // INSTANCE DATA
5025 Bind_ArgTupleValue<FA1> d_a1;
5026 Bind_ArgTupleValue<FA2> d_a2;
5027 Bind_ArgTupleValue<FA3> d_a3;
5028 Bind_ArgTupleValue<FA4> d_a4;
5029 Bind_ArgTupleValue<FA5> d_a5;
5030 Bind_ArgTupleValue<FA6> d_a6;
5031 Bind_ArgTupleValue<FA7> d_a7;
5032 Bind_ArgTupleValue<FA8> d_a8;
5033 Bind_ArgTupleValue<FA9> d_a9;
5034 Bind_ArgTupleValue<FA10> d_a10;
5035
5036 // CREATORS
5037 Bind_ArgTuple10(const Bind_ArgTuple10<A1,A2,A3,A4,
5038 A5,A6,A7,A8,A9,A10>& orig)
5039 : d_a1(orig.d_a1)
5040 , d_a2(orig.d_a2)
5041 , d_a3(orig.d_a3)
5042 , d_a4(orig.d_a4)
5043 , d_a5(orig.d_a5)
5044 , d_a6(orig.d_a6)
5045 , d_a7(orig.d_a7)
5046 , d_a8(orig.d_a8)
5047 , d_a9(orig.d_a9)
5048 , d_a10(orig.d_a10)
5049 {
5050 }
5051
5052 Bind_ArgTuple10(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5053 FA7 a7, FA8 a8, FA9 a9, FA10 a10)
5054 : d_a1(a1)
5055 , d_a2(a2)
5056 , d_a3(a3)
5057 , d_a4(a4)
5058 , d_a5(a5)
5059 , d_a6(a6)
5060 , d_a7(a7)
5061 , d_a8(a8)
5062 , d_a9(a9)
5063 , d_a10(a10)
5064 {
5065 }
5066};
5067
5068/// This `struct` stores a list of eleven arguments.
5069template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5070 class A8, class A9, class A10, class A11>
5071struct Bind_ArgTuple11 : bslmf::TypeList11<A1,A2,A3,A4,A5,A6,A7,A8,A9, A10,A11>
5072{
5073
5074 // TYPES
5075 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5076 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5077 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5078 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5079 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5080 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5081 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5082 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5083 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5084 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5085 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5086
5087 // INSTANCE DATA
5088 Bind_ArgTupleValue<FA1> d_a1;
5089 Bind_ArgTupleValue<FA2> d_a2;
5090 Bind_ArgTupleValue<FA3> d_a3;
5091 Bind_ArgTupleValue<FA4> d_a4;
5092 Bind_ArgTupleValue<FA5> d_a5;
5093 Bind_ArgTupleValue<FA6> d_a6;
5094 Bind_ArgTupleValue<FA7> d_a7;
5095 Bind_ArgTupleValue<FA8> d_a8;
5096 Bind_ArgTupleValue<FA9> d_a9;
5097 Bind_ArgTupleValue<FA10> d_a10;
5098 Bind_ArgTupleValue<FA11> d_a11;
5099
5100 // CREATORS
5101 Bind_ArgTuple11(const Bind_ArgTuple11<A1,A2,A3,A4,A5,A6,
5102 A7,A8,A9,A10,A11>& orig)
5103 : d_a1(orig.d_a1)
5104 , d_a2(orig.d_a2)
5105 , d_a3(orig.d_a3)
5106 , d_a4(orig.d_a4)
5107 , d_a5(orig.d_a5)
5108 , d_a6(orig.d_a6)
5109 , d_a7(orig.d_a7)
5110 , d_a8(orig.d_a8)
5111 , d_a9(orig.d_a9)
5112 , d_a10(orig.d_a10)
5113 , d_a11(orig.d_a11)
5114 {
5115 }
5116
5117 Bind_ArgTuple11(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5118 FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11)
5119 : d_a1(a1)
5120 , d_a2(a2)
5121 , d_a3(a3)
5122 , d_a4(a4)
5123 , d_a5(a5)
5124 , d_a6(a6)
5125 , d_a7(a7)
5126 , d_a8(a8)
5127 , d_a9(a9)
5128 , d_a10(a10)
5129 , d_a11(a11)
5130 {
5131 }
5132};
5133
5134/// This `struct` stores a list of twelve arguments.
5135template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5136 class A8, class A9, class A10, class A11, class A12>
5137struct Bind_ArgTuple12 : bslmf::TypeList12<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5138 A10,A11,A12>
5139{
5140
5141 // TYPES
5142 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5143 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5144 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5145 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5146 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5147 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5148 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5149 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5150 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5151 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5152 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5153 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5154
5155 // INSTANCE DATA
5156 Bind_ArgTupleValue<FA1> d_a1;
5157 Bind_ArgTupleValue<FA2> d_a2;
5158 Bind_ArgTupleValue<FA3> d_a3;
5159 Bind_ArgTupleValue<FA4> d_a4;
5160 Bind_ArgTupleValue<FA5> d_a5;
5161 Bind_ArgTupleValue<FA6> d_a6;
5162 Bind_ArgTupleValue<FA7> d_a7;
5163 Bind_ArgTupleValue<FA8> d_a8;
5164 Bind_ArgTupleValue<FA9> d_a9;
5165 Bind_ArgTupleValue<FA10> d_a10;
5166 Bind_ArgTupleValue<FA11> d_a11;
5167 Bind_ArgTupleValue<FA12> d_a12;
5168
5169 // CREATORS
5170 Bind_ArgTuple12(const Bind_ArgTuple12<A1,A2,A3,A4,A5,A6,
5171 A7,A8,A9,A10,A11,A12>& orig)
5172 : d_a1(orig.d_a1)
5173 , d_a2(orig.d_a2)
5174 , d_a3(orig.d_a3)
5175 , d_a4(orig.d_a4)
5176 , d_a5(orig.d_a5)
5177 , d_a6(orig.d_a6)
5178 , d_a7(orig.d_a7)
5179 , d_a8(orig.d_a8)
5180 , d_a9(orig.d_a9)
5181 , d_a10(orig.d_a10)
5182 , d_a11(orig.d_a11)
5183 , d_a12(orig.d_a12)
5184 {
5185 }
5186
5187 Bind_ArgTuple12(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7,
5188 FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12)
5189 : d_a1(a1)
5190 , d_a2(a2)
5191 , d_a3(a3)
5192 , d_a4(a4)
5193 , d_a5(a5)
5194 , d_a6(a6)
5195 , d_a7(a7)
5196 , d_a8(a8)
5197 , d_a9(a9)
5198 , d_a10(a10)
5199 , d_a11(a11)
5200 , d_a12(a12)
5201 {
5202 }
5203};
5204
5205/// This `struct` stores a list of thirteen arguments.
5206template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5207 class A8, class A9, class A10, class A11, class A12, class A13>
5208struct Bind_ArgTuple13 : bslmf::TypeList13<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5209 A10,A11,A12,A13>
5210{
5211
5212 // TYPES
5213 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5214 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5215 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5216 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5217 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5218 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5219 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5220 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5221 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5222 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5223 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5224 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5225 typedef typename bslmf::ForwardingType<A13>::Type FA13;
5226
5227 // INSTANCE DATA
5228 Bind_ArgTupleValue<FA1> d_a1;
5229 Bind_ArgTupleValue<FA2> d_a2;
5230 Bind_ArgTupleValue<FA3> d_a3;
5231 Bind_ArgTupleValue<FA4> d_a4;
5232 Bind_ArgTupleValue<FA5> d_a5;
5233 Bind_ArgTupleValue<FA6> d_a6;
5234 Bind_ArgTupleValue<FA7> d_a7;
5235 Bind_ArgTupleValue<FA8> d_a8;
5236 Bind_ArgTupleValue<FA9> d_a9;
5237 Bind_ArgTupleValue<FA10> d_a10;
5238 Bind_ArgTupleValue<FA11> d_a11;
5239 Bind_ArgTupleValue<FA12> d_a12;
5240 Bind_ArgTupleValue<FA13> d_a13;
5241
5242 // CREATORS
5243 Bind_ArgTuple13(const Bind_ArgTuple13<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5244 A10,A11,A12,A13>& orig)
5245 : d_a1(orig.d_a1)
5246 , d_a2(orig.d_a2)
5247 , d_a3(orig.d_a3)
5248 , d_a4(orig.d_a4)
5249 , d_a5(orig.d_a5)
5250 , d_a6(orig.d_a6)
5251 , d_a7(orig.d_a7)
5252 , d_a8(orig.d_a8)
5253 , d_a9(orig.d_a9)
5254 , d_a10(orig.d_a10)
5255 , d_a11(orig.d_a11)
5256 , d_a12(orig.d_a12)
5257 , d_a13(orig.d_a13)
5258 {
5259 }
5260
5261 Bind_ArgTuple13(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7,
5262 FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12, FA13 a13)
5263 : d_a1(a1)
5264 , d_a2(a2)
5265 , d_a3(a3)
5266 , d_a4(a4)
5267 , d_a5(a5)
5268 , d_a6(a6)
5269 , d_a7(a7)
5270 , d_a8(a8)
5271 , d_a9(a9)
5272 , d_a10(a10)
5273 , d_a11(a11)
5274 , d_a12(a12)
5275 , d_a13(a13)
5276 {
5277 }
5278};
5279
5280/// This `struct` stores a list of fourteen arguments.
5281template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5282 class A8, class A9, class A10, class A11, class A12, class A13,
5283 class A14>
5284struct Bind_ArgTuple14 : bslmf::TypeList14<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5285 A10,A11,A12,A13,A14>
5286{
5287
5288 // TYPES
5289 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5290 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5291 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5292 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5293 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5294 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5295 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5296 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5297 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5298 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5299 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5300 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5301 typedef typename bslmf::ForwardingType<A13>::Type FA13;
5302 typedef typename bslmf::ForwardingType<A14>::Type FA14;
5303
5304 // INSTANCE DATA
5305 Bind_ArgTupleValue<FA1> d_a1;
5306 Bind_ArgTupleValue<FA2> d_a2;
5307 Bind_ArgTupleValue<FA3> d_a3;
5308 Bind_ArgTupleValue<FA4> d_a4;
5309 Bind_ArgTupleValue<FA5> d_a5;
5310 Bind_ArgTupleValue<FA6> d_a6;
5311 Bind_ArgTupleValue<FA7> d_a7;
5312 Bind_ArgTupleValue<FA8> d_a8;
5313 Bind_ArgTupleValue<FA9> d_a9;
5314 Bind_ArgTupleValue<FA10> d_a10;
5315 Bind_ArgTupleValue<FA11> d_a11;
5316 Bind_ArgTupleValue<FA12> d_a12;
5317 Bind_ArgTupleValue<FA13> d_a13;
5318 Bind_ArgTupleValue<FA14> d_a14;
5319
5320 // CREATORS
5321 Bind_ArgTuple14(const Bind_ArgTuple14<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5322 A10,A11,A12,A13,A14>& orig)
5323 : d_a1(orig.d_a1)
5324 , d_a2(orig.d_a2)
5325 , d_a3(orig.d_a3)
5326 , d_a4(orig.d_a4)
5327 , d_a5(orig.d_a5)
5328 , d_a6(orig.d_a6)
5329 , d_a7(orig.d_a7)
5330 , d_a8(orig.d_a8)
5331 , d_a9(orig.d_a9)
5332 , d_a10(orig.d_a10)
5333 , d_a11(orig.d_a11)
5334 , d_a12(orig.d_a12)
5335 , d_a13(orig.d_a13)
5336 , d_a14(orig.d_a14)
5337 {
5338 }
5339
5340 Bind_ArgTuple14(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5341 FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12,
5342 FA13 a13, FA14 a14)
5343 : d_a1(a1)
5344 , d_a2(a2)
5345 , d_a3(a3)
5346 , d_a4(a4)
5347 , d_a5(a5)
5348 , d_a6(a6)
5349 , d_a7(a7)
5350 , d_a8(a8)
5351 , d_a9(a9)
5352 , d_a10(a10)
5353 , d_a11(a11)
5354 , d_a12(a12)
5355 , d_a13(a13)
5356 , d_a14(a14)
5357 {
5358 }
5359};
5360
5361 // ===============
5362 // class Bind_Impl
5363 // ===============
5364
5365/// Either this `class` or `Bind_ImplExplicit` is used as the base `class`
5366/// of `Bind`, where `Bind_ImplExplicit` is used only if certain conditions
5367/// on the template parameters are met, and this `class` is more resilient
5368/// and used in the more general case. This `class` is not to be directly
5369/// used outside this component. This `class` implements the storage and
5370/// functionality required for a binder that invokes an object of type
5371/// `t_FUNC` with a list of invocation parameters of type `t_BOUND_TUPLE`.
5372/// The return type of the invocation is determined by a combination of type
5373/// `t_RET` and `t_FUNC`. Note that this class is a generic binder
5374/// implementation; this component provides more type safe implementation
5375/// `Bind_ImplExplicit` that will be used under certain conditions.
5376///
5377/// See @ref bdlf_bind
5378template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
5379class Bind_Impl {
5380
5381 // PRIVATE TYPES
5382
5383 /// The return type of this binder object.
5384 typedef Bind_FuncTraits<t_RET, t_FUNC> Traits;
5385
5386 public:
5387 // PUBLIC TYPES
5388 typedef typename Traits::ResultType ResultType;
5389
5390 private:
5391 // PRIVATE TYPES
5392 typedef bslmf::Tag<Traits::k_HAS_POINTER_SEMANTICS> HasPointerSemantics;
5393 typedef Bind_Invoker<ResultType, t_BOUND_TUPLE::LENGTH>
5394 Invoker;
5395 typedef typename Traits::Type FuncType;
5396
5397 // PRIVATE INSTANCE DATA
5398 bslalg::ConstructorProxy<typename Traits::WrapperType> d_func;
5399 t_BOUND_TUPLE d_list;
5400
5401 public:
5402 // TRAITS
5403 BSLMF_NESTED_TRAIT_DECLARATION(Bind_Impl, bslma::UsesBslmaAllocator);
5404
5405 private:
5406 // PRIVATE ACCESSORS
5407
5408 /// Invoke the bound functor using the invocation parameters provided at
5409 /// construction of this `Bind` object. Substituting place-holders for
5410 /// their respective values in the specified `arguments`. The
5411 /// `bslmf::Tag` is only used for overloading resolution - indicating
5412 /// whether `d_func` has pointer semantics or not.
5413 template <class t_ARG_TUPLE>
5414 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<0>) const
5415 {
5416 Invoker invoker;
5417 return invoker.invoke(&d_func.object(), &d_list, arguments);
5418 }
5419
5420 /// Invoke the bound functor using the invocation parameters provided at
5421 /// construction of this `Bind` object. Substituting place-holders for
5422 /// their respective values in the specified `arguments`. The
5423 /// `bslmf::Tag` is only used for overloading resolution - indicating
5424 /// whether `d_func` has pointer semantics or not.
5425 template <class t_ARG_TUPLE>
5426 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<1>) const
5427 {
5428 Invoker invoker;
5429 return invoker.invoke(&(*d_func.object()), &d_list, arguments);
5430 }
5431
5432 public:
5433 // CREATORS
5434
5435 /// Construct a `Bind_Impl` object bound to the specified invocable
5436 /// object `func` using the invocation parameters specified in `list`.
5437 /// Optionally specify a `basicAllocator` used to supply memory. If
5438 /// `basicAllocator` is 0, the currently installed default allocator is
5439 /// used.
5440 Bind_Impl(typename bslmf::ForwardingType<t_FUNC>::Type func,
5441 t_BOUND_TUPLE const& list,
5442 bslma::Allocator *basicAllocator = 0)
5443 : d_func(func, basicAllocator)
5444 , d_list(list, basicAllocator)
5445 {
5446 }
5447
5448 Bind_Impl(typename bslmf::ForwardingType<t_FUNC>::Type func,
5449 bslmf::MovableRef<t_BOUND_TUPLE> list,
5450 bslma::Allocator *basicAllocator = 0)
5451 // Construct a 'Bind_Impl' object bound to the specified invocable
5452 // object 'func' using the moved invocation parameters specified in 'list'.
5453 // Optionally specify a 'basicAllocator' used to supply memory. If
5454 // 'basicAllocator' is 0, the currently installed default allocator is
5455 // used.
5456 : d_func(func, basicAllocator)
5457 , d_list(bslmf::MovableRefUtil::move(list), basicAllocator)
5458 {
5459 }
5460
5461 /// Construct a `Bind_Impl` object bound to the same invocable object
5462 /// `func` and using the same invocation parameters as the specified
5463 /// `other` object. Optionally specify a `basicAllocator` used to
5464 /// supply memory. If `basicAllocator` is 0, the currently installed
5465 /// default allocator is used.
5466 Bind_Impl(const Bind_Impl& other, bslma::Allocator *basicAllocator = 0)
5467 : d_func(other.d_func, basicAllocator)
5468 , d_list(other.d_list, basicAllocator)
5469 {
5470 }
5471
5472 /// Construct a `Bind_Impl` object bound to the same invocable object
5473 /// `func` and using the invocation parameters moved from the specified
5474 /// `other` object. Optionally specify a `basicAllocator` used to
5475 /// supply memory. If `basicAllocator` is 0, the currently installed
5476 /// default allocator is used.
5477 Bind_Impl(bslmf::MovableRef<Bind_Impl> other,
5478 bslma::Allocator *basicAllocator = 0)
5479 : d_func(bslmf::MovableRefUtil::move(
5480 bslmf::MovableRefUtil::access(other.d_func)),
5481 basicAllocator)
5482 , d_list(bslmf::MovableRefUtil::move(
5483 bslmf::MovableRefUtil::access(other.d_list)),
5484 basicAllocator)
5485 {
5486 }
5487
5488 // ACCESSORS
5489
5490 /// Invoke the bound functor using the invocation parameters provided at
5491 /// construction of this `Bind` object, substituting place-holders for
5492 /// their respective values in the specified `arguments`.
5493 template <class t_ARG_TUPLE>
5494 ResultType invoke(t_ARG_TUPLE& arguments) const
5495 {
5496 return invokeImpl(arguments, HasPointerSemantics());
5497 }
5498
5499 /// Invoke the bound functor using only the invocation parameters
5500 /// provided at construction of this `Bind` object and return the
5501 /// result.
5502 ResultType operator()() const
5503 {
5504 typedef Bind_ArgTuple0 ArgList;
5505 ArgList argList;
5506 return invoke(argList);
5507 }
5508
5509 /// Invoke the bound functor using the invocation template provided at
5510 /// construction of this `Bind` object, substituting place-holders for
5511 /// argument 1 with the value of the specified argument `p1`. Return
5512 /// the result.
5513 template <class P1>
5514 ResultType operator()(P1& p1) const
5515 {
5516 typedef Bind_ArgTuple1<P1&> ArgList;
5517 ArgList argList(p1);
5518 return invoke(argList);
5519 }
5520
5521 /// Invoke the bound functor using the invocation template provided at
5522 /// construction of this `Bind` object, substituting place-holders for
5523 /// argument 1 with the value of the specified argument `p1`. Return
5524 /// the result.
5525 template <class P1>
5526 ResultType operator()(P1 const& p1) const
5527 {
5528 typedef Bind_ArgTuple1<P1 const&> ArgList;
5529 ArgList argList(p1);
5530 return invoke(argList);
5531 }
5532
5533 /// Invoke the bound functor using the invocation template provided at
5534 /// construction of this `Bind` object, substituting place-holders for
5535 /// arguments 1 and 2 with the value of the specified arguments `p1`,
5536 /// and `p2` respectively. Return the result.
5537 template <class P1, class P2>
5538 ResultType operator()(P1& p1, P2& p2) const
5539 {
5540 typedef Bind_ArgTuple2<P1&, P2&> ArgList;
5541 ArgList argList(p1, p2);
5542 return invoke(argList);
5543 }
5544
5545 /// Invoke the bound functor using the invocation template provided at
5546 /// construction of this `Bind` object, substituting place-holders for
5547 /// arguments 1 and 2 with the value of the specified arguments `p1`,
5548 /// and `p2` respectively. Return the result.
5549 template <class P1, class P2>
5550 ResultType operator()(P1 const& p1, P2 const& p2) const
5551 {
5552 typedef Bind_ArgTuple2<P1 const&, P2 const&> ArgList;
5553 ArgList argList(p1, p2);
5554 return invoke(argList);
5555 }
5556
5557 /// Invoke the bound functor using the invocation template provided at
5558 /// construction of this `Bind` object, substituting place-holders for
5559 /// arguments 1, 2, and 3 with the values of the specified arguments
5560 /// `p1`, `p2` and `p3` respectively. Return the result.
5561 template <class P1, class P2, class P3>
5562 ResultType operator()(P1& p1, P2& p2, P3& p3) const
5563 {
5564 typedef Bind_ArgTuple3<P1&, P2&, P3&> ArgList;
5565 ArgList argList(p1, p2, p3);
5566 return invoke(argList);
5567 }
5568
5569 /// Invoke the bound functor using the invocation template provided at
5570 /// construction of this `Bind` object, substituting place-holders for
5571 /// arguments 1, 2, and 3 with the values of the specified arguments
5572 /// `p1`, `p2` and `p3` respectively. Return the result.
5573 template <class P1, class P2, class P3>
5574 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3) const
5575 {
5576 typedef Bind_ArgTuple3<P1 const&, P2 const&, P3 const&> ArgList;
5577 ArgList argList(p1, p2, p3);
5578 return invoke(argList);
5579 }
5580
5581 /// Invoke the bound functor using the invocation template provided at
5582 /// construction of this `Bind` object, substituting place-holders for
5583 /// arguments 1 - 4 with the values of the specified arguments `p1` -
5584 /// `p4` respectively. Return the result.
5585 template <class P1, class P2, class P3, class P4>
5586 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4) const
5587 {
5588 typedef Bind_ArgTuple4<P1&, P2&, P3&, P4&> ArgList;
5589 ArgList argList(p1, p2, p3, p4);
5590 return invoke(argList);
5591 }
5592
5593 /// Invoke the bound functor using the invocation template provided at
5594 /// construction of this `Bind` object, substituting place-holders for
5595 /// arguments 1 - 4 with the values of the specified arguments `p1` -
5596 /// `p4` respectively. Return the result.
5597 template <class P1, class P2, class P3, class P4>
5598 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5599 P4 const& p4) const
5600 {
5601 typedef Bind_ArgTuple4<P1 const&, P2 const&, P3 const&, P4 const&>
5602 ArgList;
5603 ArgList argList(p1, p2, p3, p4);
5604 return invoke(argList);
5605 }
5606
5607 /// Invoke the bound functor using the invocation template provided at
5608 /// construction of this `Bind` object, substituting place-holders for
5609 /// arguments 1 - 5 with the values of the specified arguments `p1` -
5610 /// `p5` respectively. Return the result.
5611 template <class P1, class P2, class P3, class P4, class P5>
5612 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5) const
5613 {
5614 typedef Bind_ArgTuple5<P1&, P2&, P3&, P4&, P5&> ArgList;
5615 ArgList argList(p1, p2, p3, p4, p5);
5616 return invoke(argList);
5617 }
5618
5619 /// Invoke the bound functor using the invocation template provided at
5620 /// construction of this `Bind` object, substituting place-holders for
5621 /// arguments 1 - 5 with the values of the specified arguments `p1` -
5622 /// `p5` respectively. Return the result.
5623 template <class P1, class P2, class P3, class P4, class P5>
5624 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5625 P4 const& p4, P5 const& p5) const
5626 {
5627 typedef Bind_ArgTuple5<P1 const&, P2 const&, P3 const&, P4 const&,
5628 P5 const&> ArgList;
5629 ArgList argList(p1, p2, p3, p4, p5);
5630 return invoke(argList);
5631 }
5632
5633 /// Invoke the bound functor using the invocation template provided at
5634 /// construction of this `Bind` object, substituting place-holders for
5635 /// arguments 1 - 6 with the values of the specified arguments `p1` -
5636 /// `p7` respectively. Return the result.
5637 template <class P1, class P2, class P3, class P4, class P5, class P6>
5638 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5639 P6& p6) const
5640 {
5641 typedef Bind_ArgTuple6<P1&, P2&, P3&, P4&, P5&, P6&> ArgList;
5642 ArgList argList(p1, p2, p3, p4, p5, p6);
5643 return invoke(argList);
5644 }
5645
5646 /// Invoke the bound functor using the invocation template provided at
5647 /// construction of this `Bind` object, substituting place-holders for
5648 /// arguments 1 - 6 with the values of the specified arguments `p1` -
5649 /// `p7` respectively. Return the result.
5650 template <class P1, class P2, class P3, class P4, class P5, class P6>
5651 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5652 P4 const& p4, P5 const& p5, P6 const& p6) const
5653 {
5654 typedef Bind_ArgTuple6<P1 const&, P2 const&, P3 const&, P4 const&,
5655 P5 const&, P6 const&> ArgList;
5656 ArgList argList(p1, p2, p3, p4, p5, p6);
5657 return invoke(argList);
5658 }
5659
5660 /// Invoke the bound functor using the invocation template provided at
5661 /// construction of this `Bind` object, substituting place-holders for
5662 /// arguments 1 - 7 with the values of the specified arguments `p1` -
5663 /// `p7` respectively. Return the result.
5664 template <class P1, class P2, class P3, class P4, class P5, class P6,
5665 class P7>
5666 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5667 P6& p6, P7& p7) const
5668 {
5669 typedef Bind_ArgTuple7<P1&, P2&, P3&, P4&, P5&, P6&, P7&> ArgList;
5670 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
5671 return invoke(argList);
5672 }
5673
5674 /// Invoke the bound functor using the invocation template provided at
5675 /// construction of this `Bind` object, substituting place-holders for
5676 /// arguments 1 - 7 with the values of the specified arguments `p1` -
5677 /// `p7` respectively. Return the result.
5678 template <class P1, class P2, class P3, class P4, class P5, class P6,
5679 class P7>
5680 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5681 P4 const& p4, P5 const& p5, P6 const& p6,
5682 P7 const& p7) const
5683 {
5684 typedef Bind_ArgTuple7<P1 const&, P2 const&, P3 const&, P4 const&,
5685 P5 const&, P6 const&, P7 const&> ArgList;
5686 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
5687 return invoke(argList);
5688 }
5689
5690 /// Invoke the bound functor using the invocation template provided at
5691 /// construction of this `Bind` object, substituting place-holders for
5692 /// arguments 1 - 8 with the values of the specified arguments `p1` -
5693 /// `p8` respectively. Return the result.
5694 template <class P1, class P2, class P3, class P4, class P5, class P6,
5695 class P7, class P8>
5696 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5697 P6& p6, P7& p7, P8& p8) const
5698 {
5699 typedef Bind_ArgTuple8<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&> ArgList;
5700 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
5701 return invoke(argList);
5702 }
5703
5704 /// Invoke the bound functor using the invocation template provided at
5705 /// construction of this `Bind` object, substituting place-holders for
5706 /// arguments 1 - 8 with the values of the specified arguments `p1` -
5707 /// `p8` respectively. Return the result.
5708 template <class P1, class P2, class P3, class P4, class P5, class P6,
5709 class P7, class P8>
5710 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5711 P4 const& p4, P5 const& p5, P6 const& p6,
5712 P7 const& p7, P8 const& p8) const
5713 {
5714 typedef Bind_ArgTuple8<P1 const&, P2 const&, P3 const&, P4 const&,
5715 P5 const&, P6 const&, P7 const&, P8 const&> ArgList;
5716 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
5717 return invoke(argList);
5718 }
5719
5720 /// Invoke the bound functor using the invocation template provided at
5721 /// construction of this `Bind` object, substituting place-holders for
5722 /// arguments 1 - 9 with the values of the specified arguments `p1` -
5723 /// `p9` respectively. Return the result.
5724 template <class P1, class P2, class P3, class P4, class P5, class P6,
5725 class P7, class P8, class P9>
5726 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5727 P6& p6, P7& p7, P8& p8, P9& p9) const
5728 {
5729 typedef Bind_ArgTuple9<P1&, P2&, P3&, P4&, P5&,
5730 P6&, P7&, P8&, P9&> ArgList;
5731 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
5732 return invoke(argList);
5733 }
5734
5735 /// Invoke the bound functor using the invocation template provided at
5736 /// construction of this `Bind` object, substituting place-holders for
5737 /// arguments 1 - 9 with the values of the specified arguments `p1` -
5738 /// `p9` respectively. Return the result.
5739 template <class P1, class P2, class P3, class P4, class P5, class P6,
5740 class P7, class P8, class P9>
5741 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5742 P4 const& p4, P5 const& p5, P6 const& p6,
5743 P7 const& p7, P8 const& p8, P9 const& p9) const
5744 {
5745 typedef Bind_ArgTuple9<P1 const&, P2 const&, P3 const&, P4 const&,
5746 P5 const&, P6 const&, P7 const&, P8 const&,
5747 P9 const&> ArgList;
5748 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
5749 return invoke(argList);
5750 }
5751
5752 /// Invoke the bound functor using the invocation template provided at
5753 /// construction of this `Bind` object, substituting place-holders for
5754 /// arguments 1 - 10 with the values of the specified arguments `p1` -
5755 /// `p10` respectively. Return the result.
5756 template <class P1, class P2, class P3, class P4, class P5, class P6,
5757 class P7, class P8, class P9, class P10>
5758 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5759 P6& p6, P7& p7, P8& p8, P9& p9,
5760 P10& p10) const
5761 {
5762 typedef Bind_ArgTuple10<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5763 P9&, P10&> ArgList;
5764 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
5765 return invoke(argList);
5766 }
5767
5768 /// Invoke the bound functor using the invocation template provided at
5769 /// construction of this `Bind` object, substituting place-holders for
5770 /// arguments 1 - 10 with the values of the specified arguments `p1` -
5771 /// `p10` respectively. Return the result.
5772 template <class P1, class P2, class P3, class P4, class P5, class P6,
5773 class P7, class P8, class P9, class P10>
5774 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5775 P4 const& p4, P5 const& p5, P6 const& p6,
5776 P7 const& p7, P8 const& p8, P9 const& p9,
5777 P10 const& p10) const
5778 {
5779 typedef Bind_ArgTuple10<P1 const&, P2 const&, P3 const&, P4 const&,
5780 P5 const&, P6 const&, P7 const&, P8 const&,
5781 P9 const&, P10 const&> ArgList;
5782 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
5783 return invoke(argList);
5784 }
5785
5786 /// Invoke the bound functor using the invocation template provided at
5787 /// construction of this `Bind` object, substituting place-holders for
5788 /// arguments 1 - 11 with the values of the specified arguments `p1` -
5789 /// `p11` respectively. Return the result.
5790 template <class P1, class P2, class P3, class P4, class P5, class P6,
5791 class P7, class P8, class P9, class P10, class P11>
5792 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5793 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5794 P11& p11) const
5795 {
5796 typedef Bind_ArgTuple11<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5797 P9&, P10&, P11&> ArgList;
5798 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
5799 return invoke(argList);
5800 }
5801
5802 /// Invoke the bound functor using the invocation template provided at
5803 /// construction of this `Bind` object, substituting place-holders for
5804 /// arguments 1 - 11 with the values of the specified arguments `p1` -
5805 /// `p11` respectively. Return the result.
5806 template <class P1, class P2, class P3, class P4, class P5, class P6,
5807 class P7, class P8, class P9, class P10, class P11>
5808 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5809 P4 const& p4, P5 const& p5, P6 const& p6,
5810 P7 const& p7, P8 const& p8, P9 const& p9,
5811 P10 const& p10, P11 const& p11) const
5812 {
5813 typedef Bind_ArgTuple11<P1 const&, P2 const&, P3 const&, P4 const&,
5814 P5 const&, P6 const&, P7 const&, P8 const&,
5815 P9 const&, P10 const&, P11 const&> ArgList;
5816 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
5817 return invoke(argList);
5818 }
5819
5820 /// Invoke the bound functor using the invocation template provided at
5821 /// construction of this `Bind` object, substituting place-holders for
5822 /// arguments 1 - 12 with the values of the specified arguments `p1` -
5823 /// `p12` respectively. Return the result.
5824 template <class P1, class P2, class P3, class P4, class P5, class P6,
5825 class P7, class P8, class P9, class P10, class P11, class P12>
5826 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5827 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5828 P11& p11, P12& p12) const
5829 {
5830 typedef Bind_ArgTuple12<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5831 P9&, P10&, P11&, P12&> ArgList;
5832 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
5833 return invoke(argList);
5834 }
5835
5836 /// Invoke the bound functor using the invocation template provided at
5837 /// construction of this `Bind` object, substituting place-holders for
5838 /// arguments 1 - 12 with the values of the specified arguments `p1` -
5839 /// `p12` respectively. Return the result.
5840 template <class P1, class P2, class P3, class P4, class P5, class P6,
5841 class P7, class P8, class P9, class P10, class P11, class P12>
5842 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5843 P4 const& p4, P5 const& p5, P6 const& p6,
5844 P7 const& p7, P8 const& p8, P9 const& p9,
5845 P10 const& p10, P11 const& p11,
5846 P12 const& p12) const
5847 {
5848 typedef Bind_ArgTuple12<P1 const&, P2 const&, P3 const&, P4 const&,
5849 P5 const&, P6 const&, P7 const&, P8 const&,
5850 P9 const&, P10 const&, P11 const&,
5851 P12 const&> ArgList;
5852 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
5853 return invoke(argList);
5854 }
5855
5856 /// Invoke the bound functor using the invocation template provided at
5857 /// construction of this `Bind` object, substituting place-holders for
5858 /// arguments 1 - 13 with the values of the specified arguments `p1` -
5859 /// `p13` respectively. Return the result.
5860 template <class P1, class P2, class P3, class P4, class P5, class P6,
5861 class P7, class P8, class P9, class P10, class P11, class P12,
5862 class P13>
5863 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5864 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5865 P11& p11, P12& p12, P13& p13) const
5866 {
5867 typedef Bind_ArgTuple13<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5868 P9&, P10&, P11&, P12&, P13&> ArgList;
5869 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5870 p13);
5871 return invoke(argList);
5872 }
5873
5874 /// Invoke the bound functor using the invocation template provided at
5875 /// construction of this `Bind` object, substituting place-holders for
5876 /// arguments 1 - 13 with the values of the specified arguments `p1` -
5877 /// `p13` respectively. Return the result.
5878 template <class P1, class P2, class P3, class P4, class P5, class P6,
5879 class P7, class P8, class P9, class P10, class P11, class P12,
5880 class P13>
5881 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5882 P4 const& p4, P5 const& p5, P6 const& p6,
5883 P7 const& p7, P8 const& p8, P9 const& p9,
5884 P10 const& p10, P11 const& p11,
5885 P12 const& p12, P13 const& p13) const
5886 {
5887 typedef Bind_ArgTuple13<P1 const&, P2 const&, P3 const&, P4 const&,
5888 P5 const&, P6 const&, P7 const&, P8 const&,
5889 P9 const&, P10 const&, P11 const&,
5890 P12 const&, P13 const&> ArgList;
5891 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5892 p13);
5893 return invoke(argList);
5894 }
5895
5896 /// Invoke the bound functor using the invocation template provided at
5897 /// construction of this `Bind` object, substituting place-holders for
5898 /// arguments 1 - 14 with the values of the specified arguments `p1` -
5899 /// `p14` respectively. Return the result.
5900 template <class P1, class P2, class P3, class P4, class P5, class P6,
5901 class P7, class P8, class P9, class P10, class P11, class P12,
5902 class P13, class P14>
5903 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5904 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5905 P11& p11, P12& p12, P13& p13, P14& p14) const
5906 {
5907 typedef Bind_ArgTuple14<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5908 P9&, P10&, P11&, P12&, P13&, P14&> ArgList;
5909 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5910 p13, p14);
5911 return invoke(argList);
5912 }
5913
5914 /// Invoke the bound functor using the invocation template provided at
5915 /// construction of this `Bind` object, substituting place-holders for
5916 /// arguments 1 - 14 with the values of the specified arguments `p1` -
5917 /// `p14` respectively. Return the result.
5918 template <class P1, class P2, class P3, class P4, class P5, class P6,
5919 class P7, class P8, class P9, class P10, class P11, class P12,
5920 class P13, class P14>
5921 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5922 P4 const& p4, P5 const& p5, P6 const& p6,
5923 P7 const& p7, P8 const& p8, P9 const& p9,
5924 P10 const& p10, P11 const& p11,
5925 P12 const& p12, P13 const& p13,
5926 P14 const& p14) const
5927 {
5928 typedef Bind_ArgTuple14<P1 const&, P2 const&, P3 const&, P4 const&,
5929 P5 const&, P6 const&, P7 const&, P8 const&,
5930 P9 const&, P10 const&, P11 const&,
5931 P12 const&, P13 const&, P14 const&> ArgList;
5932 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5933 p13, p14);
5934 return invoke(argList);
5935 }
5936};
5937
5938 // =======================
5939 // class Bind_ImplExplicit
5940 // =======================
5941
5942/// This class implements the storage and functionality required for a
5943/// binder that invokes an object of type `t_FUNC` with a list of invocation
5944/// parameters of type `t_BOUND_TUPLE`. The return type of the invocation
5945/// is determined by a combination of type `t_RET` and `t_FUNC`. This
5946/// implementation is preferred to the more generic `Bind_Impl` above,
5947/// because it allows to match the signature more closely. However, this
5948/// implementation can only be used when the type of binder is "explicit"
5949/// (see below). Note that it does not yet allow to cast the bound
5950/// arguments to their respective argument type at binding time; the bound
5951/// arguments are still converted to the signature at invocation time.
5952///
5953/// A binder is explicit if:
5954///
5955/// 1. The function signature can be determined completely (return and
5956/// argument types, e.g., free or member function pointers).
5957/// 2. There are no duplicate references to the same placeholder nor any
5958/// nested `Bind` objects in the bound arguments.
5959/// 3. There are no ellipsis argument in the signature of the function.
5960///
5961/// Note that this class is an implementation detail of `Bind`. Do not use
5962/// this class outside this component.
5963///
5964/// See @ref bdlf_bind
5965template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
5966class Bind_ImplExplicit {
5967
5968 // PRIVATE TYPES
5969 typedef Bind_FuncTraits<t_RET, t_FUNC> Traits;
5970
5971 public:
5972 // PUBLIC TYPES
5973
5974 /// The return type of this binder object.
5975 typedef typename Traits::ResultType ResultType;
5976
5977 private:
5978 // PRIVATE TYPES
5979 typedef typename Traits::Type FuncType;
5980 typedef Bind_Invoker<ResultType,
5981 t_BOUND_TUPLE::LENGTH> Invoker;
5982 typedef bslmf::Tag<Traits::k_HAS_POINTER_SEMANTICS> HasPointerSemantics;
5983 typedef typename Traits::FuncArgumentList FuncArgumentList;
5984 typedef Bind_CalcParameterMask<t_BOUND_TUPLE> ParamMask;
5985
5986 enum {
5987 k_IS_MEMBER_OFFSET =
5988 (int)Traits::k_IS_MEMBER_OFFSET // 1 for member functions, 0 else
5989 };
5990
5991 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
5992 (int)ParamMask::k_PARAMINDEX1, k_IS_MEMBER_OFFSET>::Type P1;
5993 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
5994 (int)ParamMask::k_PARAMINDEX2, k_IS_MEMBER_OFFSET>::Type P2;
5995 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
5996 (int)ParamMask::k_PARAMINDEX3, k_IS_MEMBER_OFFSET>::Type P3;
5997 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
5998 (int)ParamMask::k_PARAMINDEX4, k_IS_MEMBER_OFFSET>::Type P4;
5999 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6000 (int)ParamMask::k_PARAMINDEX5, k_IS_MEMBER_OFFSET>::Type P5;
6001 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6002 (int)ParamMask::k_PARAMINDEX6, k_IS_MEMBER_OFFSET>::Type P6;
6003 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6004 (int)ParamMask::k_PARAMINDEX7, k_IS_MEMBER_OFFSET>::Type P7;
6005 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6006 (int)ParamMask::k_PARAMINDEX8, k_IS_MEMBER_OFFSET>::Type P8;
6007 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6008 (int)ParamMask::k_PARAMINDEX9, k_IS_MEMBER_OFFSET>::Type P9;
6009 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6010 (int)ParamMask::k_PARAMINDEX10, k_IS_MEMBER_OFFSET>::Type P10;
6011 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6012 (int)ParamMask::k_PARAMINDEX11, k_IS_MEMBER_OFFSET>::Type P11;
6013 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6014 (int)ParamMask::k_PARAMINDEX12, k_IS_MEMBER_OFFSET>::Type P12;
6015 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6016 (int)ParamMask::k_PARAMINDEX13, k_IS_MEMBER_OFFSET>::Type P13;
6017 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6018 (int)ParamMask::k_PARAMINDEX14, k_IS_MEMBER_OFFSET>::Type P14;
6019
6020 // PRIVATE INSTANCE DATA
6021 bslalg::ConstructorProxy<typename Traits::WrapperType> d_func;
6022 t_BOUND_TUPLE d_list;
6023
6024 public:
6025 // TRAITS
6026 BSLMF_NESTED_TRAIT_DECLARATION(Bind_ImplExplicit,
6027 bslma::UsesBslmaAllocator);
6028
6029 private:
6030 // PRIVATE ACCESSORS
6031
6032 /// Invoke the bound functor using the invocation parameters provided at
6033 /// construction of this `Bind` object. Substituting place-holders for
6034 /// their respective values in the specified `arguments`. The
6035 /// `bslmf::Tag` is only used for overloading resolution - indicating
6036 /// whether `d_func` has pointer semantics or not.
6037 template <class t_ARG_TUPLE>
6038 ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<0>) const
6039 {
6040 Invoker invoker;
6041 return invoker.invoke(&d_func.object(), &d_list, arguments);
6042 }
6043
6044 /// Invoke the bound functor using the invocation parameters provided at
6045 /// construction of this `Bind` object. Substituting place-holders for
6046 /// their respective values in the specified `arguments`. The
6047 /// `bslmf::Tag` is only used for overloading resolution - indicating
6048 /// whether `d_func` has pointer semantics or not.
6049 template <class t_ARG_TUPLE>
6050 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<1>) const
6051 {
6052 Invoker invoker;
6053 return invoker.invoke(&(*d_func.object()), &d_list, arguments);
6054 }
6055
6056 public:
6057 // CREATORS
6058
6059 /// Construct a `Bind_Impl` object bound to the specified invocable
6060 /// object `func` using the invocation parameters specified in `list`.
6061 Bind_ImplExplicit(typename bslmf::ForwardingType<t_FUNC>::Type func,
6062 t_BOUND_TUPLE const& list,
6063 bslma::Allocator *allocator)
6064 : d_func(func, allocator)
6065 , d_list(list, allocator)
6066 {
6067 }
6068
6069 /// Construct a `Bind_Impl` object bound to the specified invocable
6070 /// object `func` using the invocation parameters specified in `list`.
6071 Bind_ImplExplicit(typename bslmf::ForwardingType<t_FUNC>::Type func,
6072 bslmf::MovableRef<t_BOUND_TUPLE> list,
6073 bslma::Allocator *allocator)
6074 : d_func(func, allocator)
6075 , d_list(bslmf::MovableRefUtil::move(list), allocator)
6076 {
6077 }
6078
6079 Bind_ImplExplicit(const Bind_ImplExplicit& other,
6080 bslma::Allocator *allocator)
6081 : d_func(other.d_func, allocator)
6082 , d_list(other.d_list, allocator)
6083 {
6084 }
6085
6086 Bind_ImplExplicit(bslmf::MovableRef<Bind_ImplExplicit> other,
6087 bslma::Allocator *basicAllocator = 0)
6088 : d_func(bslmf::MovableRefUtil::move(
6089 bslmf::MovableRefUtil::access(other.d_func)),
6090 basicAllocator)
6091 , d_list(bslmf::MovableRefUtil::move(
6092 bslmf::MovableRefUtil::access(other.d_list)),
6093 basicAllocator)
6094 {
6095 }
6096
6097 // ACCESSORS
6098
6099 /// Invoke the bound functor using the invocation parameters provided at
6100 /// construction of this `Bind` object. Substituting place-holders for
6101 /// their respective values in the specified `arguments`.
6102 template <class t_ARG_TUPLE>
6103 ResultType invoke(t_ARG_TUPLE& arguments) const
6104 {
6105 return invokeImpl(arguments, HasPointerSemantics());
6106 }
6107
6108 /// Invoke the bound functor using only the invocation parameters
6109 /// provided at construction of this `Bind` object and return the
6110 /// result.
6111 ResultType operator()() const
6112 {
6113 typedef Bind_ArgTuple0 ArgList; ArgList argList;
6114 return invoke(argList);
6115 }
6116
6117 /// Invoke the bound functor using the invocation template provided at
6118 /// construction of this `Bind` object, substituting place-holders for
6119 /// argument 1 with the value of the specified argument `p1`. Return
6120 /// the result.
6121 ResultType operator()(P1 p1) const
6122 {
6123
6124 typedef Bind_ArgTuple1<P1> ArgList; ArgList argList(p1);
6125 return invoke(argList);
6126 }
6127
6128 /// Invoke the bound functor using the invocation template provided at
6129 /// construction of this `Bind` object, substituting place-holders for
6130 /// arguments 1 and 2 with the value of the specified arguments `p1`,
6131 /// and `p2` respectively. Return the result.
6132 ResultType operator()(P1 p1, P2 p2) const
6133 {
6134 typedef Bind_ArgTuple2<P1, P2> ArgList;
6135 ArgList argList(p1, p2);
6136 return invoke(argList);
6137 }
6138
6139 /// Invoke the bound functor using the invocation template provided at
6140 /// construction of this `Bind` object, substituting place-holders for
6141 /// arguments 1, 2, and 3 with the values of the specified arguments
6142 /// `p1`, `p2` and `p3` respectively. Return the result.
6143 ResultType operator()(P1 p1, P2 p2, P3 p3) const
6144 {
6145 typedef Bind_ArgTuple3<P1, P2, P3> ArgList;
6146 ArgList argList(p1, p2, p3);
6147 return invoke(argList);
6148 }
6149
6150 /// Invoke the bound functor using the invocation template provided at
6151 /// construction of this `Bind` object, substituting place-holders for
6152 /// arguments 1 - 4 with the values of the specified arguments `p1` -
6153 /// `p4` respectively. Return the result.
6154 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4) const
6155 {
6156 typedef Bind_ArgTuple4<P1, P2, P3, P4> ArgList;
6157 ArgList argList(p1, p2, p3, p4);
6158 return invoke(argList);
6159 }
6160
6161 /// Invoke the bound functor using the invocation template provided at
6162 /// construction of this `Bind` object, substituting place-holders for
6163 /// arguments 1 - 5 with the values of the specified arguments `p1` -
6164 /// `p5` respectively. Return the result.
6165 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const
6166 {
6167 typedef Bind_ArgTuple5<P1, P2, P3, P4, P5> ArgList;
6168 ArgList argList(p1, p2, p3, p4, p5);
6169 return invoke(argList);
6170 }
6171
6172 /// Invoke the bound functor using the invocation template provided at
6173 /// construction of this `Bind` object, substituting place-holders for
6174 /// arguments 1 - 6 with the values of the specified arguments `p1` -
6175 /// `p7` respectively. Return the result.
6176 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
6177 {
6178 typedef Bind_ArgTuple6<P1, P2, P3, P4, P5, P6> ArgList;
6179 ArgList argList(p1, p2, p3, p4, p5, p6);
6180 return invoke(argList);
6181 }
6182
6183 /// Invoke the bound functor using the invocation template provided at
6184 /// construction of this `Bind` object, substituting place-holders for
6185 /// arguments 1 - 7 with the values of the specified arguments `p1` -
6186 /// `p7` respectively. Return the result.
6187 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6188 P7 p7) const
6189 {
6190 typedef Bind_ArgTuple7<P1, P2, P3, P4, P5, P6, P7> ArgList;
6191 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
6192 return invoke(argList);
6193 }
6194
6195 /// Invoke the bound functor using the invocation template provided at
6196 /// construction of this `Bind` object, substituting place-holders for
6197 /// arguments 1 - 8 with the values of the specified arguments `p1` -
6198 /// `p8` respectively. Return the result.
6199 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6200 P7 p7, P8 p8) const
6201 {
6202 typedef Bind_ArgTuple8<P1, P2, P3, P4, P5, P6, P7, P8> ArgList;
6203 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
6204 return invoke(argList);
6205 }
6206
6207 /// Invoke the bound functor using the invocation template provided at
6208 /// construction of this `Bind` object, substituting place-holders for
6209 /// arguments 1 - 9 with the values of the specified arguments `p1` -
6210 /// `p9` respectively. Return the result.
6211 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6212 P7 p7, P8 p8, P9 p9) const
6213 {
6214 typedef Bind_ArgTuple9<P1, P2, P3, P4, P5, P6, P7, P8, P9> ArgList;
6215 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
6216 return invoke(argList);
6217 }
6218
6219 /// Invoke the bound functor using the invocation template provided at
6220 /// construction of this `Bind` object, substituting place-holders for
6221 /// arguments 1 - 10 with the values of the specified arguments `p1` -
6222 /// `p10` respectively. Return the result.
6223 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6224 P7 p7, P8 p8, P9 p9, P10 p10) const
6225 {
6226 typedef Bind_ArgTuple10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
6227 ArgList;
6228 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
6229 return invoke(argList);
6230 }
6231
6232 /// invoke the bound functor using the invocation template provided at
6233 /// construction of this @ref bdlf_bind object, substituting place-holders
6234 /// for arguments 1 - 11 with the values of the specified arguments `p1`
6235 /// - `p11` respectively. Return the result.
6236 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6237 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) const
6238 {
6239 typedef Bind_ArgTuple11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6240 P11> ArgList;
6241 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
6242 return invoke(argList);
6243 }
6244
6245 /// Invoke the bound functor using the invocation template provided at
6246 /// construction of this `Bind` object, substituting place-holders for
6247 /// arguments 1 - 12 with the values of the specified arguments `p1` -
6248 /// `p12` respectively. Return the result.
6249 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6250 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6251 P12 p12) const
6252 {
6253 typedef Bind_ArgTuple12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6254 P11, P12> ArgList;
6255 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
6256 return invoke(argList);
6257 }
6258
6259 /// Invoke the bound functor using the invocation template provided at
6260 /// construction of this `Bind` object, substituting place-holders for
6261 /// arguments 1 - 13 with the values of the specified arguments `p1` -
6262 /// `p13` respectively. Return the result.
6263 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6264 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6265 P12 p12, P13 p13) const
6266 {
6267 typedef Bind_ArgTuple13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6268 P11, P12, P13> ArgList;
6269 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
6270 p13);
6271 return invoke(argList);
6272 }
6273
6274 /// Invoke the bound functor using the invocation template provided at
6275 /// construction of this `Bind` object, substituting place-holders for
6276 /// arguments 1 - 14 with the values of the specified arguments `p1` -
6277 /// `p14` respectively. Return the result.
6278 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6279 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6280 P12 p12, P13 p13, P14 p14) const
6281 {
6282 typedef Bind_ArgTuple14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
6283 P12, P13, P14> ArgList;
6284 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
6285 p13, p14);
6286 return invoke(argList);
6287 }
6288};
6289
6290 // =======================
6291 // class Bind_ImplSelector
6292 // =======================
6293
6294/// This utility is used to select the best bind implementation for the
6295/// given function and invocation template. `Bind_ImplExplicit` is selected
6296/// if the binder is explicit, else `Bind_Impl` is selected. A binder is
6297/// explicit when:
6298///
6299/// 1. The function signature can be determined completely (return and
6300/// argument types, e.g., free or member function pointers).
6301/// 2. There are no duplicate references to the same placeholder nor any
6302/// nested `Bind` objects in the bound arguments.
6303/// 3. There are no ellipsis argument in the signature of the function.
6304template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6318
6319// Implementation note: The following three classes, 'Bind_FuncTraits',
6320// 'Bind_FuncTraitsImp', and 'Bind_FuncTraitsHasNoEllipsis' are presented in
6321// the reverse order to eliminate an AIX failure due to the order of templates,
6322// even if those have been forward-declared.
6323
6324 // ==================================
6325 // class Bind_FuncTraitsHasNoEllipsis
6326 // ==================================
6327
6328/// Determines whether a function type has the ellipsis as an argument.
6329/// This is needed for making the binder non-explicit in case of a function
6330/// pointer, reference, or member function pointer. By default, a function
6331/// does not take an ellipsis unless specialized below. This traits class
6332/// is used in the `Bind_FuncTraitsImp` below. Note that this meta function
6333/// is not supported on sun studio 8.
6334template <class t_FUNC>
6335struct Bind_FuncTraitsHasNoEllipsis {
6336
6337 enum {
6338 k_VAL = 1
6339 };
6340};
6341
6342// PARTIAL SPECIALIZATIONS
6343
6344/// Specialization for function pointers that return `t_RET` and accept one
6345/// argument which is an ellipsis.
6346template <class t_RET>
6347struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(...)> {
6348 enum { k_VAL = 0 };
6349};
6350
6351/// Specialization for function pointers that return `t_RET` and accept one
6352/// argument and an ellipsis.
6353template <class t_RET, class A1>
6354struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,...)> {
6355 enum { k_VAL = 0 };
6356};
6357
6358/// Specialization for function pointers that return `t_RET` and accept two
6359/// arguments and an ellipsis.
6360template <class t_RET, class A1, class A2>
6361struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,...)> {
6362 enum { k_VAL = 0 };
6363};
6364
6365/// Specialization for function pointers that return `t_RET` and accept
6366/// three arguments and an ellipsis.
6367template <class t_RET, class A1, class A2, class A3>
6368struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,...)> {
6369 enum { k_VAL = 0 };
6370};
6371
6372/// Specialization for function pointers that return `t_RET` and accept four
6373/// arguments and an ellipsis.
6374template <class t_RET, class A1, class A2, class A3, class A4>
6375struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,...)> {
6376 enum { k_VAL = 0 };
6377};
6378
6379/// Specialization for function pointers that return `t_RET` and accept five
6380/// arguments and an ellipsis.
6381template <class t_RET, class A1, class A2, class A3, class A4, class A5>
6382struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,...)> {
6383 enum { k_VAL = 0 };
6384};
6385
6386/// Specialization for function pointers that return `t_RET` and accept six
6387/// arguments and an ellipsis.
6388template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6389 class A6>
6390struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6,...)> {
6391 enum { k_VAL = 0 };
6392};
6393
6394/// Specialization for function pointers that return `t_RET` and accept
6395/// seven arguments and an ellipsis.
6396template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6397 class A6, class A7>
6398struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6, A7,...)> {
6399 enum { k_VAL = 0 };
6400};
6401
6402/// Specialization for function pointers that return `t_RET` and accept
6403/// eight arguments and an ellipsis.
6404template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6405 class A6, class A7, class A8>
6406struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6,A7,A8,...)> {
6407 enum { k_VAL = 0 };
6408};
6409
6410/// Specialization for function pointers that return `t_RET` and accept nine
6411/// arguments and an ellipsis.
6412template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6413 class A6, class A7, class A8, class A9>
6414struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6415 A1,A2,A3,A4,A5,A6,A7,A8,A9,...)> {
6416 enum { k_VAL = 0 };
6417};
6418
6419/// Specialization for function pointers that return `t_RET` and accept ten
6420/// arguments and an ellipsis.
6421template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6422 class A6, class A7, class A8, class A9, class A10>
6423struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6424 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,...)> {
6425 enum { k_VAL = 0 };
6426};
6427
6428/// Specialization for function pointers that return `t_RET` and accept
6429/// eleven arguments and an ellipsis.
6430template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6431 class A6, class A7, class A8, class A9, class A10, class A11>
6432struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6433 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,...)> {
6434 enum { k_VAL = 0 };
6435};
6436
6437/// Specialization for function pointers that return `t_RET` and accept
6438/// twelve arguments and an ellipsis.
6439template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6440 class A6, class A7, class A8, class A9, class A10, class A11,
6441 class A12>
6442struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6443 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,...)> {
6444 enum { k_VAL = 0 };
6445};
6446
6447/// Specialization for function pointers that return `t_RET` and accept
6448/// thirteen arguments and an ellipsis.
6449template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6450 class A6, class A7, class A8, class A9, class A10, class A11,
6451 class A12, class A13>
6452struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6453 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,...)> {
6454 enum { k_VAL = 0 };
6455};
6456
6457/// Specialization for function pointers that return `t_RET` and accept
6458/// fourteen arguments and an ellipsis.
6459template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6460 class A6, class A7, class A8, class A9, class A10, class A11,
6461 class A12, class A13, class A14>
6462struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6463 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14...)> {
6464 enum { k_VAL = 0 };
6465};
6466
6467 // ================================================
6468 // struct Bind_FuncTraitsImp_OneResultTypeOrAnother
6469 // ================================================
6470
6471/// Define the type variable `type` to be `t_FUNC::result_type` if that
6472/// exists and `t_FUNC::ResultType` otherwise. Additionally, for C++11 and
6473/// above, if `t_FUNC` has an `operator()` member (such as lambda
6474/// functions), define `type` to be the return type of that operator.
6475///
6476/// This `struct` is used by some, but not most, of the definitions of
6477/// `Bind_FuncTraitsImp`.
6478template <class t_FUNC>
6479struct Bind_FuncTraitsImp_OneResultTypeOrAnother {
6480
6481 private:
6482 // PRIVATE TYPES
6483
6484 /// This class declares a `type` member to be the same as the one
6485 /// `bslmf::ResultType` produces.
6486 template <class T, class = void>
6487 struct Result {
6488
6489 // PUBLIC TYPES
6490 typedef typename bslmf::ResultType<T>::type type;
6491 };
6492
6493#ifdef BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE
6494#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES
6495
6496 /// The general version of this class inherits from its specialization.
6497 template <class T>
6498 struct Return : public Return<decltype(&T::operator())> {
6499 };
6500
6501 /// The non-`const` specialized form of the `Return` class defines a
6502 /// `type` member as the return type of the member function parameter.
6503 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6504 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6505
6506 // PUBLIC TYPES
6507 typedef t_RET type;
6508 };
6509
6510 /// The `const` specialized form of the `Return` class inherits from
6511 /// the non-`const` specialization (above).
6512 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6513 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) const> :
6514 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6515 };
6516
6517#if defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES)
6518
6519 /// The non-`const` noexcept specialized form of the `Return` class
6520 /// inherits from the non-`const` non-`noexcept` specialization (above).
6521 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6522 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) noexcept> :
6523 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6524 };
6525
6526 /// The `const` noexcept specialized form of the `Return` class inherits
6527 /// from the non-`const` non-`noexcept` specialization (above).
6528 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6529 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) const noexcept> :
6530 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6531 };
6532
6533#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
6534
6535 /// This is a specialization of `Result` above. If the `T` parameter
6536 /// has a single unique `operator()` member, then `Result<T, void>`
6537 /// prefers this specialization over the general template. This class
6538 /// declares a `type` member as the return type of `T::operator()`.
6539 template <class T>
6540 struct Result<T, bsl::void_t<decltype(&T::operator())>> {
6541
6542 // PUBLIC TYPES
6543 typedef typename Return<T>::type type;
6544 };
6545
6546#endif // BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES
6547#endif // BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE
6548
6549 public:
6550 // TYPES
6551 typedef typename Result<t_FUNC>::type type;
6552};
6553
6554 // ===================
6555 // class FuncTraitsImp
6556 // ===================
6557
6558/// This `struct` provides a mechanism for inferring various traits of the
6559/// function object type `t_FUNC`. The return type is given by `t_RET`
6560/// unless it is `bslmf::Nil` in which case it is inferred from `t_FUNC`.
6561/// The last three parameters `IS_FUNCTION`, `IS_FUNCTION_POINTER` and
6562/// `IS_MEMBER_FUNCTION_POINTER` specify whether `t_FUNC` is a free function
6563/// type (either a reference-to-function or plain function type), a pointer
6564/// to function type, or a pointer to member function type, respectively.
6565///
6566/// Only specializations of this class should be used (given below). All
6567/// specializations define the types and enumerations documented in the
6568/// `Bind_FuncTraits` below.
6569template <class t_RET,
6570 class t_FUNC,
6571 int IS_FUNCTION,
6572 int IS_FUNCTION_POINTER,
6573 int IS_MEMBER_FUNCTION_POINTER>
6574struct Bind_FuncTraitsImp;
6575
6576// PARTIAL SPECIALIZATIONS
6577
6578/// Function traits for non-member function types (references or not, but
6579/// not pointers to function), with explicit return type specification.
6580template <class t_RET, class t_FUNC>
6581struct Bind_FuncTraitsImp<t_RET, t_FUNC, 1, 0, 0> {
6582
6583 // ENUMERATIONS
6584 enum {
6585 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC*>::k_VAL
6586 , k_IS_MEMBER_OFFSET = 0
6587 , k_HAS_POINTER_SEMANTICS = 0
6588 };
6589
6590 // PUBLIC TYPES
6591 typedef t_FUNC *Type;
6592 typedef t_FUNC *WrapperType;
6593 typedef t_RET ResultType;
6594 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ArgumentList
6595 FuncArgumentList;
6596};
6597
6598/// Function traits for non-member function pointers, with explicit return
6599/// type specification.
6600template <class t_RET, class t_FUNC>
6601struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 1, 0> {
6602
6603 // ENUMERATIONS
6604 enum {
6605 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC>::k_VAL
6606 , k_IS_MEMBER_OFFSET = 0
6607 , k_HAS_POINTER_SEMANTICS = 0
6608 };
6609
6610 // PUBLIC TYPES
6611 typedef t_FUNC Type;
6612 typedef t_FUNC WrapperType;
6613 typedef t_RET ResultType;
6614 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ArgumentList
6615 FuncArgumentList;
6616};
6617
6618/// Function traits for member function pointers, with explicit return type
6619/// specification.
6620template <class t_RET, class t_FUNC>
6621struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 0, 1> {
6622
6623 // ENUMERATIONS
6624 enum {
6625 k_IS_EXPLICIT = 1 // we do not support the ellipsis
6626 , k_IS_MEMBER_OFFSET = 1
6627 , k_HAS_POINTER_SEMANTICS = 0
6628 };
6629
6630 // PUBLIC TYPES
6631 typedef t_FUNC Type;
6632 typedef MemFn<t_FUNC> WrapperType;
6633 typedef t_RET ResultType;
6634 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ArgumentList
6635 FuncArgumentList;
6636};
6637
6638/// Function traits for function objects that are passed by value with
6639/// explicit return type specification.
6640template <class t_RET, class t_FUNC>
6641struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 0, 0> {
6642
6643 // ENUMERATIONS
6644 enum {
6645 k_IS_EXPLICIT = 0
6646 , k_HAS_POINTER_SEMANTICS = bslmf::HasPointerSemantics<t_FUNC>::value
6647 };
6648
6649 // PUBLIC TYPES
6650 typedef t_FUNC Type;
6651 typedef t_FUNC WrapperType;
6652 typedef t_RET ResultType;
6653};
6654
6655/// Function traits for objects passed by pointer with explicit return type.
6656template <class t_RET, class t_FUNC>
6657struct Bind_FuncTraitsImp<t_RET, t_FUNC *, 0, 0, 0> {
6658
6659 // ENUMERATIONS
6660 enum {
6661 k_IS_EXPLICIT = 0
6662 , k_HAS_POINTER_SEMANTICS = 1
6663 };
6664
6665 // PUBLIC TYPES
6666 typedef t_FUNC Type;
6667 typedef t_FUNC *WrapperType;
6668 typedef t_RET ResultType;
6669};
6670
6671/// Function traits for non-member function types (references or not, but
6672/// not pointers to function). The result type is determined from the
6673/// function pointer traits.
6674template <class t_FUNC>
6675struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 1, 0, 0> {
6676
6677 // ENUMERATIONS
6678 enum {
6679 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC*>::k_VAL
6680 , k_IS_MEMBER_OFFSET = 0
6681 , k_HAS_POINTER_SEMANTICS = 0
6682 };
6683
6684 // PUBLIC TYPES
6685 typedef t_FUNC Type;
6686 typedef t_FUNC *WrapperType;
6687 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ResultType
6688 ResultType;
6689 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ArgumentList
6690 FuncArgumentList;
6691};
6692
6693/// Function traits for non-member function pointers. The result type is
6694/// determined from the function pointer traits.
6695template <class t_FUNC>
6696struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 1, 0> {
6697
6698 // ENUMERATIONS
6699 enum {
6700 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC>::k_VAL
6701 , k_IS_MEMBER_OFFSET = 0
6702 , k_HAS_POINTER_SEMANTICS = 0
6703 };
6704
6705 // PUBLIC TYPES
6706 typedef t_FUNC Type;
6707 typedef t_FUNC WrapperType;
6708 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ResultType
6709 ResultType;
6710 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ArgumentList
6711 FuncArgumentList;
6712};
6713
6714/// Function traits for member function pointers. The result type is
6715/// determined from the function pointer traits.
6716template <class t_FUNC>
6717struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 0, 1> {
6718
6719 // ENUMERATIONS
6720 enum {
6721 k_IS_EXPLICIT = 1 // we do not support the ellipsis
6722 , k_IS_MEMBER_OFFSET = 1
6723 , k_HAS_POINTER_SEMANTICS = 0
6724 };
6725
6726 // PUBLIC TYPES
6727 typedef t_FUNC Type;
6728 typedef MemFn<t_FUNC> WrapperType;
6729 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ResultType
6730 ResultType;
6731 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ArgumentList
6732 FuncArgumentList;
6733};
6734
6735/// Function traits for function objects that are passed by value without
6736/// explicit result type specification. The result type is determined by
6737/// either `typename t_FUNC::result_type` or `typename t_FUNC::ResultType`,
6738/// with the former taking precedence if both are defined.
6739template <class t_FUNC>
6740struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 0, 0> {
6741
6742 // ENUMERATIONS
6743 enum {
6744 k_IS_EXPLICIT = 0
6745 , k_HAS_POINTER_SEMANTICS = bslmf::HasPointerSemantics<t_FUNC>::value
6746 };
6747
6748 // PUBLIC TYPES
6749 typedef t_FUNC Type;
6750 typedef t_FUNC WrapperType;
6751 typedef typename Bind_FuncTraitsImp_OneResultTypeOrAnother<t_FUNC>::type
6752 ResultType;
6753};
6754
6755/// Function traits for bsl::function objects that are passed by value. The
6756/// result type is determined by `bsl::function<PROTO>::result_type`.
6757template <class PROTO>
6758struct Bind_FuncTraitsImp<bslmf::Nil,bsl::function<PROTO>,0,0,0> {
6759
6760 // ENUMERATIONS
6761 enum {
6762 k_IS_EXPLICIT = 0
6763 , k_HAS_POINTER_SEMANTICS = 0
6764 };
6765
6766 // PUBLIC TYPES
6767 typedef bsl::function<PROTO> Type;
6768 typedef bsl::function<PROTO> WrapperType;
6769 typedef typename bsl::function<PROTO>::result_type ResultType;
6770};
6771
6772/// Function traits for objects passed by pointer with no explicit return
6773/// type. The object is assumed to have a `result_type` or `ResultType`
6774/// type definition, with the former taking precedence if both are defined.
6775template <class t_FUNC>
6776struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC *, 0, 0, 0> {
6777
6778 // ENUMERATIONS
6779 enum {
6780 k_IS_EXPLICIT = 0
6781 , k_HAS_POINTER_SEMANTICS = 1
6782 };
6783
6784 // PUBLIC TYPES
6785 typedef t_FUNC Type;
6786 typedef t_FUNC *WrapperType;
6787 typedef typename Bind_FuncTraitsImp_OneResultTypeOrAnother<t_FUNC>::type
6788 ResultType;
6789};
6790
6791/// Function traits for objects passed by pointer with no explicit return
6792/// type. The object is assumed to have a `ResultType` type definition.
6793template <class PROTO>
6794struct Bind_FuncTraitsImp<bslmf::Nil,bsl::function<PROTO>*,0,0,0> {
6795
6796 // ENUMERATIONS
6797 enum {
6798 k_IS_EXPLICIT = 0
6799 , k_HAS_POINTER_SEMANTICS = 1
6800 };
6801
6802 // PUBLIC TYPES
6803 typedef bsl::function<PROTO> Type;
6804 typedef bsl::function<PROTO>* WrapperType;
6805 typedef typename bsl::function<PROTO>::result_type ResultType;
6806};
6807
6808 // ================
6809 // class FuncTraits
6810 // ================
6811
6812/// This `struct` provides various traits of the functor type `t_FUNC`
6813/// documented below. If `t_RET` is `bslmf::Nil`, then the return type is
6814/// inferred by using either `bslmf::FunctionPointerTraits`,
6815/// `bslmf::MemberFunctionPointerTraits`, or `typename t_FUNC::result_type`
6816/// as appropriate.
6817/// @code
6818/// // ENUMERATIONS
6819/// enum {
6820/// k_IS_EXPLICIT // An invocable object is explicit if ...
6821/// // (see 'Bind_ImplExplicit')
6822///
6823/// , k_IS_MEMBER_OFFSET // Offset for calculating evaluation of
6824/// // placeholder values at invocation. Will
6825/// // be 1 for member function pointers, and 0
6826/// // otherwise.
6827///
6828/// , k_HAS_POINTER_SEMANTICS // Whether the bound functor should be
6829/// // invoked by address or by value.
6830/// };
6831///
6832/// // PUBLIC TYPES
6833/// typedef ... Type; // type of the bound function object
6834/// typedef ... WrapperType; // type of the bound object wrapper
6835/// typedef ... ResultType; // return type of the bound function
6836/// // object
6837/// typedef ... FuncArgumentList; // signature of the bound function object,
6838/// // a 'bslmf::TypeList'
6839/// @endcode
6840/// The table below gives a summary of the values set by the specializations
6841/// of `Bind_FuncTraitsImp`, where `X` represents a class type and `T`
6842/// represents the return type (given explicitly by `t_RET`, or deduced by
6843/// the nested `ResultType` of `X` or of the appropriate traits when `t_RET`
6844/// is specified as `bslmf::Nil`).
6845///
6846/// t_RET t_FUNC IS _FN IS_FNP IS_MEM IS_EXPLICIT OFFSET PTR_SEM
6847/// --------- ------- ------ ------ ------ ----------- ------ -------
6848/// T T(...) 1 0 0 1^ 0 0
6849/// T T(*)(...) 0 1 0 1^ 0 0
6850/// T T(X::*)(...) 0 0 1 1 1 0
6851/// T X 0 0 0 0 A B
6852/// T X* 0 0 0 0 A 1
6853/// bslmf::Nil T(...) 1 0 0 1^ 0 0
6854/// bslmf::Nil T(*)(..) 0 1 0 1^ 0 0
6855/// bslmf::Nil T(X::*)(...) 0 0 1 1 1 0
6856/// bslmf::Nil X 0 0 0 0 A B
6857/// bslmf::Nil X* 0 0 0 0 A 1
6858///
6859/// A: undefined, since unused by `Bin_Impl`, which is used for
6860/// non-explicit binders.
6861/// B: as determined by the value of
6862/// `bslalg_TypeTraits<X, bslalg::TypeTraitHasPointerSemantics>`.
6863/// ^: in the (rare) case where the `t_FUNC` type has an ellipsis argument,
6864/// the k_IS_EXPLICIT will be set to 0. Note that we *only* support the
6865/// ellipsis in non-member functions.
6866template <class t_RET, class t_FUNC>
6867struct Bind_FuncTraits
6868 : Bind_FuncTraitsImp<t_RET,
6869 t_FUNC,
6870 (int)bslmf::IsFunctionPointer<t_FUNC*>::value,
6871 (int)bslmf::IsFunctionPointer<t_FUNC>::value,
6872 (int)bslmf::IsMemberFunctionPointer<t_FUNC>::value>
6873{
6874};
6875
6876 // ==========================
6877 // class Bind_PlaceHolderMask
6878 // ==========================
6879
6880/// This template, passed the type of one of the bound arguments to a
6881/// function object, yields:
6882/// * If the specified `t_BOUND_TYPE` is a place holder, a mask with the
6883/// bit at the index of the place holder set.
6884/// * If the specified `t_BOUND_TYPE` is a `Bind` or `BindWrapper`, a mask
6885/// with bit 24 set.
6886/// * Zero otherwise.
6887template <class t_BOUND_TYPE>
6888struct Bind_PlaceHolderMask;
6889
6890template <class t_BOUND_TYPE>
6891struct Bind_PlaceHolderMask {
6892 static const int k_VAL = 0;
6893};
6894
6895template <int INDEX>
6896struct Bind_PlaceHolderMask<PlaceHolder<INDEX> > {
6897 static const int k_VAL = 1 << INDEX;
6898};
6899
6900/// This specialization of `Bind_PlaceHolderMask` defines a mask for a
6901/// `Bind` object passed recursively as a bound argument. The value is not
6902/// important, as long as it is out of range. Note that `1 << 30` would be
6903/// equally valid, but can lead to an overflow in constant expression with
6904/// `Bind_CalcParameterMask::k_PARAM_MASK2` below (obtained by adding the
6905/// masks of the bound arguments together) when there are more than 3 nested
6906/// binders (this is unfortunately an error with the GNU compiler).
6907template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6908struct Bind_PlaceHolderMask<Bind<t_RET, t_FUNC, t_BOUND_TUPLE> > {
6909
6910 static const int k_VAL = 1 << 24;
6911};
6912
6913/// This specialization of `Bind_PlaceHolderMask` defines a mask for a
6914/// `BindWrapper` object passed recursively as a bound argument. The value
6915/// is not important, as long as it is out of range. This makes sure that a
6916/// binder with a nested `BindWrapper` object is treated as non-explicit, in
6917/// the same way as if the nested binder was of type `Bind`.
6918template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6919struct Bind_PlaceHolderMask<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE> > {
6920
6921 static const int k_VAL = 1 << 24;
6922};
6923
6924
6925 // ===========================
6926 // class Bind_PlaceHolderIndex
6927 // ===========================
6928
6929/// This template, passed the type of one of the bound arguments to a
6930/// function object, yields:
6931/// * if the specified `t_BOUND_TYPE` is a place holder, the index of the
6932/// place holder object
6933/// * zero otherwise
6934template <class t_BOUND_TYPE>
6935struct Bind_PlaceHolderIndex;
6936
6937/// This template is used to calculate a compound numeric value of which
6938/// parameters must be forwarded to a bound functor. The general definition
6939/// defines a numeric value of zero.
6940template <class t_BOUND_TYPE>
6941struct Bind_PlaceHolderIndex {
6942
6943 enum {
6944 k_VAL = 0
6945 };
6946};
6947
6948/// This specialization of `Bind_PlaceHolderIndex` defines a numeric value
6949/// for the place-holder at the specified `INDEX` of the bound arguments.
6950template <int INDEX>
6951struct Bind_PlaceHolderIndex<PlaceHolder<INDEX> > {
6952
6953 enum {
6954 k_VAL = INDEX
6955 };
6956};
6957
6958 // =============================
6959 // class Bind_MemFnObjectWrapper
6960 // =============================
6961
6962/// This local class is used to wrap an object used to invoke a member
6963/// functions bound to a `Bind` binder. In explicit binding, the argument
6964/// types of operator() are determined during `Bind` instantiation. If a
6965/// member function is bound to the binder, and the object to invoke the
6966/// member function on is passed as an invocation argument (instead of a
6967/// bound argument), the exact type of the object - whether it is a pointer
6968/// or reference - cannot be determined based on the method signature. This
6969/// wrapper serve as an intermediate type to wrap around the object pointer
6970/// or reference. This class is declared to have pointer semantics, such
6971/// that `MemFn` will properly dereference the object to invoke the member
6972/// function.
6973///
6974/// See @ref bdlf_bind
6975template <class TYPE>
6976class Bind_MemFnObjectWrapper {
6977
6978 // DATA
6979 TYPE *d_object; // held, not owned
6980
6981 public:
6982 // TRAITS
6983 BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper,
6984 bslmf::HasPointerSemantics);
6985 BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper,
6986 bslmf::IsBitwiseMoveable);
6987
6988 // CREATORS
6989 Bind_MemFnObjectWrapper(TYPE *object) // IMPLICIT
6990 : d_object(object) {}
6991 Bind_MemFnObjectWrapper(TYPE& object) // IMPLICIT
6992 : d_object(&object) {}
6993 // Implicitly converts the specified object (of parameterized 'TYPE')
6994 // to a 'Bind_MemFnObjectWrapper'.
6995
6996 // ACCESSORS
6997
6998 /// Returns a reference to the object (of parameterized `TYPE`) pointed
6999 /// to by this `Bind_MemFnObjectWrapper`.
7000 TYPE& operator*() const { return *d_object; }
7001
7002};
7003
7004 // =======================
7005 // class Bind_MapParameter
7006 // =======================
7007
7008/// This meta-function is used to select the type at `t_OFFSET` positions of
7009/// the `t_INDEX` position in an argument list type `t_FUNC_ARGS`, which is
7010/// of type `bslmf::TypeList` denoting the arguments of `t_FUNC`. Note that
7011/// this class is used by `Bind_ImplExplicit`.
7012template <class t_FUNC, class t_FUNC_ARGS, int t_INDEX, int t_IS_MEMBER_OFFSET>
7013struct Bind_MapParameter {
7014
7015 // PUBLIC TYPES
7016 typedef typename
7017 bslmf::ForwardingType<typename bslmf::TypeListTypeOf<
7018 t_INDEX - t_IS_MEMBER_OFFSET,
7019 t_FUNC_ARGS,
7020 const bslmf::MatchAnyType&>::TypeOrDefault>::Type Type;
7021};
7022
7023/// This partial specialization of `Bind_MapParameter` is intended for use
7024/// with member functions. The `Bind_MemFnObjectWrapper` will properly wrap
7025/// around the class object reference or pointer, such that either can be
7026/// used to invoke the member function.
7027template <class t_FUNC, class t_FUNC_ARGS>
7028struct Bind_MapParameter<t_FUNC, t_FUNC_ARGS, 1, 1> {
7029
7030 // PUBLIC TYPES
7031 typedef bslmf::MemberFunctionPointerTraits<t_FUNC> Traits;
7032 typedef typename Traits::ClassType ObjectType;
7033 typedef typename bslmf::ForwardingType<
7034 const Bind_MemFnObjectWrapper<ObjectType>& >::Type Type;
7035};
7036
7037/// This partial specialization of `Bind_MapParameter` does not specify any
7038/// type in the `t_FUNC_ARGS` list. It is used for parameters that should
7039/// be ignored.
7040template <class t_FUNC, class t_FUNC_ARGS, int t_IS_MEMBER_OFFSET>
7041struct Bind_MapParameter<t_FUNC, t_FUNC_ARGS, 0, t_IS_MEMBER_OFFSET> {
7042
7043 // PUBLIC TYPES
7044 typedef const bslmf::MatchAnyType& Type;
7045};
7046} // close package namespace
7047
7048 // ==================================
7049 // class bdlf::Bind_CalcParameterMask
7050 // ==================================
7051
7052// The following macro is used to compute the index of place holders within a
7053// parameter list and its corresponding mapping to the place holder values.
7054// For example:
7055//..
7056// bdlf::BindUtil::bind(&foo, _1, "abc", _2, _5);
7057//..
7058// Will have the following values:
7059//..
7060// bind time index invocation time index
7061// --------------- ---------------------
7062// k_PARAM1 1
7063// k_PARAM2 0
7064// k_PARAM3 2
7065// k_PARAM4 5
7066//..
7067// The 'BDLF_BIND_PARAMINDEX' macro will compute the following:
7068//..
7069// BDLF_BIND_PARAMINDEX(1) = 1
7070// BDLF_BIND_PARAMINDEX(2) = 3
7071// BDLF_BIND_PARAMINDEX(3) = 0
7072// BDLF_BIND_PARAMINDEX(4) = 0
7073// BDLF_BIND_PARAMINDEX(5) = 4
7074//..
7075// The index is used to deduce the appropriate invocation argument type for the
7076// explicit binder.
7077
7078#define BDLF_BIND_PARAMINDEX(N) ( \
7079(k_PARAM1 == N ? 1 : 0) + \
7080(k_PARAM2 == N ? 2 : 0) + \
7081(k_PARAM3 == N ? 3 : 0) + \
7082(k_PARAM4 == N ? 4 : 0) + \
7083(k_PARAM5 == N ? 5 : 0) + \
7084(k_PARAM6 == N ? 6 : 0) + \
7085(k_PARAM7 == N ? 7 : 0) + \
7086(k_PARAM8 == N ? 8 : 0) + \
7087(k_PARAM9 == N ? 9 : 0) + \
7088(k_PARAM10 == N ? 10 : 0) + \
7089(k_PARAM11 == N ? 11 : 0) + \
7090(k_PARAM12 == N ? 12 : 0) + \
7091(k_PARAM13 == N ? 13 : 0) + \
7092(k_PARAM14 == N ? 14 : 0))
7093
7094namespace bdlf {
7095/// This meta-function is used to calculate a mask that indicates which
7096/// parameters in `t_BOUND_TUPLE` are place-holders and which ones are
7097/// literal values. It is used by `Bind_ImplExplicit`.
7098template <class t_BOUND_TUPLE>
7099struct Bind_CalcParameterMask {
7100
7101 typedef typename t_BOUND_TUPLE::template TypeOf< 1>::TypeOrDefault Type1;
7102 typedef typename t_BOUND_TUPLE::template TypeOf< 2>::TypeOrDefault Type2;
7103 typedef typename t_BOUND_TUPLE::template TypeOf< 3>::TypeOrDefault Type3;
7104 typedef typename t_BOUND_TUPLE::template TypeOf< 4>::TypeOrDefault Type4;
7105 typedef typename t_BOUND_TUPLE::template TypeOf< 5>::TypeOrDefault Type5;
7106 typedef typename t_BOUND_TUPLE::template TypeOf< 6>::TypeOrDefault Type6;
7107 typedef typename t_BOUND_TUPLE::template TypeOf< 7>::TypeOrDefault Type7;
7108 typedef typename t_BOUND_TUPLE::template TypeOf< 8>::TypeOrDefault Type8;
7109 typedef typename t_BOUND_TUPLE::template TypeOf< 9>::TypeOrDefault Type9;
7110 typedef typename t_BOUND_TUPLE::template TypeOf<10>::TypeOrDefault Type10;
7111 typedef typename t_BOUND_TUPLE::template TypeOf<11>::TypeOrDefault Type11;
7112 typedef typename t_BOUND_TUPLE::template TypeOf<12>::TypeOrDefault Type12;
7113 typedef typename t_BOUND_TUPLE::template TypeOf<13>::TypeOrDefault Type13;
7114 typedef typename t_BOUND_TUPLE::template TypeOf<14>::TypeOrDefault Type14;
7115
7116 enum {
7117 k_PARAM1 = Bind_PlaceHolderIndex<Type1 >::k_VAL
7118 , k_PARAM2 = Bind_PlaceHolderIndex<Type2 >::k_VAL
7119 , k_PARAM3 = Bind_PlaceHolderIndex<Type3 >::k_VAL
7120 , k_PARAM4 = Bind_PlaceHolderIndex<Type4 >::k_VAL
7121 , k_PARAM5 = Bind_PlaceHolderIndex<Type5 >::k_VAL
7122 , k_PARAM6 = Bind_PlaceHolderIndex<Type6 >::k_VAL
7123 , k_PARAM7 = Bind_PlaceHolderIndex<Type7 >::k_VAL
7124 , k_PARAM8 = Bind_PlaceHolderIndex<Type8 >::k_VAL
7125 , k_PARAM9 = Bind_PlaceHolderIndex<Type9 >::k_VAL
7126 , k_PARAM10 = Bind_PlaceHolderIndex<Type10>::k_VAL
7127 , k_PARAM11 = Bind_PlaceHolderIndex<Type11>::k_VAL
7128 , k_PARAM12 = Bind_PlaceHolderIndex<Type12>::k_VAL
7129 , k_PARAM13 = Bind_PlaceHolderIndex<Type13>::k_VAL
7130 , k_PARAM14 = Bind_PlaceHolderIndex<Type14>::k_VAL
7131 // Individual place-holder indices. For each type that is a valid
7132 // place-holder, 'PARAM<N>' will be set to the index of the
7133 // corresponding argument. For non-place-holder types, 'PARAM<N>' will
7134 // be 0. For nested 'Bind' types, the out-of-range value 31 will be
7135 // used.
7136
7137 , k_PARAM_MASK = +Bind_PlaceHolderMask<Type1 >::k_VAL |
7138 +Bind_PlaceHolderMask<Type2 >::k_VAL |
7139 +Bind_PlaceHolderMask<Type3 >::k_VAL |
7140 +Bind_PlaceHolderMask<Type4 >::k_VAL |
7141 +Bind_PlaceHolderMask<Type5 >::k_VAL |
7142 +Bind_PlaceHolderMask<Type6 >::k_VAL |
7143 +Bind_PlaceHolderMask<Type7 >::k_VAL |
7144 +Bind_PlaceHolderMask<Type8 >::k_VAL |
7145 +Bind_PlaceHolderMask<Type9 >::k_VAL |
7146 +Bind_PlaceHolderMask<Type10>::k_VAL |
7147 +Bind_PlaceHolderMask<Type11>::k_VAL |
7148 +Bind_PlaceHolderMask<Type12>::k_VAL |
7149 +Bind_PlaceHolderMask<Type13>::k_VAL |
7150 +Bind_PlaceHolderMask<Type14>::k_VAL
7151 // Mask of which parameters are place-holders.
7152
7153 , k_PARAM_MASK2 = +Bind_PlaceHolderMask<Type1 >::k_VAL +
7154 +Bind_PlaceHolderMask<Type2 >::k_VAL +
7155 +Bind_PlaceHolderMask<Type3 >::k_VAL +
7156 +Bind_PlaceHolderMask<Type4 >::k_VAL +
7157 +Bind_PlaceHolderMask<Type5 >::k_VAL +
7158 +Bind_PlaceHolderMask<Type6 >::k_VAL +
7159 +Bind_PlaceHolderMask<Type7 >::k_VAL +
7160 +Bind_PlaceHolderMask<Type8 >::k_VAL +
7161 +Bind_PlaceHolderMask<Type9 >::k_VAL +
7162 +Bind_PlaceHolderMask<Type10>::k_VAL +
7163 +Bind_PlaceHolderMask<Type11>::k_VAL +
7164 +Bind_PlaceHolderMask<Type12>::k_VAL +
7165 +Bind_PlaceHolderMask<Type13>::k_VAL +
7166 +Bind_PlaceHolderMask<Type14>::k_VAL
7167 // Mask of which parameters are place-holder calculated by addition
7168 // rather the by ORing. If the given place-holder is used for multiple
7169 // arguments, the result of mask will be different from the ORed value
7170 // above.
7171
7172 , k_IS_EXPLICIT = (k_PARAM_MASK == k_PARAM_MASK2 ?
7173 (k_PARAM_MASK < (1<<15) ? 1 : 0) : 0)
7174 // Indicates if the types defined in 't_BOUND_TUPLE' are explicit. The
7175 // t_BOUND_TUPLE is said to be explicit if there are no duplicate
7176 // references to the same place-holder, and if there is no nested
7177 // 'Bind' objects. Note that even if 't_BOUND_TUPLE' is explicit, the
7178 // binding may still not be explicit (e.g., for function objects that
7179 // could have multiple signatures, or for functions that take an
7180 // ellipsis). See the documentation for this component for more
7181 // information.
7182
7183 , k_PARAMINDEX1 = BDLF_BIND_PARAMINDEX( 1)
7184 , k_PARAMINDEX2 = BDLF_BIND_PARAMINDEX( 2)
7185 , k_PARAMINDEX3 = BDLF_BIND_PARAMINDEX( 3)
7186 , k_PARAMINDEX4 = BDLF_BIND_PARAMINDEX( 4)
7187 , k_PARAMINDEX5 = BDLF_BIND_PARAMINDEX( 5)
7188 , k_PARAMINDEX6 = BDLF_BIND_PARAMINDEX( 6)
7189 , k_PARAMINDEX7 = BDLF_BIND_PARAMINDEX( 7)
7190 , k_PARAMINDEX8 = BDLF_BIND_PARAMINDEX( 8)
7191 , k_PARAMINDEX9 = BDLF_BIND_PARAMINDEX( 9)
7192 , k_PARAMINDEX10 = BDLF_BIND_PARAMINDEX(10)
7193 , k_PARAMINDEX11 = BDLF_BIND_PARAMINDEX(11)
7194 , k_PARAMINDEX12 = BDLF_BIND_PARAMINDEX(12)
7195 , k_PARAMINDEX13 = BDLF_BIND_PARAMINDEX(13)
7196 , k_PARAMINDEX14 = BDLF_BIND_PARAMINDEX(14)
7197 };
7198};
7199} // close package namespace
7200
7201#undef BDLF_BIND_PARAMINDEX
7202
7203namespace bdlf {
7204
7205 // ======================
7206 // class Bind_BoundTuple*
7207 // ======================
7208
7209/// This `struct` stores a list of two arguments. It does *not* use the
7210/// const-forwarding type of its argument, unlike `Bind_ArgTuple2` which
7211/// applies that optimization to avoid unnecessary copying.
7212template <class A1, class A2>
7213struct Bind_BoundTuple2 : bslmf::TypeList2<A1,A2>
7214{
7215
7216 // TRAITS
7217 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7218 Bind_BoundTuple2, bslmf::IsBitwiseMoveable,
7219 bslmf::IsBitwiseMoveable<A1>::value &&
7220 bslmf::IsBitwiseMoveable<A2>::value);
7221
7222 // INSTANCE DATA
7223 Bind_BoundTupleValue<A1> d_a1;
7224 Bind_BoundTupleValue<A2> d_a2;
7225
7226 // CREATORS
7227 Bind_BoundTuple2(const Bind_BoundTuple2<A1,A2>& orig,
7228 bslma::Allocator *allocator = 0)
7229 : d_a1(orig.d_a1, allocator)
7230 , d_a2(orig.d_a2, allocator)
7231 {
7232 }
7233
7234 Bind_BoundTuple2(
7235 bslmf::MovableRef<Bind_BoundTuple2<A1,A2> > orig,
7236 bslma::Allocator *allocator = 0)
7237 : d_a1(bslmf::MovableRefUtil::move(
7238 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7239 , d_a2(bslmf::MovableRefUtil::move(
7240 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7241 {
7242 }
7243
7244 Bind_BoundTuple2(A1 const& a1,
7245 A2 const& a2,
7246 bslma::Allocator *allocator = 0)
7247 : d_a1(a1, allocator)
7248 , d_a2(a2, allocator)
7249 {
7250 }
7251
7252 Bind_BoundTuple2(bslmf::MovableRef<A1> a1,
7253 bslmf::MovableRef<A2> a2,
7254 bslma::Allocator *allocator = 0)
7255 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7256 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7257 {
7258 }
7259};
7260
7261/// This `struct` stores a list of three arguments. It does *not* use the
7262/// const-forwarding type of its arguments, unlike `Bind_ArgTuple3` which
7263/// applies that optimization to avoid unnecessary copying.
7264template <class A1, class A2, class A3>
7265struct Bind_BoundTuple3 : bslmf::TypeList3<A1,A2,A3>
7266{
7267
7268 // TRAITS
7269 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7270 Bind_BoundTuple3, bslmf::IsBitwiseMoveable,
7271 bslmf::IsBitwiseMoveable<A1>::value &&
7272 bslmf::IsBitwiseMoveable<A2>::value &&
7273 bslmf::IsBitwiseMoveable<A3>::value);
7274
7275 // INSTANCE DATA
7276 Bind_BoundTupleValue<A1> d_a1;
7277 Bind_BoundTupleValue<A2> d_a2;
7278 Bind_BoundTupleValue<A3> d_a3;
7279
7280 // CREATORS
7281 Bind_BoundTuple3(const Bind_BoundTuple3<A1,A2,A3>& orig,
7282 bslma::Allocator *allocator = 0)
7283 : d_a1(orig.d_a1,allocator)
7284 , d_a2(orig.d_a2,allocator)
7285 , d_a3(orig.d_a3,allocator)
7286 {
7287 }
7288
7289 Bind_BoundTuple3(
7290 bslmf::MovableRef<Bind_BoundTuple3<A1,A2,A3> > orig,
7291 bslma::Allocator *allocator = 0)
7292 : d_a1(bslmf::MovableRefUtil::move(
7293 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7294 , d_a2(bslmf::MovableRefUtil::move(
7295 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7296 , d_a3(bslmf::MovableRefUtil::move(
7297 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7298 {
7299 }
7300
7301 Bind_BoundTuple3(A1 const& a1,
7302 A2 const& a2,
7303 A3 const& a3,
7304 bslma::Allocator *allocator = 0)
7305 : d_a1(a1,allocator)
7306 , d_a2(a2,allocator)
7307 , d_a3(a3,allocator)
7308 {
7309 }
7310
7311 Bind_BoundTuple3(bslmf::MovableRef<A1> a1,
7312 bslmf::MovableRef<A2> a2,
7313 bslmf::MovableRef<A3> a3,
7314 bslma::Allocator *allocator = 0)
7315 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7316 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7317 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7318 {
7319 }
7320};
7321
7322/// This `struct` stores a list of four arguments. It does *not* use the
7323/// const-forwarding type of its arguments, unlike `Bind_ArgTuple4` which
7324/// applies that optimization to avoid unnecessary copying.
7325template <class A1, class A2, class A3, class A4>
7326struct Bind_BoundTuple4 : bslmf::TypeList4<A1,A2,A3,A4>
7327{
7328
7329 // TRAITS
7330 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7331 Bind_BoundTuple4, bslmf::IsBitwiseMoveable,
7332 bslmf::IsBitwiseMoveable<A1>::value &&
7333 bslmf::IsBitwiseMoveable<A2>::value &&
7334 bslmf::IsBitwiseMoveable<A3>::value &&
7335 bslmf::IsBitwiseMoveable<A4>::value);
7336
7337 // INSTANCE DATA
7338 Bind_BoundTupleValue<A1> d_a1;
7339 Bind_BoundTupleValue<A2> d_a2;
7340 Bind_BoundTupleValue<A3> d_a3;
7341 Bind_BoundTupleValue<A4> d_a4;
7342
7343 // CREATORS
7344 Bind_BoundTuple4(const Bind_BoundTuple4<A1,A2,A3,A4>& orig,
7345 bslma::Allocator *allocator = 0)
7346 : d_a1(orig.d_a1,allocator)
7347 , d_a2(orig.d_a2,allocator)
7348 , d_a3(orig.d_a3,allocator)
7349 , d_a4(orig.d_a4,allocator)
7350 {
7351 }
7352
7353 Bind_BoundTuple4(
7354 bslmf::MovableRef<Bind_BoundTuple4<A1,A2,A3,A4> > orig,
7355 bslma::Allocator *allocator = 0)
7356 : d_a1(bslmf::MovableRefUtil::move(
7357 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7358 , d_a2(bslmf::MovableRefUtil::move(
7359 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7360 , d_a3(bslmf::MovableRefUtil::move(
7361 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7362 , d_a4(bslmf::MovableRefUtil::move(
7363 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7364 {
7365 }
7366
7367 Bind_BoundTuple4(A1 const& a1,
7368 A2 const& a2,
7369 A3 const& a3,
7370 A4 const& a4,
7371 bslma::Allocator *allocator = 0)
7372 : d_a1(a1,allocator)
7373 , d_a2(a2,allocator)
7374 , d_a3(a3,allocator)
7375 , d_a4(a4,allocator)
7376 {
7377 }
7378
7379 Bind_BoundTuple4(bslmf::MovableRef<A1> a1,
7380 bslmf::MovableRef<A2> a2,
7381 bslmf::MovableRef<A3> a3,
7382 bslmf::MovableRef<A4> a4,
7383 bslma::Allocator *allocator = 0)
7384 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7385 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7386 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7387 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7388 {
7389 }
7390};
7391
7392/// This `struct` stores a list of five arguments. It does *not* use the
7393/// const-forwarding type of its arguments, unlike `Bind_ArgTuple5` which
7394/// applies that optimization to avoid unnecessary copying.
7395template <class A1, class A2, class A3, class A4, class A5>
7396struct Bind_BoundTuple5 : bslmf::TypeList5<A1,A2,A3,A4,A5>
7397{
7398
7399 // TRAITS
7400 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7401 Bind_BoundTuple5, bslmf::IsBitwiseMoveable,
7402 bslmf::IsBitwiseMoveable<A1>::value &&
7403 bslmf::IsBitwiseMoveable<A2>::value &&
7404 bslmf::IsBitwiseMoveable<A3>::value &&
7405 bslmf::IsBitwiseMoveable<A4>::value &&
7406 bslmf::IsBitwiseMoveable<A5>::value);
7407
7408 // INSTANCE DATA
7409 Bind_BoundTupleValue<A1> d_a1;
7410 Bind_BoundTupleValue<A2> d_a2;
7411 Bind_BoundTupleValue<A3> d_a3;
7412 Bind_BoundTupleValue<A4> d_a4;
7413 Bind_BoundTupleValue<A5> d_a5;
7414
7415 // CREATORS
7416 Bind_BoundTuple5(const Bind_BoundTuple5<A1,A2,A3,A4,A5>& orig,
7417 bslma::Allocator *allocator = 0)
7418 : d_a1(orig.d_a1,allocator)
7419 , d_a2(orig.d_a2,allocator)
7420 , d_a3(orig.d_a3,allocator)
7421 , d_a4(orig.d_a4,allocator)
7422 , d_a5(orig.d_a5,allocator)
7423 {
7424 }
7425
7426 Bind_BoundTuple5(
7427 bslmf::MovableRef<Bind_BoundTuple5<A1,A2,A3,A4,A5> > orig,
7428 bslma::Allocator *allocator = 0)
7429 : d_a1(bslmf::MovableRefUtil::move(
7430 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7431 , d_a2(bslmf::MovableRefUtil::move(
7432 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7433 , d_a3(bslmf::MovableRefUtil::move(
7434 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7435 , d_a4(bslmf::MovableRefUtil::move(
7436 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7437 , d_a5(bslmf::MovableRefUtil::move(
7438 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7439 {
7440 }
7441
7442 Bind_BoundTuple5(A1 const& a1,
7443 A2 const& a2,
7444 A3 const& a3,
7445 A4 const& a4,
7446 A5 const& a5,
7447 bslma::Allocator *allocator = 0)
7448 : d_a1(a1,allocator)
7449 , d_a2(a2,allocator)
7450 , d_a3(a3,allocator)
7451 , d_a4(a4,allocator)
7452 , d_a5(a5,allocator)
7453 {
7454 }
7455
7456 Bind_BoundTuple5(bslmf::MovableRef<A1> a1,
7457 bslmf::MovableRef<A2> a2,
7458 bslmf::MovableRef<A3> a3,
7459 bslmf::MovableRef<A4> a4,
7460 bslmf::MovableRef<A5> a5,
7461 bslma::Allocator *allocator = 0)
7462 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7463 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7464 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7465 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7466 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7467 {
7468 }
7469};
7470
7471/// This `struct` stores a list of six arguments. It does *not* use the
7472/// const-forwarding type of its arguments, unlike `Bind_ArgTuple6` which
7473/// applies that optimization to avoid unnecessary copying.
7474template <class A1, class A2, class A3, class A4, class A5, class A6>
7475struct Bind_BoundTuple6 : bslmf::TypeList6<A1,A2,A3,A4,A5,A6>
7476{
7477
7478 // TRAITS
7479 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7480 Bind_BoundTuple6, bslmf::IsBitwiseMoveable,
7481 bslmf::IsBitwiseMoveable<A1>::value &&
7482 bslmf::IsBitwiseMoveable<A2>::value &&
7483 bslmf::IsBitwiseMoveable<A3>::value &&
7484 bslmf::IsBitwiseMoveable<A4>::value &&
7485 bslmf::IsBitwiseMoveable<A5>::value &&
7486 bslmf::IsBitwiseMoveable<A6>::value);
7487
7488 // INSTANCE DATA
7489 Bind_BoundTupleValue<A1> d_a1;
7490 Bind_BoundTupleValue<A2> d_a2;
7491 Bind_BoundTupleValue<A3> d_a3;
7492 Bind_BoundTupleValue<A4> d_a4;
7493 Bind_BoundTupleValue<A5> d_a5;
7494 Bind_BoundTupleValue<A6> d_a6;
7495
7496 // CREATORS
7497 Bind_BoundTuple6(const Bind_BoundTuple6<A1,A2,A3,A4,A5,A6>& orig,
7498 bslma::Allocator *allocator = 0)
7499 : d_a1(orig.d_a1,allocator)
7500 , d_a2(orig.d_a2,allocator)
7501 , d_a3(orig.d_a3,allocator)
7502 , d_a4(orig.d_a4,allocator)
7503 , d_a5(orig.d_a5,allocator)
7504 , d_a6(orig.d_a6,allocator)
7505 {
7506 }
7507
7508 Bind_BoundTuple6(
7509 bslmf::MovableRef<
7510 Bind_BoundTuple6<A1,A2,A3,A4,A5,A6> > orig,
7511 bslma::Allocator *allocator = 0)
7512 : d_a1(bslmf::MovableRefUtil::move(
7513 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7514 , d_a2(bslmf::MovableRefUtil::move(
7515 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7516 , d_a3(bslmf::MovableRefUtil::move(
7517 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7518 , d_a4(bslmf::MovableRefUtil::move(
7519 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7520 , d_a5(bslmf::MovableRefUtil::move(
7521 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7522 , d_a6(bslmf::MovableRefUtil::move(
7523 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7524 {
7525 }
7526
7527 Bind_BoundTuple6(A1 const& a1,
7528 A2 const& a2,
7529 A3 const& a3,
7530 A4 const& a4,
7531 A5 const& a5,
7532 A6 const& a6,
7533 bslma::Allocator *allocator = 0)
7534 : d_a1(a1,allocator)
7535 , d_a2(a2,allocator)
7536 , d_a3(a3,allocator)
7537 , d_a4(a4,allocator)
7538 , d_a5(a5,allocator)
7539 , d_a6(a6,allocator)
7540 {
7541 }
7542
7543 Bind_BoundTuple6(bslmf::MovableRef<A1> a1,
7544 bslmf::MovableRef<A2> a2,
7545 bslmf::MovableRef<A3> a3,
7546 bslmf::MovableRef<A4> a4,
7547 bslmf::MovableRef<A5> a5,
7548 bslmf::MovableRef<A6> a6,
7549 bslma::Allocator *allocator = 0)
7550 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7551 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7552 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7553 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7554 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7555 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7556 {
7557 }
7558};
7559
7560/// This `struct` stores a list of seven arguments. It does *not* use the
7561/// const-forwarding type of its arguments, unlike `Bind_ArgTuple7` which
7562/// applies that optimization to avoid unnecessary copying.
7563template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
7564struct Bind_BoundTuple7 : bslmf::TypeList7<A1,A2,A3,A4,A5,A6,A7>
7565{
7566
7567 // TRAITS
7568 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7569 Bind_BoundTuple7, bslmf::IsBitwiseMoveable,
7570 bslmf::IsBitwiseMoveable<A1>::value &&
7571 bslmf::IsBitwiseMoveable<A2>::value &&
7572 bslmf::IsBitwiseMoveable<A3>::value &&
7573 bslmf::IsBitwiseMoveable<A4>::value &&
7574 bslmf::IsBitwiseMoveable<A5>::value &&
7575 bslmf::IsBitwiseMoveable<A6>::value &&
7576 bslmf::IsBitwiseMoveable<A7>::value);
7577
7578 // INSTANCE DATA
7579 Bind_BoundTupleValue<A1> d_a1;
7580 Bind_BoundTupleValue<A2> d_a2;
7581 Bind_BoundTupleValue<A3> d_a3;
7582 Bind_BoundTupleValue<A4> d_a4;
7583 Bind_BoundTupleValue<A5> d_a5;
7584 Bind_BoundTupleValue<A6> d_a6;
7585 Bind_BoundTupleValue<A7> d_a7;
7586
7587 // CREATORS
7588 Bind_BoundTuple7(
7589 const Bind_BoundTuple7<A1,A2,A3,A4,A5,A6,A7>& orig,
7590 bslma::Allocator *allocator = 0)
7591 : d_a1(orig.d_a1,allocator)
7592 , d_a2(orig.d_a2,allocator)
7593 , d_a3(orig.d_a3,allocator)
7594 , d_a4(orig.d_a4,allocator)
7595 , d_a5(orig.d_a5,allocator)
7596 , d_a6(orig.d_a6,allocator)
7597 , d_a7(orig.d_a7,allocator)
7598 {
7599 }
7600
7601 Bind_BoundTuple7(
7602 bslmf::MovableRef<
7603 Bind_BoundTuple7<A1,A2,A3,A4,A5,A6,A7> > orig,
7604 bslma::Allocator *allocator = 0)
7605 : d_a1(bslmf::MovableRefUtil::move(
7606 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7607 , d_a2(bslmf::MovableRefUtil::move(
7608 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7609 , d_a3(bslmf::MovableRefUtil::move(
7610 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7611 , d_a4(bslmf::MovableRefUtil::move(
7612 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7613 , d_a5(bslmf::MovableRefUtil::move(
7614 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7615 , d_a6(bslmf::MovableRefUtil::move(
7616 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7617 , d_a7(bslmf::MovableRefUtil::move(
7618 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7619 {
7620 }
7621
7622 Bind_BoundTuple7(A1 const& a1,
7623 A2 const& a2,
7624 A3 const& a3,
7625 A4 const& a4,
7626 A5 const& a5,
7627 A6 const& a6,
7628 A7 const& a7,
7629 bslma::Allocator *allocator = 0)
7630 : d_a1(a1,allocator)
7631 , d_a2(a2,allocator)
7632 , d_a3(a3,allocator)
7633 , d_a4(a4,allocator)
7634 , d_a5(a5,allocator)
7635 , d_a6(a6,allocator)
7636 , d_a7(a7,allocator)
7637 {
7638 }
7639
7640 Bind_BoundTuple7(bslmf::MovableRef<A1> a1,
7641 bslmf::MovableRef<A2> a2,
7642 bslmf::MovableRef<A3> a3,
7643 bslmf::MovableRef<A4> a4,
7644 bslmf::MovableRef<A5> a5,
7645 bslmf::MovableRef<A6> a6,
7646 bslmf::MovableRef<A7> a7,
7647 bslma::Allocator *allocator = 0)
7648 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7649 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7650 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7651 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7652 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7653 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7654 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7655 {
7656 }
7657};
7658
7659/// This `struct` stores a list of eight arguments. It does *not* use the
7660/// const-forwarding type of its arguments, unlike `Bind_ArgTuple8` which
7661/// applies that optimization to avoid unnecessary copying.
7662template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7663 class A8>
7664struct Bind_BoundTuple8 : bslmf::TypeList8<A1,A2,A3,A4,A5,A6,A7,A8>
7665{
7666
7667 // TRAITS
7668 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7669 Bind_BoundTuple8, bslmf::IsBitwiseMoveable,
7670 bslmf::IsBitwiseMoveable<A1>::value &&
7671 bslmf::IsBitwiseMoveable<A2>::value &&
7672 bslmf::IsBitwiseMoveable<A3>::value &&
7673 bslmf::IsBitwiseMoveable<A4>::value &&
7674 bslmf::IsBitwiseMoveable<A5>::value &&
7675 bslmf::IsBitwiseMoveable<A6>::value &&
7676 bslmf::IsBitwiseMoveable<A7>::value &&
7677 bslmf::IsBitwiseMoveable<A8>::value);
7678
7679 // INSTANCE DATA
7680 Bind_BoundTupleValue<A1> d_a1;
7681 Bind_BoundTupleValue<A2> d_a2;
7682 Bind_BoundTupleValue<A3> d_a3;
7683 Bind_BoundTupleValue<A4> d_a4;
7684 Bind_BoundTupleValue<A5> d_a5;
7685 Bind_BoundTupleValue<A6> d_a6;
7686 Bind_BoundTupleValue<A7> d_a7;
7687 Bind_BoundTupleValue<A8> d_a8;
7688
7689 // CREATORS
7690 Bind_BoundTuple8(
7691 const Bind_BoundTuple8<A1,A2,A3,A4,A5,A6,A7,A8>& orig,
7692 bslma::Allocator *allocator = 0)
7693 : d_a1(orig.d_a1,allocator)
7694 , d_a2(orig.d_a2,allocator)
7695 , d_a3(orig.d_a3,allocator)
7696 , d_a4(orig.d_a4,allocator)
7697 , d_a5(orig.d_a5,allocator)
7698 , d_a6(orig.d_a6,allocator)
7699 , d_a7(orig.d_a7,allocator)
7700 , d_a8(orig.d_a8,allocator)
7701 {
7702 }
7703
7704 Bind_BoundTuple8(
7705 bslmf::MovableRef<
7706 Bind_BoundTuple8<A1,A2,A3,A4,A5,A6,A7,A8> > orig,
7707 bslma::Allocator *allocator = 0)
7708 : d_a1(bslmf::MovableRefUtil::move(
7709 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7710 , d_a2(bslmf::MovableRefUtil::move(
7711 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7712 , d_a3(bslmf::MovableRefUtil::move(
7713 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7714 , d_a4(bslmf::MovableRefUtil::move(
7715 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7716 , d_a5(bslmf::MovableRefUtil::move(
7717 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7718 , d_a6(bslmf::MovableRefUtil::move(
7719 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7720 , d_a7(bslmf::MovableRefUtil::move(
7721 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7722 , d_a8(bslmf::MovableRefUtil::move(
7723 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
7724 {
7725 }
7726
7727 Bind_BoundTuple8(A1 const& a1,
7728 A2 const& a2,
7729 A3 const& a3,
7730 A4 const& a4,
7731 A5 const& a5,
7732 A6 const& a6,
7733 A7 const& a7,
7734 A8 const& a8,
7735 bslma::Allocator *allocator = 0)
7736 : d_a1(a1,allocator)
7737 , d_a2(a2,allocator)
7738 , d_a3(a3,allocator)
7739 , d_a4(a4,allocator)
7740 , d_a5(a5,allocator)
7741 , d_a6(a6,allocator)
7742 , d_a7(a7,allocator)
7743 , d_a8(a8,allocator)
7744 {
7745 }
7746
7747 Bind_BoundTuple8(bslmf::MovableRef<A1> a1,
7748 bslmf::MovableRef<A2> a2,
7749 bslmf::MovableRef<A3> a3,
7750 bslmf::MovableRef<A4> a4,
7751 bslmf::MovableRef<A5> a5,
7752 bslmf::MovableRef<A6> a6,
7753 bslmf::MovableRef<A7> a7,
7754 bslmf::MovableRef<A8> a8,
7755 bslma::Allocator *allocator = 0)
7756 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7757 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7758 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7759 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7760 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7761 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7762 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7763 , d_a8(bslmf::MovableRefUtil::move(a8), allocator)
7764 {
7765 }
7766};
7767
7768/// This `struct` stores a list of nine arguments. It does *not* use the
7769/// const-forwarding type of its arguments, unlike `Bind_ArgTuple9` which
7770/// applies that optimization to avoid unnecessary copying.
7771template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7772 class A8, class A9>
7773struct Bind_BoundTuple9 : bslmf::TypeList9<A1,A2,A3,A4,A5,A6,A7,A8,A9>
7774{
7775
7776 // TRAITS
7777 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7778 Bind_BoundTuple9, bslmf::IsBitwiseMoveable,
7779 bslmf::IsBitwiseMoveable<A1>::value &&
7780 bslmf::IsBitwiseMoveable<A2>::value &&
7781 bslmf::IsBitwiseMoveable<A3>::value &&
7782 bslmf::IsBitwiseMoveable<A4>::value &&
7783 bslmf::IsBitwiseMoveable<A5>::value &&
7784 bslmf::IsBitwiseMoveable<A6>::value &&
7785 bslmf::IsBitwiseMoveable<A7>::value &&
7786 bslmf::IsBitwiseMoveable<A8>::value &&
7787 bslmf::IsBitwiseMoveable<A9>::value);
7788
7789 // INSTANCE DATA
7790 Bind_BoundTupleValue<A1> d_a1;
7791 Bind_BoundTupleValue<A2> d_a2;
7792 Bind_BoundTupleValue<A3> d_a3;
7793 Bind_BoundTupleValue<A4> d_a4;
7794 Bind_BoundTupleValue<A5> d_a5;
7795 Bind_BoundTupleValue<A6> d_a6;
7796 Bind_BoundTupleValue<A7> d_a7;
7797 Bind_BoundTupleValue<A8> d_a8;
7798 Bind_BoundTupleValue<A9> d_a9;
7799
7800 // CREATORS
7801 Bind_BoundTuple9(
7802 const Bind_BoundTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>& orig,
7803 bslma::Allocator *allocator = 0)
7804 : d_a1(orig.d_a1,allocator)
7805 , d_a2(orig.d_a2,allocator)
7806 , d_a3(orig.d_a3,allocator)
7807 , d_a4(orig.d_a4,allocator)
7808 , d_a5(orig.d_a5,allocator)
7809 , d_a6(orig.d_a6,allocator)
7810 , d_a7(orig.d_a7,allocator)
7811 , d_a8(orig.d_a8,allocator)
7812 , d_a9(orig.d_a9,allocator)
7813 {
7814 }
7815
7816 Bind_BoundTuple9(
7817 bslmf::MovableRef<
7818 Bind_BoundTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9> > orig,
7819 bslma::Allocator *allocator = 0)
7820 : d_a1(bslmf::MovableRefUtil::move(
7821 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7822 , d_a2(bslmf::MovableRefUtil::move(
7823 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7824 , d_a3(bslmf::MovableRefUtil::move(
7825 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7826 , d_a4(bslmf::MovableRefUtil::move(
7827 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7828 , d_a5(bslmf::MovableRefUtil::move(
7829 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7830 , d_a6(bslmf::MovableRefUtil::move(
7831 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7832 , d_a7(bslmf::MovableRefUtil::move(
7833 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7834 , d_a8(bslmf::MovableRefUtil::move(
7835 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
7836 , d_a9(bslmf::MovableRefUtil::move(
7837 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
7838 {
7839 }
7840
7841 Bind_BoundTuple9(A1 const& a1,
7842 A2 const& a2,
7843 A3 const& a3,
7844 A4 const& a4,
7845 A5 const& a5,
7846 A6 const& a6,
7847 A7 const& a7,
7848 A8 const& a8,
7849 A9 const& a9,
7850 bslma::Allocator *allocator = 0)
7851 : d_a1(a1,allocator)
7852 , d_a2(a2,allocator)
7853 , d_a3(a3,allocator)
7854 , d_a4(a4,allocator)
7855 , d_a5(a5,allocator)
7856 , d_a6(a6,allocator)
7857 , d_a7(a7,allocator)
7858 , d_a8(a8,allocator)
7859 , d_a9(a9,allocator)
7860 {
7861 }
7862
7863 Bind_BoundTuple9(bslmf::MovableRef<A1> a1,
7864 bslmf::MovableRef<A2> a2,
7865 bslmf::MovableRef<A3> a3,
7866 bslmf::MovableRef<A4> a4,
7867 bslmf::MovableRef<A5> a5,
7868 bslmf::MovableRef<A6> a6,
7869 bslmf::MovableRef<A7> a7,
7870 bslmf::MovableRef<A8> a8,
7871 bslmf::MovableRef<A9> a9,
7872 bslma::Allocator *allocator = 0)
7873 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7874 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7875 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7876 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7877 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7878 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7879 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7880 , d_a8(bslmf::MovableRefUtil::move(a8), allocator)
7881 , d_a9(bslmf::MovableRefUtil::move(a9), allocator)
7882 {
7883 }
7884};
7885
7886/// This `struct` stores a list of ten arguments. It does *not* use the
7887/// const-forwarding type of its arguments, unlike `Bind_ArgTuple10` which
7888/// applies that optimization to avoid unnecessary copying.
7889template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7890 class A8, class A9, class A10>
7891struct Bind_BoundTuple10 : bslmf::TypeList10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>
7892{
7893
7894 // TRAITS
7895 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7896 Bind_BoundTuple10, bslmf::IsBitwiseMoveable,
7897 bslmf::IsBitwiseMoveable<A1>::value &&
7898 bslmf::IsBitwiseMoveable<A2>::value &&
7899 bslmf::IsBitwiseMoveable<A3>::value &&
7900 bslmf::IsBitwiseMoveable<A4>::value &&
7901 bslmf::IsBitwiseMoveable<A5>::value &&
7902 bslmf::IsBitwiseMoveable<A6>::value &&
7903 bslmf::IsBitwiseMoveable<A7>::value &&
7904 bslmf::IsBitwiseMoveable<A8>::value &&
7905 bslmf::IsBitwiseMoveable<A9>::value &&
7906 bslmf::IsBitwiseMoveable<A10>::value);
7907
7908 // INSTANCE DATA
7909 Bind_BoundTupleValue<A1> d_a1;
7910 Bind_BoundTupleValue<A2> d_a2;
7911 Bind_BoundTupleValue<A3> d_a3;
7912 Bind_BoundTupleValue<A4> d_a4;
7913 Bind_BoundTupleValue<A5> d_a5;
7914 Bind_BoundTupleValue<A6> d_a6;
7915 Bind_BoundTupleValue<A7> d_a7;
7916 Bind_BoundTupleValue<A8> d_a8;
7917 Bind_BoundTupleValue<A9> d_a9;
7918 Bind_BoundTupleValue<A10> d_a10;
7919
7920 // CREATORS
7921 Bind_BoundTuple10(
7922 const Bind_BoundTuple10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>& orig,
7923 bslma::Allocator *allocator = 0)
7924 : d_a1(orig.d_a1,allocator)
7925 , d_a2(orig.d_a2,allocator)
7926 , d_a3(orig.d_a3,allocator)
7927 , d_a4(orig.d_a4,allocator)
7928 , d_a5(orig.d_a5,allocator)
7929 , d_a6(orig.d_a6,allocator)
7930 , d_a7(orig.d_a7,allocator)
7931 , d_a8(orig.d_a8,allocator)
7932 , d_a9(orig.d_a9,allocator)
7933 , d_a10(orig.d_a10,allocator)
7934 {
7935 }
7936
7937 Bind_BoundTuple10(
7938 bslmf::MovableRef<
7939 Bind_BoundTuple10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> > orig,
7940 bslma::Allocator *allocator = 0)
7941 : d_a1(bslmf::MovableRefUtil::move(
7942 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7943 , d_a2(bslmf::MovableRefUtil::move(
7944 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7945 , d_a3(bslmf::MovableRefUtil::move(
7946 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7947 , d_a4(bslmf::MovableRefUtil::move(
7948 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7949 , d_a5(bslmf::MovableRefUtil::move(
7950 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7951 , d_a6(bslmf::MovableRefUtil::move(
7952 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7953 , d_a7(bslmf::MovableRefUtil::move(
7954 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7955 , d_a8(bslmf::MovableRefUtil::move(
7956 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
7957 , d_a9(bslmf::MovableRefUtil::move(
7958 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
7959 , d_a10(bslmf::MovableRefUtil::move(
7960 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
7961 {
7962 }
7963
7964 Bind_BoundTuple10(A1 const& a1,
7965 A2 const& a2,
7966 A3 const& a3,
7967 A4 const& a4,
7968 A5 const& a5,
7969 A6 const& a6,
7970 A7 const& a7,
7971 A8 const& a8,
7972 A9 const& a9,
7973 A10 const& a10,
7974 bslma::Allocator *allocator = 0)
7975 : d_a1(a1,allocator)
7976 , d_a2(a2,allocator)
7977 , d_a3(a3,allocator)
7978 , d_a4(a4,allocator)
7979 , d_a5(a5,allocator)
7980 , d_a6(a6,allocator)
7981 , d_a7(a7,allocator)
7982 , d_a8(a8,allocator)
7983 , d_a9(a9,allocator)
7984 , d_a10(a10,allocator)
7985 {
7986 }
7987
7988 Bind_BoundTuple10(bslmf::MovableRef<A1> a1,
7989 bslmf::MovableRef<A2> a2,
7990 bslmf::MovableRef<A3> a3,
7991 bslmf::MovableRef<A4> a4,
7992 bslmf::MovableRef<A5> a5,
7993 bslmf::MovableRef<A6> a6,
7994 bslmf::MovableRef<A7> a7,
7995 bslmf::MovableRef<A8> a8,
7996 bslmf::MovableRef<A9> a9,
7997 bslmf::MovableRef<A10> a10,
7998 bslma::Allocator *allocator = 0)
7999 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8000 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8001 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8002 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8003 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8004 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8005 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8006 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8007 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8008 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8009 {
8010 }
8011};
8012
8013/// This `struct` stores a list of eleven arguments. It does *not* use the
8014/// const-forwarding type of its arguments, unlike `Bind_ArgTuple11` which
8015/// applies that optimization to avoid unnecessary copying.
8016template <class A1, class A2, class A3, class A4, class A5, class A6,
8017 class A7, class A8, class A9, class A10, class A11>
8018struct Bind_BoundTuple11
8019 : bslmf::TypeList11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> {
8020
8021 // TRAITS
8022 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8023 Bind_BoundTuple11, bslmf::IsBitwiseMoveable,
8024 bslmf::IsBitwiseMoveable<A1>::value &&
8025 bslmf::IsBitwiseMoveable<A2>::value &&
8026 bslmf::IsBitwiseMoveable<A3>::value &&
8027 bslmf::IsBitwiseMoveable<A4>::value &&
8028 bslmf::IsBitwiseMoveable<A5>::value &&
8029 bslmf::IsBitwiseMoveable<A6>::value &&
8030 bslmf::IsBitwiseMoveable<A7>::value &&
8031 bslmf::IsBitwiseMoveable<A8>::value &&
8032 bslmf::IsBitwiseMoveable<A9>::value &&
8033 bslmf::IsBitwiseMoveable<A10>::value &&
8034 bslmf::IsBitwiseMoveable<A11>::value);
8035
8036 // INSTANCE DATA
8037 Bind_BoundTupleValue<A1> d_a1;
8038 Bind_BoundTupleValue<A2> d_a2;
8039 Bind_BoundTupleValue<A3> d_a3;
8040 Bind_BoundTupleValue<A4> d_a4;
8041 Bind_BoundTupleValue<A5> d_a5;
8042 Bind_BoundTupleValue<A6> d_a6;
8043 Bind_BoundTupleValue<A7> d_a7;
8044 Bind_BoundTupleValue<A8> d_a8;
8045 Bind_BoundTupleValue<A9> d_a9;
8046 Bind_BoundTupleValue<A10> d_a10;
8047 Bind_BoundTupleValue<A11> d_a11;
8048
8049 // CREATORS
8050 Bind_BoundTuple11(const Bind_BoundTuple11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8051 A11>& orig,
8052 bslma::Allocator *allocator = 0)
8053 : d_a1(orig.d_a1,allocator)
8054 , d_a2(orig.d_a2,allocator)
8055 , d_a3(orig.d_a3,allocator)
8056 , d_a4(orig.d_a4,allocator)
8057 , d_a5(orig.d_a5,allocator)
8058 , d_a6(orig.d_a6,allocator)
8059 , d_a7(orig.d_a7,allocator)
8060 , d_a8(orig.d_a8,allocator)
8061 , d_a9(orig.d_a9,allocator)
8062 , d_a10(orig.d_a10,allocator)
8063 , d_a11(orig.d_a11,allocator)
8064 {
8065 }
8066
8067 Bind_BoundTuple11(
8068 bslmf::MovableRef<Bind_BoundTuple11<
8069 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> > orig,
8070 bslma::Allocator *allocator = 0)
8071 : d_a1(bslmf::MovableRefUtil::move(
8072 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8073 , d_a2(bslmf::MovableRefUtil::move(
8074 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8075 , d_a3(bslmf::MovableRefUtil::move(
8076 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8077 , d_a4(bslmf::MovableRefUtil::move(
8078 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8079 , d_a5(bslmf::MovableRefUtil::move(
8080 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8081 , d_a6(bslmf::MovableRefUtil::move(
8082 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8083 , d_a7(bslmf::MovableRefUtil::move(
8084 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8085 , d_a8(bslmf::MovableRefUtil::move(
8086 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8087 , d_a9(bslmf::MovableRefUtil::move(
8088 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8089 , d_a10(bslmf::MovableRefUtil::move(
8090 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8091 , d_a11(bslmf::MovableRefUtil::move(
8092 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8093 {
8094 }
8095
8096 Bind_BoundTuple11(A1 const& a1,
8097 A2 const& a2,
8098 A3 const& a3,
8099 A4 const& a4,
8100 A5 const& a5,
8101 A6 const& a6,
8102 A7 const& a7,
8103 A8 const& a8,
8104 A9 const& a9,
8105 A10 const& a10,
8106 A11 const& a11,
8107 bslma::Allocator *allocator = 0)
8108 : d_a1(a1,allocator)
8109 , d_a2(a2,allocator)
8110 , d_a3(a3,allocator)
8111 , d_a4(a4,allocator)
8112 , d_a5(a5,allocator)
8113 , d_a6(a6,allocator)
8114 , d_a7(a7,allocator)
8115 , d_a8(a8,allocator)
8116 , d_a9(a9,allocator)
8117 , d_a10(a10,allocator)
8118 , d_a11(a11,allocator)
8119 {
8120 }
8121
8122 Bind_BoundTuple11(bslmf::MovableRef<A1> a1,
8123 bslmf::MovableRef<A2> a2,
8124 bslmf::MovableRef<A3> a3,
8125 bslmf::MovableRef<A4> a4,
8126 bslmf::MovableRef<A5> a5,
8127 bslmf::MovableRef<A6> a6,
8128 bslmf::MovableRef<A7> a7,
8129 bslmf::MovableRef<A8> a8,
8130 bslmf::MovableRef<A9> a9,
8131 bslmf::MovableRef<A10> a10,
8132 bslmf::MovableRef<A11> a11,
8133 bslma::Allocator *allocator = 0)
8134 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8135 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8136 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8137 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8138 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8139 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8140 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8141 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8142 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8143 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8144 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8145 {
8146 }
8147};
8148
8149/// This `struct` stores a list of twelve arguments. It does *not* use the
8150/// const-forwarding type of its arguments, unlike `Bind_ArgTuple12` which
8151/// applies that optimization to avoid unnecessary copying.
8152template <class A1, class A2, class A3, class A4, class A5, class A6,
8153 class A7, class A8, class A9, class A10, class A11, class A12>
8154struct Bind_BoundTuple12
8155 : bslmf::TypeList12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> {
8156
8157 // TRAITS
8158 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8159 Bind_BoundTuple12, bslmf::IsBitwiseMoveable,
8160 bslmf::IsBitwiseMoveable<A1>::value &&
8161 bslmf::IsBitwiseMoveable<A2>::value &&
8162 bslmf::IsBitwiseMoveable<A3>::value &&
8163 bslmf::IsBitwiseMoveable<A4>::value &&
8164 bslmf::IsBitwiseMoveable<A5>::value &&
8165 bslmf::IsBitwiseMoveable<A6>::value &&
8166 bslmf::IsBitwiseMoveable<A7>::value &&
8167 bslmf::IsBitwiseMoveable<A8>::value &&
8168 bslmf::IsBitwiseMoveable<A9>::value &&
8169 bslmf::IsBitwiseMoveable<A10>::value &&
8170 bslmf::IsBitwiseMoveable<A11>::value &&
8171 bslmf::IsBitwiseMoveable<A12>::value);
8172
8173 // INSTANCE DATA
8174 Bind_BoundTupleValue<A1> d_a1;
8175 Bind_BoundTupleValue<A2> d_a2;
8176 Bind_BoundTupleValue<A3> d_a3;
8177 Bind_BoundTupleValue<A4> d_a4;
8178 Bind_BoundTupleValue<A5> d_a5;
8179 Bind_BoundTupleValue<A6> d_a6;
8180 Bind_BoundTupleValue<A7> d_a7;
8181 Bind_BoundTupleValue<A8> d_a8;
8182 Bind_BoundTupleValue<A9> d_a9;
8183 Bind_BoundTupleValue<A10> d_a10;
8184 Bind_BoundTupleValue<A11> d_a11;
8185 Bind_BoundTupleValue<A12> d_a12;
8186
8187 // CREATORS
8188 Bind_BoundTuple12(const Bind_BoundTuple12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8189 A11,A12>& orig,
8190 bslma::Allocator *allocator = 0)
8191 : d_a1(orig.d_a1,allocator)
8192 , d_a2(orig.d_a2,allocator)
8193 , d_a3(orig.d_a3,allocator)
8194 , d_a4(orig.d_a4,allocator)
8195 , d_a5(orig.d_a5,allocator)
8196 , d_a6(orig.d_a6,allocator)
8197 , d_a7(orig.d_a7,allocator)
8198 , d_a8(orig.d_a8,allocator)
8199 , d_a9(orig.d_a9,allocator)
8200 , d_a10(orig.d_a10,allocator)
8201 , d_a11(orig.d_a11,allocator)
8202 , d_a12(orig.d_a12,allocator)
8203 {
8204 }
8205
8206 Bind_BoundTuple12(
8207 bslmf::MovableRef<Bind_BoundTuple12<
8208 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> > orig,
8209 bslma::Allocator *allocator = 0)
8210 : d_a1(bslmf::MovableRefUtil::move(
8211 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8212 , d_a2(bslmf::MovableRefUtil::move(
8213 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8214 , d_a3(bslmf::MovableRefUtil::move(
8215 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8216 , d_a4(bslmf::MovableRefUtil::move(
8217 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8218 , d_a5(bslmf::MovableRefUtil::move(
8219 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8220 , d_a6(bslmf::MovableRefUtil::move(
8221 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8222 , d_a7(bslmf::MovableRefUtil::move(
8223 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8224 , d_a8(bslmf::MovableRefUtil::move(
8225 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8226 , d_a9(bslmf::MovableRefUtil::move(
8227 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8228 , d_a10(bslmf::MovableRefUtil::move(
8229 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8230 , d_a11(bslmf::MovableRefUtil::move(
8231 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8232 , d_a12(bslmf::MovableRefUtil::move(
8233 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8234 {
8235 }
8236
8237 Bind_BoundTuple12(A1 const& a1,
8238 A2 const& a2,
8239 A3 const& a3,
8240 A4 const& a4,
8241 A5 const& a5,
8242 A6 const& a6,
8243 A7 const& a7,
8244 A8 const& a8,
8245 A9 const& a9,
8246 A10 const& a10,
8247 A11 const& a11,
8248 A12 const& a12,
8249 bslma::Allocator *allocator = 0)
8250 : d_a1(a1,allocator)
8251 , d_a2(a2,allocator)
8252 , d_a3(a3,allocator)
8253 , d_a4(a4,allocator)
8254 , d_a5(a5,allocator)
8255 , d_a6(a6,allocator)
8256 , d_a7(a7,allocator)
8257 , d_a8(a8,allocator)
8258 , d_a9(a9,allocator)
8259 , d_a10(a10,allocator)
8260 , d_a11(a11,allocator)
8261 , d_a12(a12,allocator)
8262 {
8263 }
8264
8265 Bind_BoundTuple12(bslmf::MovableRef<A1> a1,
8266 bslmf::MovableRef<A2> a2,
8267 bslmf::MovableRef<A3> a3,
8268 bslmf::MovableRef<A4> a4,
8269 bslmf::MovableRef<A5> a5,
8270 bslmf::MovableRef<A6> a6,
8271 bslmf::MovableRef<A7> a7,
8272 bslmf::MovableRef<A8> a8,
8273 bslmf::MovableRef<A9> a9,
8274 bslmf::MovableRef<A10> a10,
8275 bslmf::MovableRef<A11> a11,
8276 bslmf::MovableRef<A12> a12,
8277 bslma::Allocator *allocator = 0)
8278 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8279 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8280 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8281 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8282 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8283 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8284 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8285 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8286 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8287 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8288 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8289 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8290 {
8291 }
8292};
8293
8294/// This `struct` stores a list of thirteen arguments. It does *not* use
8295/// the const-forwarding type of its arguments, unlike `Bind_ArgTuple13`
8296/// which applies that optimization to avoid unnecessary copying.
8297template <class A1, class A2, class A3, class A4, class A5, class A6,
8298 class A7, class A8, class A9, class A10, class A11, class A12,
8299 class A13>
8300struct Bind_BoundTuple13
8301 : bslmf::TypeList13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> {
8302
8303 // TRAITS
8304 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8305 Bind_BoundTuple13, bslmf::IsBitwiseMoveable,
8306 bslmf::IsBitwiseMoveable<A1>::value &&
8307 bslmf::IsBitwiseMoveable<A2>::value &&
8308 bslmf::IsBitwiseMoveable<A3>::value &&
8309 bslmf::IsBitwiseMoveable<A4>::value &&
8310 bslmf::IsBitwiseMoveable<A5>::value &&
8311 bslmf::IsBitwiseMoveable<A6>::value &&
8312 bslmf::IsBitwiseMoveable<A7>::value &&
8313 bslmf::IsBitwiseMoveable<A8>::value &&
8314 bslmf::IsBitwiseMoveable<A9>::value &&
8315 bslmf::IsBitwiseMoveable<A10>::value &&
8316 bslmf::IsBitwiseMoveable<A11>::value &&
8317 bslmf::IsBitwiseMoveable<A12>::value &&
8318 bslmf::IsBitwiseMoveable<A13>::value);
8319
8320 // INSTANCE DATA
8321 Bind_BoundTupleValue<A1> d_a1;
8322 Bind_BoundTupleValue<A2> d_a2;
8323 Bind_BoundTupleValue<A3> d_a3;
8324 Bind_BoundTupleValue<A4> d_a4;
8325 Bind_BoundTupleValue<A5> d_a5;
8326 Bind_BoundTupleValue<A6> d_a6;
8327 Bind_BoundTupleValue<A7> d_a7;
8328 Bind_BoundTupleValue<A8> d_a8;
8329 Bind_BoundTupleValue<A9> d_a9;
8330 Bind_BoundTupleValue<A10> d_a10;
8331 Bind_BoundTupleValue<A11> d_a11;
8332 Bind_BoundTupleValue<A12> d_a12;
8333 Bind_BoundTupleValue<A13> d_a13;
8334
8335 // CREATORS
8336 Bind_BoundTuple13(const Bind_BoundTuple13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8337 A11,A12,A13>& orig,
8338 bslma::Allocator *allocator = 0)
8339 : d_a1(orig.d_a1,allocator)
8340 , d_a2(orig.d_a2,allocator)
8341 , d_a3(orig.d_a3,allocator)
8342 , d_a4(orig.d_a4,allocator)
8343 , d_a5(orig.d_a5,allocator)
8344 , d_a6(orig.d_a6,allocator)
8345 , d_a7(orig.d_a7,allocator)
8346 , d_a8(orig.d_a8,allocator)
8347 , d_a9(orig.d_a9,allocator)
8348 , d_a10(orig.d_a10,allocator)
8349 , d_a11(orig.d_a11,allocator)
8350 , d_a12(orig.d_a12,allocator)
8351 , d_a13(orig.d_a13,allocator)
8352 {
8353 }
8354
8355 Bind_BoundTuple13(
8356 bslmf::MovableRef<Bind_BoundTuple13<
8357 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> > orig,
8358 bslma::Allocator *allocator = 0)
8359 : d_a1(bslmf::MovableRefUtil::move(
8360 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8361 , d_a2(bslmf::MovableRefUtil::move(
8362 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8363 , d_a3(bslmf::MovableRefUtil::move(
8364 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8365 , d_a4(bslmf::MovableRefUtil::move(
8366 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8367 , d_a5(bslmf::MovableRefUtil::move(
8368 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8369 , d_a6(bslmf::MovableRefUtil::move(
8370 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8371 , d_a7(bslmf::MovableRefUtil::move(
8372 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8373 , d_a8(bslmf::MovableRefUtil::move(
8374 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8375 , d_a9(bslmf::MovableRefUtil::move(
8376 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8377 , d_a10(bslmf::MovableRefUtil::move(
8378 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8379 , d_a11(bslmf::MovableRefUtil::move(
8380 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8381 , d_a12(bslmf::MovableRefUtil::move(
8382 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8383 , d_a13(bslmf::MovableRefUtil::move(
8384 bslmf::MovableRefUtil::access(orig).d_a13),allocator)
8385 {
8386 }
8387
8388 Bind_BoundTuple13(A1 const& a1,
8389 A2 const& a2,
8390 A3 const& a3,
8391 A4 const& a4,
8392 A5 const& a5,
8393 A6 const& a6,
8394 A7 const& a7,
8395 A8 const& a8,
8396 A9 const& a9,
8397 A10 const& a10,
8398 A11 const& a11,
8399 A12 const& a12,
8400 A13 const& a13,
8401 bslma::Allocator *allocator = 0)
8402 : d_a1(a1,allocator)
8403 , d_a2(a2,allocator)
8404 , d_a3(a3,allocator)
8405 , d_a4(a4,allocator)
8406 , d_a5(a5,allocator)
8407 , d_a6(a6,allocator)
8408 , d_a7(a7,allocator)
8409 , d_a8(a8,allocator)
8410 , d_a9(a9,allocator)
8411 , d_a10(a10,allocator)
8412 , d_a11(a11,allocator)
8413 , d_a12(a12,allocator)
8414 , d_a13(a13,allocator)
8415 {
8416 }
8417
8418 Bind_BoundTuple13(bslmf::MovableRef<A1> a1,
8419 bslmf::MovableRef<A2> a2,
8420 bslmf::MovableRef<A3> a3,
8421 bslmf::MovableRef<A4> a4,
8422 bslmf::MovableRef<A5> a5,
8423 bslmf::MovableRef<A6> a6,
8424 bslmf::MovableRef<A7> a7,
8425 bslmf::MovableRef<A8> a8,
8426 bslmf::MovableRef<A9> a9,
8427 bslmf::MovableRef<A10> a10,
8428 bslmf::MovableRef<A11> a11,
8429 bslmf::MovableRef<A12> a12,
8430 bslmf::MovableRef<A13> a13,
8431 bslma::Allocator *allocator = 0)
8432 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8433 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8434 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8435 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8436 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8437 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8438 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8439 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8440 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8441 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8442 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8443 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8444 , d_a13(bslmf::MovableRefUtil::move(a13), allocator)
8445 {
8446 }
8447};
8448
8449/// This `struct` stores a list of fourteen arguments. It does *not* use
8450/// the const-forwarding type of its arguments, unlike `Bind_ArgTuple14`
8451/// which applies that optimization to avoid unnecessary copying.
8452template <class A1, class A2, class A3, class A4, class A5, class A6,
8453 class A7, class A8, class A9, class A10, class A11, class A12,
8454 class A13, class A14>
8455struct Bind_BoundTuple14
8456 : bslmf::TypeList14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> {
8457
8458 // TRAITS
8459 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8460 Bind_BoundTuple14, bslmf::IsBitwiseMoveable,
8461 bslmf::IsBitwiseMoveable<A1>::value &&
8462 bslmf::IsBitwiseMoveable<A2>::value &&
8463 bslmf::IsBitwiseMoveable<A3>::value &&
8464 bslmf::IsBitwiseMoveable<A4>::value &&
8465 bslmf::IsBitwiseMoveable<A5>::value &&
8466 bslmf::IsBitwiseMoveable<A6>::value &&
8467 bslmf::IsBitwiseMoveable<A7>::value &&
8468 bslmf::IsBitwiseMoveable<A8>::value &&
8469 bslmf::IsBitwiseMoveable<A9>::value &&
8470 bslmf::IsBitwiseMoveable<A10>::value &&
8471 bslmf::IsBitwiseMoveable<A11>::value &&
8472 bslmf::IsBitwiseMoveable<A12>::value &&
8473 bslmf::IsBitwiseMoveable<A13>::value &&
8474 bslmf::IsBitwiseMoveable<A14>::value);
8475
8476 // INSTANCE DATA
8477 Bind_BoundTupleValue<A1> d_a1;
8478 Bind_BoundTupleValue<A2> d_a2;
8479 Bind_BoundTupleValue<A3> d_a3;
8480 Bind_BoundTupleValue<A4> d_a4;
8481 Bind_BoundTupleValue<A5> d_a5;
8482 Bind_BoundTupleValue<A6> d_a6;
8483 Bind_BoundTupleValue<A7> d_a7;
8484 Bind_BoundTupleValue<A8> d_a8;
8485 Bind_BoundTupleValue<A9> d_a9;
8486 Bind_BoundTupleValue<A10> d_a10;
8487 Bind_BoundTupleValue<A11> d_a11;
8488 Bind_BoundTupleValue<A12> d_a12;
8489 Bind_BoundTupleValue<A13> d_a13;
8490 Bind_BoundTupleValue<A14> d_a14;
8491
8492 // CREATORS
8493 Bind_BoundTuple14(const Bind_BoundTuple14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8494 A11,A12,A13,A14>& orig,
8495 bslma::Allocator *allocator = 0)
8496 : d_a1(orig.d_a1,allocator)
8497 , d_a2(orig.d_a2,allocator)
8498 , d_a3(orig.d_a3,allocator)
8499 , d_a4(orig.d_a4,allocator)
8500 , d_a5(orig.d_a5,allocator)
8501 , d_a6(orig.d_a6,allocator)
8502 , d_a7(orig.d_a7,allocator)
8503 , d_a8(orig.d_a8,allocator)
8504 , d_a9(orig.d_a9,allocator)
8505 , d_a10(orig.d_a10,allocator)
8506 , d_a11(orig.d_a11,allocator)
8507 , d_a12(orig.d_a12,allocator)
8508 , d_a13(orig.d_a13,allocator)
8509 , d_a14(orig.d_a14,allocator)
8510 {
8511 }
8512
8513 Bind_BoundTuple14(
8514 bslmf::MovableRef<Bind_BoundTuple14<
8515 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> > orig,
8516 bslma::Allocator *allocator = 0)
8517 : d_a1(bslmf::MovableRefUtil::move(
8518 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8519 , d_a2(bslmf::MovableRefUtil::move(
8520 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8521 , d_a3(bslmf::MovableRefUtil::move(
8522 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8523 , d_a4(bslmf::MovableRefUtil::move(
8524 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8525 , d_a5(bslmf::MovableRefUtil::move(
8526 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8527 , d_a6(bslmf::MovableRefUtil::move(
8528 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8529 , d_a7(bslmf::MovableRefUtil::move(
8530 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8531 , d_a8(bslmf::MovableRefUtil::move(
8532 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8533 , d_a9(bslmf::MovableRefUtil::move(
8534 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8535 , d_a10(bslmf::MovableRefUtil::move(
8536 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8537 , d_a11(bslmf::MovableRefUtil::move(
8538 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8539 , d_a12(bslmf::MovableRefUtil::move(
8540 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8541 , d_a13(bslmf::MovableRefUtil::move(
8542 bslmf::MovableRefUtil::access(orig).d_a13),allocator)
8543 , d_a14(bslmf::MovableRefUtil::move(
8544 bslmf::MovableRefUtil::access(orig).d_a14),allocator)
8545 {
8546 }
8547
8548 Bind_BoundTuple14(A1 const& a1,
8549 A2 const& a2,
8550 A3 const& a3,
8551 A4 const& a4,
8552 A5 const& a5,
8553 A6 const& a6,
8554 A7 const& a7,
8555 A8 const& a8,
8556 A9 const& a9,
8557 A10 const& a10,
8558 A11 const& a11,
8559 A12 const& a12,
8560 A13 const& a13,
8561 A14 const& a14,
8562 bslma::Allocator *allocator = 0)
8563 : d_a1(a1,allocator)
8564 , d_a2(a2,allocator)
8565 , d_a3(a3,allocator)
8566 , d_a4(a4,allocator)
8567 , d_a5(a5,allocator)
8568 , d_a6(a6,allocator)
8569 , d_a7(a7,allocator)
8570 , d_a8(a8,allocator)
8571 , d_a9(a9,allocator)
8572 , d_a10(a10,allocator)
8573 , d_a11(a11,allocator)
8574 , d_a12(a12,allocator)
8575 , d_a13(a13,allocator)
8576 , d_a14(a14,allocator)
8577 {
8578 }
8579
8580 Bind_BoundTuple14(bslmf::MovableRef<A1> a1,
8581 bslmf::MovableRef<A2> a2,
8582 bslmf::MovableRef<A3> a3,
8583 bslmf::MovableRef<A4> a4,
8584 bslmf::MovableRef<A5> a5,
8585 bslmf::MovableRef<A6> a6,
8586 bslmf::MovableRef<A7> a7,
8587 bslmf::MovableRef<A8> a8,
8588 bslmf::MovableRef<A9> a9,
8589 bslmf::MovableRef<A10> a10,
8590 bslmf::MovableRef<A11> a11,
8591 bslmf::MovableRef<A12> a12,
8592 bslmf::MovableRef<A13> a13,
8593 bslmf::MovableRef<A14> a14,
8594 bslma::Allocator *allocator = 0)
8595 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8596 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8597 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8598 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8599 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8600 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8601 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8602 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8603 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8604 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8605 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8606 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8607 , d_a13(bslmf::MovableRefUtil::move(a13), allocator)
8608 , d_a14(bslmf::MovableRefUtil::move(a14), allocator)
8609 {
8610 }
8611};
8612} // close package namespace
8613
8614 // ========================
8615 // class bdlf::Bind_Invoker
8616 // ========================
8617
8618#define BDLF_BIND_EVAL(N) \
8619 bdlf::Bind_Evaluator< \
8620 typename bslmf::TypeListTypeOf<N, t_BOUND_TUPLE>::Type, \
8621 t_ARG_TUPLE>::eval(argList, (boundList->d_a##N).value())
8622
8623namespace bdlf {
8624/// Invoker for functions that take zero arguments.
8625template <class t_RET>
8626struct Bind_Invoker<t_RET, 0> {
8627 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8628 t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE&) const
8629 {
8630 return (*func)();
8631 }
8632};
8633
8634/// Invoker for functions that take zero arguments.
8635template <>
8636struct Bind_Invoker<void, 0> {
8637 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8638 void invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE&) const
8639 {
8640 (*func)();
8641 }
8642};
8643
8644/// Invoker for functions that take one argument.
8645template <class t_RET>
8646struct Bind_Invoker<t_RET, 1> {
8647 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8648 t_RET invoke(t_FUNC *func,
8649 t_BOUND_TUPLE *boundList,
8650 t_ARG_TUPLE& argList) const
8651 {
8652 return (*func)(BDLF_BIND_EVAL(1));
8653 }
8654};
8655
8656/// Invoker for functions that take one argument.
8657template <>
8658struct Bind_Invoker<void, 1> {
8659 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8660 void invoke(t_FUNC *func,
8661 t_BOUND_TUPLE *boundList,
8662 t_ARG_TUPLE& argList) const
8663 {
8664 (*func)(BDLF_BIND_EVAL(1));
8665 }
8666};
8667
8668/// Invoker for function that take two arguments.
8669template <class t_RET>
8670struct Bind_Invoker<t_RET, 2> {
8671 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8672 t_RET invoke(t_FUNC *func,
8673 t_BOUND_TUPLE *boundList,
8674 t_ARG_TUPLE& argList) const
8675 {
8676 return (*func)(BDLF_BIND_EVAL(1),
8677 BDLF_BIND_EVAL(2));
8678 }
8679};
8680
8681/// Invoker for functions that take two arguments.
8682template <>
8683struct Bind_Invoker<void, 2> {
8684 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8685 void invoke(t_FUNC *func,
8686 t_BOUND_TUPLE *boundList,
8687 t_ARG_TUPLE& argList) const
8688 {
8689 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2));
8690 }
8691};
8692
8693/// Invoker for functions that take three arguments.
8694template <class t_RET>
8695struct Bind_Invoker<t_RET, 3> {
8696 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8697 t_RET invoke(t_FUNC *func,
8698 t_BOUND_TUPLE *boundList,
8699 t_ARG_TUPLE& argList) const
8700 {
8701 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8702 BDLF_BIND_EVAL(3));
8703 }
8704};
8705
8706/// Invoker for functions that take three arguments.
8707template <>
8708struct Bind_Invoker<void, 3> {
8709 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8710 void invoke(t_FUNC *func,
8711 t_BOUND_TUPLE *boundList,
8712 t_ARG_TUPLE& argList) const
8713 {
8714 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3));
8715 }
8716};
8717
8718/// Invoker for functions that take four arguments.
8719template <class t_RET>
8720struct Bind_Invoker<t_RET, 4> {
8721 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8722 t_RET invoke(t_FUNC *func,
8723 t_BOUND_TUPLE *boundList,
8724 t_ARG_TUPLE& argList) const
8725 {
8726 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8727 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4));
8728 }
8729};
8730
8731/// Invoker for functions that take four arguments.
8732template <>
8733struct Bind_Invoker<void, 4> {
8734 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8735 void invoke(t_FUNC *func,
8736 t_BOUND_TUPLE *boundList,
8737 t_ARG_TUPLE& argList) const
8738 {
8739 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8740 BDLF_BIND_EVAL(4));
8741 }
8742};
8743
8744/// Invoker for functions that take five arguments.
8745template <class t_RET>
8746struct Bind_Invoker<t_RET, 5> {
8747 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8748 t_RET invoke(t_FUNC *func,
8749 t_BOUND_TUPLE *boundList,
8750 t_ARG_TUPLE& argList) const
8751 {
8752 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8753 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8754 BDLF_BIND_EVAL(5));
8755 }
8756};
8757
8758/// Invoker for functions that take five arguments.
8759template <>
8760struct Bind_Invoker<void, 5> {
8761 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8762 void invoke(t_FUNC *func,
8763 t_BOUND_TUPLE *boundList,
8764 t_ARG_TUPLE& argList) const
8765 {
8766 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8767 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5));
8768 }
8769};
8770
8771/// Invoker for functions that take six arguments.
8772template <class t_RET>
8773struct Bind_Invoker<t_RET, 6> {
8774 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8775 t_RET invoke(t_FUNC *func,
8776 t_BOUND_TUPLE *boundList,
8777 t_ARG_TUPLE& argList) const
8778 {
8779 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8780 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8781 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6));
8782 }
8783};
8784
8785/// Invoker for functions that take six arguments.
8786template <>
8787struct Bind_Invoker<void, 6> {
8788 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8789 void invoke(t_FUNC *func,
8790 t_BOUND_TUPLE *boundList,
8791 t_ARG_TUPLE& argList) const
8792 {
8793 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8794 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6));
8795 }
8796};
8797
8798/// Invoker for functions that take seven arguments.
8799template <class t_RET>
8800struct Bind_Invoker<t_RET, 7> {
8801 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8802 t_RET invoke(t_FUNC *func,
8803 t_BOUND_TUPLE *boundList,
8804 t_ARG_TUPLE& argList) const
8805 {
8806 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8807 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8808 BDLF_BIND_EVAL(7));
8809 }
8810};
8811
8812/// Invoker for functions that take seven arguments.
8813template <>
8814struct Bind_Invoker<void, 7> {
8815 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8816 void invoke(t_FUNC *func,
8817 t_BOUND_TUPLE *boundList,
8818 t_ARG_TUPLE& argList) const
8819 {
8820 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8821 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8822 BDLF_BIND_EVAL(7));
8823 }
8824};
8825
8826/// Invoker for functions that take eight arguments.
8827template <class t_RET>
8828struct Bind_Invoker<t_RET, 8> {
8829 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8830 t_RET invoke(t_FUNC *func,
8831 t_BOUND_TUPLE *boundList,
8832 t_ARG_TUPLE& argList) const
8833 {
8834 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8835 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8836 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8837 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8));
8838 }
8839};
8840
8841/// Invoker for functions that take eight arguments.
8842template <>
8843struct Bind_Invoker<void, 8> {
8844 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8845 void invoke(t_FUNC *func,
8846 t_BOUND_TUPLE *boundList,
8847 t_ARG_TUPLE& argList) const
8848 {
8849 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8850 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8851 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8));
8852 }
8853};
8854
8855/// Invoker for functions that take nine arguments.
8856template <class t_RET>
8857struct Bind_Invoker<t_RET, 9> {
8858 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8859 t_RET invoke(t_FUNC *func,
8860 t_BOUND_TUPLE *boundList,
8861 t_ARG_TUPLE& argList) const
8862 {
8863 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8864 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8865 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9)
8866 );
8867 }
8868};
8869
8870/// Invoker for functions that take nine arguments.
8871template <>
8872struct Bind_Invoker<void, 9> {
8873 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8874 void invoke(t_FUNC *func,
8875 t_BOUND_TUPLE *boundList,
8876 t_ARG_TUPLE& argList) const
8877 {
8878 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8879 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8880 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9));
8881 }
8882};
8883
8884/// Invoker for functions that take nine arguments.
8885template <class t_RET>
8886struct Bind_Invoker<t_RET, 10> {
8887 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8888 t_RET invoke(t_FUNC *func,
8889 t_BOUND_TUPLE *boundList,
8890 t_ARG_TUPLE& argList) const
8891 {
8892 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8893 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8894 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8895 BDLF_BIND_EVAL(10));
8896 }
8897};
8898
8899/// Invoker for functions that take ten arguments and return void.
8900template <>
8901struct Bind_Invoker<void, 10> {
8902 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8903 void invoke(t_FUNC *func,
8904 t_BOUND_TUPLE *boundList,
8905 t_ARG_TUPLE& argList) const
8906 {
8907 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8908 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8909 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8910 BDLF_BIND_EVAL(10));
8911 }
8912};
8913
8914/// Invoker for functions that take eleven arguments.
8915template <class t_RET>
8916struct Bind_Invoker<t_RET, 11> {
8917 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8918 t_RET invoke(t_FUNC *func,
8919 t_BOUND_TUPLE *boundList,
8920 t_ARG_TUPLE& argList) const
8921 {
8922 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8923 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8924 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8925 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
8926 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
8927 BDLF_BIND_EVAL(11));
8928 }
8929};
8930
8931/// Invoker for functions that take eleven arguments and return void.
8932template <>
8933struct Bind_Invoker<void, 11> {
8934 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8935 void invoke(t_FUNC *func,
8936 t_BOUND_TUPLE *boundList,
8937 t_ARG_TUPLE& argList) const
8938 {
8939 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),BDLF_BIND_EVAL(3),
8940 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8941 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8942 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11));
8943 }
8944};
8945
8946/// Invoker for functions that take nine arguments.
8947template <class t_RET>
8948struct Bind_Invoker<t_RET, 12> {
8949 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8950 t_RET invoke(t_FUNC *func,
8951 t_BOUND_TUPLE *boundList,
8952 t_ARG_TUPLE& argList) const
8953 {
8954 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8955 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8956 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8957 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
8958 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
8959 BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12));
8960 }
8961};
8962
8963/// Invoker for functions that take twelve arguments and return void.
8964template <>
8965struct Bind_Invoker<void, 12> {
8966 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8967 void invoke(t_FUNC *func,
8968 t_BOUND_TUPLE *boundList,
8969 t_ARG_TUPLE& argList) const
8970 {
8971 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8972 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8973 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8974 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12));
8975 }
8976};
8977
8978/// Invoker for functions that take thirteen arguments.
8979template <class t_RET>
8980struct Bind_Invoker<t_RET, 13> {
8981 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8982 t_RET invoke(t_FUNC *func,
8983 t_BOUND_TUPLE *boundList,
8984 t_ARG_TUPLE& argList) const
8985 {
8986 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8987 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8988 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8989 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
8990 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
8991 BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12),
8992 BDLF_BIND_EVAL(13));
8993 }
8994};
8995
8996/// Invoker for functions that take thirteen arguments and return void.
8997template <>
8998struct Bind_Invoker<void, 13> {
8999 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9000 void invoke(t_FUNC *func,
9001 t_BOUND_TUPLE *boundList,
9002 t_ARG_TUPLE& argList) const
9003 {
9004 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
9005 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9006 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9007 BDLF_BIND_EVAL(10),BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9008 BDLF_BIND_EVAL(13));
9009 }
9010};
9011
9012/// Invoker for functions that take fourteen arguments.
9013template <class t_RET>
9014struct Bind_Invoker<t_RET, 14> {
9015 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9016 t_RET invoke(t_FUNC *func,
9017 t_BOUND_TUPLE *boundList,
9018 t_ARG_TUPLE& argList) const
9019 {
9020 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
9021 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
9022 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9023 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
9024 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
9025 BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9026 BDLF_BIND_EVAL(13), BDLF_BIND_EVAL(14));
9027 }
9028};
9029
9030/// Invoker for functions that take fourteen arguments and return void.
9031template <>
9032struct Bind_Invoker<void, 14> {
9033 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9034 void invoke(t_FUNC *func,
9035 t_BOUND_TUPLE *boundList,
9036 t_ARG_TUPLE& argList) const
9037 {
9038 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
9039 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9040 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9041 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9042 BDLF_BIND_EVAL(13), BDLF_BIND_EVAL(14));
9043 }
9044};
9045} // close package namespace
9046
9047#undef BDLF_BIND_EVAL
9048
9049namespace bdlf {
9050 // ====================
9051 // class Bind_Evaluator
9052 // ====================
9053
9054/// This utility provides a default argument evaluator that simply returns
9055/// whatever value is passed.
9056template <class t_BOUND_TUPLE_ELEMENT, class t_ARG_TUPLE>
9057struct Bind_Evaluator {
9058
9059 typedef typename bslmf::ArrayToConstPointer<t_BOUND_TUPLE_ELEMENT>::Type
9060 BoundType_Impl;
9061 typedef typename bslmf::ForwardingRefType<BoundType_Impl>::Type BoundType;
9062
9063 /// Return the specified `value`.
9064 static
9065 BoundType eval(t_ARG_TUPLE&, BoundType value)
9066 {
9067 return value;
9068 }
9069};
9070
9071/// This partial specialization of `Bind_Evaluator` provides an argument
9072/// evaluator that substitutes the place-holder at position `t_INDEX` with
9073/// the corresponding element in the specified `t_ARG_TUPLE`.
9074template <int t_INDEX, class t_ARG_TUPLE>
9075struct Bind_Evaluator<PlaceHolder<t_INDEX>, t_ARG_TUPLE> {
9076
9077 // PUBLIC TYPES
9078 typedef typename bslmf::ArrayToConstPointer<
9079 typename bslmf::TypeListTypeOf<t_INDEX,
9080 t_ARG_TUPLE>::TypeOrDefault>::Type
9081 ReturnType_Impl;
9082 typedef typename bslmf::ForwardingType<ReturnType_Impl>::Type ReturnType;
9083
9084 // CLASS METHODS
9085
9086 /// Return the first value from the specified `argTuple`.
9087 static
9088 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<1>&)
9089 {
9090 return *(&argTuple.d_a1.value());
9091 }
9092
9093 /// Return the second value from the specified `argTuple`.
9094 static
9095 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<2>&)
9096 {
9097 return *(&argTuple.d_a2.value());
9098 }
9099
9100 /// Return the third value from the specified `argTuple`.
9101 static
9102 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<3>&)
9103 {
9104 return *(&argTuple.d_a3.value());
9105 }
9106
9107 /// Return the fourth value from the specified `argTuple`.
9108 static
9109 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<4>&)
9110 {
9111 return *(&argTuple.d_a4.value());
9112 }
9113
9114 /// Return the fifth value from the specified `argTuple`.
9115 static
9116 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<5>&)
9117 {
9118 return *(&argTuple.d_a5.value());
9119 }
9120
9121 /// Return the sixth value from the specified `argTuple`.
9122 static
9123 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<6>&)
9124 {
9125 return *(&argTuple.d_a6.value());
9126 }
9127
9128 /// Return the seventh value from the specified `argTuple`.
9129 static
9130 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<7>&)
9131 {
9132 return *(&argTuple.d_a7.value());
9133 }
9134
9135 /// Return the eighth value from the specified `argTuple`.
9136 static
9137 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<8>&)
9138 {
9139 return *(&argTuple.d_a8.value());
9140 }
9141
9142 /// Return the ninth value from the specified `argTuple`.
9143 static
9144 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<9>&)
9145 {
9146 return *(&argTuple.d_a9.value());
9147 }
9148
9149 /// Return the tenth value from the specified `argTuple`.
9150 static
9151 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<10>&)
9152 {
9153 return *(&argTuple.d_a10.value());
9154 }
9155
9156 /// Return the eleventh value from the specified `argTuple`.
9157 static
9158 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<11>&)
9159 {
9160 return *(&argTuple.d_a11.value());
9161 }
9162
9163 /// Return the twelfth value from the specified `argTuple`.
9164 static
9165 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<12>&)
9166 {
9167 return *(&argTuple.d_a12.value());
9168 }
9169
9170 /// Return the thirteenth value from the specified `argTuple`.
9171 static
9172 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<13>&)
9173 {
9174 return *(&argTuple.d_a13.value());
9175 }
9176
9177 /// Return the fourteenth value from the specified `argTuple`.
9178 static
9179 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<14>&)
9180 {
9181 return *(&argTuple.d_a14.value());
9182 }
9183};
9184
9185/// This utility provides an evaluator for nested `Bind` arguments. The
9186/// `Bind` function object is invoked using the provided argument list and
9187/// the result is returned.
9188template <class t_RET, class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9189struct Bind_Evaluator<Bind<t_RET, t_FUNC, t_BOUND_TUPLE>, t_ARG_TUPLE> {
9190
9191 /// Call the specified `func` functor with the specified `argList`
9192 /// arguments and return the result.
9193 static
9194 typename Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
9195 eval(t_ARG_TUPLE& argList,
9196 const Bind<t_RET, t_FUNC, t_BOUND_TUPLE>& func)
9197 {
9198 return func.invoke(argList);
9199 }
9200};
9201
9202/// This utility provides an evaluator for nested `BindWrapper` arguments.
9203/// It is a specialization of the `Bind_Evaluator` declared in the
9204/// @ref bdlf_bind component to enable nested `BindWrapper` objects in the same
9205/// fashion as nested `Bind` objects. The underlying `Bind` function object
9206/// is invoked using the provided argument list and the result is returned.
9207template <class t_RET, class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9208struct Bind_Evaluator<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE>, t_ARG_TUPLE> {
9209
9210 /// Call the specified `func` functor with the specified `argList`
9211 /// arguments and return the result.
9212 static inline typename Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
9213 eval(t_ARG_TUPLE& argList,
9214 const BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE>& func)
9215 {
9216 return func.invoke(argList);
9217 }
9218};
9219
9220} // close package namespace
9221
9222
9223
9224#endif
9225
9226// ----------------------------------------------------------------------------
9227// Copyright 2019 Bloomberg Finance L.P.
9228//
9229// Licensed under the Apache License, Version 2.0 (the "License");
9230// you may not use this file except in compliance with the License.
9231// You may obtain a copy of the License at
9232//
9233// http://www.apache.org/licenses/LICENSE-2.0
9234//
9235// Unless required by applicable law or agreed to in writing, software
9236// distributed under the License is distributed on an "AS IS" BASIS,
9237// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
9238// See the License for the specific language governing permissions and
9239// limitations under the License.
9240// ----------------------------- END-OF-FILE ----------------------------------
9241
9242/** @} */
9243/** @} */
9244/** @} */
bdlf_memfn.h
bdlf_placeholder.h
bslalg_constructorproxy.h
bslma_allocator.h
bslma_usesbslmaallocator.h
bslmf_arraytopointer.h
bslmf_conditional.h
bslmf_forwardingreftype.h
bslmf_forwardingtype.h
bslmf_functionpointertraits.h
bslmf_haspointersemantics.h
bslmf_if.h
bslmf_isbitwisemoveable.h
bslmf_isnothrowmoveconstructible.h
bslmf_matchanytype.h
bslmf_memberfunctionpointertraits.h
bslmf_nestedtraitdeclaration.h
bslmf_nil.h
bslmf_removecv.h
bslmf_resulttype.h
bslmf_tag.h
bslmf_typelist.h
bslmf_voidtype.h
bsls_compilerfeatures.h
bsls_ident.h
bsls_keyword.h
bdlf::BindUtil
Definition bdlf_bind.h:1793
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple6< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
Definition bdlf_bind.h:3962
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, bdlf::Bind_BoundTuple0 > bindSR(bslma::Allocator *allocator, t_FUNC func)
Definition bdlf_bind.h:3785
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple11< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
Definition bdlf_bind.h:3516
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple9< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
Definition bdlf_bind.h:4112
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple1< typename Storage_Type< P1 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
Definition bdlf_bind.h:3102
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple8< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
Definition bdlf_bind.h:3348
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple13< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
Definition bdlf_bind.h:2960
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple8< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
Definition bdlf_bind.h:2050
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple7< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
Definition bdlf_bind.h:3300
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple8< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
Definition bdlf_bind.h:4058
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple7< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
Definition bdlf_bind.h:2008
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple4< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
Definition bdlf_bind.h:3181
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple10< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
Definition bdlf_bind.h:3456
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple9< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
Definition bdlf_bind.h:2096
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple3< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
Definition bdlf_bind.h:3150
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple14< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type, typename Storage_Type< P14 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13, BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
Definition bdlf_bind.h:3030
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple12< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
Definition bdlf_bind.h:2259
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple7< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
Definition bdlf_bind.h:2631
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple1< typename Storage_Type< P1 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
Definition bdlf_bind.h:2459
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple14< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type, typename Storage_Type< P14 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13, BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
Definition bdlf_bind.h:3723
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple5< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
Definition bdlf_bind.h:3921
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple12< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
Definition bdlf_bind.h:4301
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0 > bindS(bslma::Allocator *allocator, t_FUNC func)
Definition bdlf_bind.h:3087
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple13< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
Definition bdlf_bind.h:4373
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple10< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
Definition bdlf_bind.h:2776
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple5< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
Definition bdlf_bind.h:3216
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple11< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
Definition bdlf_bind.h:2833
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple2< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
Definition bdlf_bind.h:1861
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple14< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type, typename Storage_Type< P14 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13, BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
Definition bdlf_bind.h:4449
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple4< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
Definition bdlf_bind.h:3884
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple3< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
Definition bdlf_bind.h:3851
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple9< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
Definition bdlf_bind.h:2723
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple2< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
Definition bdlf_bind.h:3823
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple6< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
Definition bdlf_bind.h:2591
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple10< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
Definition bdlf_bind.h:4171
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple3< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
Definition bdlf_bind.h:1882
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple14< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type, typename Storage_Type< P14 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13, BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
Definition bdlf_bind.h:2389
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple11< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
Definition bdlf_bind.h:2200
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple8< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
Definition bdlf_bind.h:2675
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple0 > bind(t_FUNC func)
Definition bdlf_bind.h:1830
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple2< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
Definition bdlf_bind.h:2476
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple0 > bindR(t_FUNC func)
Definition bdlf_bind.h:2445
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple9< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
Definition bdlf_bind.h:3400
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple5< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
Definition bdlf_bind.h:1936
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple5< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
Definition bdlf_bind.h:2556
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple3< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
Definition bdlf_bind.h:2498
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple11< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
Definition bdlf_bind.h:4234
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple4< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
Definition bdlf_bind.h:1907
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple6< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
Definition bdlf_bind.h:3256
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple1< typename Storage_Type< P1 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
Definition bdlf_bind.h:3801
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple10< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
Definition bdlf_bind.h:2146
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple1< typename Storage_Type< P1 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
Definition bdlf_bind.h:1843
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple12< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
Definition bdlf_bind.h:2894
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple12< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
Definition bdlf_bind.h:3581
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple13< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
Definition bdlf_bind.h:3650
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, Bind_BoundTuple7< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type > > bindSR(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
Definition bdlf_bind.h:4008
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple4< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type > > bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
Definition bdlf_bind.h:2525
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple6< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
Definition bdlf_bind.h:1970
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, Bind_BoundTuple2< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type > > bindS(bslma::Allocator *allocator, t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
Definition bdlf_bind.h:3123
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple13< typename Storage_Type< P1 >::type, typename Storage_Type< P2 >::type, typename Storage_Type< P3 >::type, typename Storage_Type< P4 >::type, typename Storage_Type< P5 >::type, typename Storage_Type< P6 >::type, typename Storage_Type< P7 >::type, typename Storage_Type< P8 >::type, typename Storage_Type< P9 >::type, typename Storage_Type< P10 >::type, typename Storage_Type< P11 >::type, typename Storage_Type< P12 >::type, typename Storage_Type< P13 >::type > > bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1, BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2, BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3, BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4, BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5, BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6, BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7, BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8, BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9, BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10, BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11, BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12, BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
Definition bdlf_bind.h:2322
bdlf::BindWrapper
Definition bdlf_bind.h:1314
bdlf::BindWrapper::BindWrapper
BindWrapper(typename bslmf::ForwardingType< t_FUNC >::Type func, const t_BOUND_TUPLE &tuple, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1344
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11) const
Definition bdlf_bind.h:1662
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7) const
Definition bdlf_bind.h:1544
bdlf::BindWrapper::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:1385
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12, P13 &p13, P14 &p14) const
Definition bdlf_bind.h:1737
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3) const
Definition bdlf_bind.h:1457
bdlf::BindWrapper::BindWrapper
BindWrapper(typename bslmf::ForwardingType< t_FUNC >::Type func, bslmf::MovableRef< t_BOUND_TUPLE > tuple, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1354
bdlf::BindWrapper::BindWrapper
BindWrapper(const BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE > &original)
Definition bdlf_bind.h:1366
bdlf::BindWrapper::BindWrapper
BindWrapper(bslmf::MovableRef< BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE > > original) BSLS_KEYWORD_NOEXCEPT
Definition bdlf_bind.h:1373
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10) const
Definition bdlf_bind.h:1635
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11) const
Definition bdlf_bind.h:1649
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4) const
Definition bdlf_bind.h:1488
bdlf::BindWrapper::ResultType
bdlf::Bind< t_RET, t_FUNC, t_BOUND_TUPLE >::ResultType ResultType
The return type of this binder object.
Definition bdlf_bind.h:1337
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2) const
Definition bdlf_bind.h:1437
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1) const
Definition bdlf_bind.h:1427
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9) const
Definition bdlf_bind.h:1596
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2) const
Definition bdlf_bind.h:1447
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4) const
Definition bdlf_bind.h:1478
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5) const
Definition bdlf_bind.h:1509
bdlf::BindWrapper::operator->
const bdlf::Bind< t_RET, t_FUNC, t_BOUND_TUPLE > * operator->() const
Definition bdlf_bind.h:1399
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12, P13 &p13) const
Definition bdlf_bind.h:1705
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10) const
Definition bdlf_bind.h:1622
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12, P13 const &p13, P14 const &p14) const
Definition bdlf_bind.h:1754
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12) const
Definition bdlf_bind.h:1676
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8) const
Definition bdlf_bind.h:1571
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8) const
Definition bdlf_bind.h:1583
bdlf::BindWrapper::operator*
const bdlf::Bind< t_RET, t_FUNC, t_BOUND_TUPLE > & operator*() const
Definition bdlf_bind.h:1392
bdlf::BindWrapper::operator()
ResultType operator()() const
Definition bdlf_bind.h:1407
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3) const
Definition bdlf_bind.h:1467
bdlf::BindWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bsl::is_nothrow_move_constructible)
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6) const
Definition bdlf_bind.h:1531
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6) const
Definition bdlf_bind.h:1520
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12) const
Definition bdlf_bind.h:1689
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9) const
Definition bdlf_bind.h:1608
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7) const
Definition bdlf_bind.h:1557
bdlf::BindWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::IsBitwiseMoveable)
bdlf::BindWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::HasPointerSemantics)
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1) const
Definition bdlf_bind.h:1417
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5) const
Definition bdlf_bind.h:1499
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12, P13 const &p13) const
Definition bdlf_bind.h:1720
bdlf::Bind_ArgTupleValue< TYPE & >::value
TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:4584
bdlf::Bind_ArgTupleValue< TYPE & >::value
const TYPE & value() const
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:4589
bdlf::Bind_ArgTupleValue< TYPE & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE & > &original)
Definition bdlf_bind.h:4569
bdlf::Bind_ArgTupleValue< TYPE & >::Bind_ArgTupleValue
Bind_ArgTupleValue(TYPE &value)
Definition bdlf_bind.h:4576
bdlf::Bind_ArgTupleValue< TYPE const & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const TYPE &value)
Definition bdlf_bind.h:4614
bdlf::Bind_ArgTupleValue< TYPE const & >::value
const TYPE & value() const
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:4627
bdlf::Bind_ArgTupleValue< TYPE const & >::value
const TYPE & value()
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:4622
bdlf::Bind_ArgTupleValue< TYPE const & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE const & > &original)
Definition bdlf_bind.h:4607
bdlf::Bind_ArgTupleValue
Definition bdlf_bind.h:4518
bdlf::Bind_ArgTupleValue::value
const STORAGE_TYPE & value() const
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:4551
bdlf::Bind_ArgTupleValue::Bind_ArgTupleValue
Bind_ArgTupleValue(TYPE value)
Definition bdlf_bind.h:4538
bdlf::Bind_ArgTupleValue::value
STORAGE_TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:4546
bdlf::Bind_ArgTupleValue::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE > &original)
Definition bdlf_bind.h:4531
bdlf::Bind_BoundTupleValue
Definition bdlf_bind.h:1098
bdlf::Bind_BoundTupleValue::value
TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:1148
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(bslmf::MovableRef< TYPE > value, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1139
bdlf::Bind_BoundTupleValue::value
const TYPE & value() const
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:1153
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(const TYPE &value, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1131
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(bslmf::MovableRef< Bind_BoundTupleValue< TYPE > > original, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1120
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(const Bind_BoundTupleValue< TYPE > &original, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1111
bdlf::Bind_ImplExplicit
Definition bdlf_bind.h:5966
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14) const
Definition bdlf_bind.h:6278
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13) const
Definition bdlf_bind.h:6263
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(const Bind_ImplExplicit &other, bslma::Allocator *allocator)
Definition bdlf_bind.h:6079
bdlf::Bind_ImplExplicit::ResultType
Traits::ResultType ResultType
The return type of this binder object.
Definition bdlf_bind.h:5975
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9) const
Definition bdlf_bind.h:6211
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
Definition bdlf_bind.h:6176
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) const
Definition bdlf_bind.h:6187
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1) const
Definition bdlf_bind.h:6121
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(bslmf::MovableRef< Bind_ImplExplicit > other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:6086
bdlf::Bind_ImplExplicit::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_ImplExplicit, bslma::UsesBslmaAllocator)
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const
Definition bdlf_bind.h:6165
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2) const
Definition bdlf_bind.h:6132
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) const
Definition bdlf_bind.h:6199
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4) const
Definition bdlf_bind.h:6154
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) const
Definition bdlf_bind.h:6236
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10) const
Definition bdlf_bind.h:6223
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12) const
Definition bdlf_bind.h:6249
bdlf::Bind_ImplExplicit::operator()
ResultType operator()() const
Definition bdlf_bind.h:6111
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(typename bslmf::ForwardingType< t_FUNC >::Type func, t_BOUND_TUPLE const &list, bslma::Allocator *allocator)
Definition bdlf_bind.h:6061
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(typename bslmf::ForwardingType< t_FUNC >::Type func, bslmf::MovableRef< t_BOUND_TUPLE > list, bslma::Allocator *allocator)
Definition bdlf_bind.h:6071
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3) const
Definition bdlf_bind.h:6143
bdlf::Bind_ImplExplicit::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:6103
bdlf::Bind_Impl
Definition bdlf_bind.h:5379
bdlf::Bind_Impl::ResultType
Traits::ResultType ResultType
Definition bdlf_bind.h:5388
bdlf::Bind_Impl::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_Impl, bslma::UsesBslmaAllocator)
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3) const
Definition bdlf_bind.h:5574
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12, P13 const &p13, P14 const &p14) const
Definition bdlf_bind.h:5921
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10) const
Definition bdlf_bind.h:5774
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12, P13 &p13) const
Definition bdlf_bind.h:5863
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9) const
Definition bdlf_bind.h:5741
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11) const
Definition bdlf_bind.h:5792
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(typename bslmf::ForwardingType< t_FUNC >::Type func, bslmf::MovableRef< t_BOUND_TUPLE > list, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5448
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4) const
Definition bdlf_bind.h:5586
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1) const
Definition bdlf_bind.h:5514
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6) const
Definition bdlf_bind.h:5638
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7) const
Definition bdlf_bind.h:5680
bdlf::Bind_Impl::operator()
ResultType operator()() const
Definition bdlf_bind.h:5502
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3) const
Definition bdlf_bind.h:5562
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(typename bslmf::ForwardingType< t_FUNC >::Type func, t_BOUND_TUPLE const &list, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5440
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8) const
Definition bdlf_bind.h:5696
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9) const
Definition bdlf_bind.h:5726
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10) const
Definition bdlf_bind.h:5758
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12, P13 const &p13) const
Definition bdlf_bind.h:5881
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5) const
Definition bdlf_bind.h:5624
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(const Bind_Impl &other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5466
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6) const
Definition bdlf_bind.h:5651
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5) const
Definition bdlf_bind.h:5612
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2) const
Definition bdlf_bind.h:5550
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8) const
Definition bdlf_bind.h:5710
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12) const
Definition bdlf_bind.h:5826
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4) const
Definition bdlf_bind.h:5598
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7) const
Definition bdlf_bind.h:5666
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7, P8 &p8, P9 &p9, P10 &p10, P11 &p11, P12 &p12, P13 &p13, P14 &p14) const
Definition bdlf_bind.h:5903
bdlf::Bind_Impl::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:5494
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11) const
Definition bdlf_bind.h:5808
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2) const
Definition bdlf_bind.h:5538
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(bslmf::MovableRef< Bind_Impl > other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5477
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4, P5 const &p5, P6 const &p6, P7 const &p7, P8 const &p8, P9 const &p9, P10 const &p10, P11 const &p11, P12 const &p12) const
Definition bdlf_bind.h:5842
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1) const
Definition bdlf_bind.h:5526
bdlf::Bind_MemFnObjectWrapper
Definition bdlf_bind.h:6976
bdlf::Bind_MemFnObjectWrapper::Bind_MemFnObjectWrapper
Bind_MemFnObjectWrapper(TYPE *object)
Definition bdlf_bind.h:6989
bdlf::Bind_MemFnObjectWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper, bslmf::IsBitwiseMoveable)
bdlf::Bind_MemFnObjectWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper, bslmf::HasPointerSemantics)
bdlf::Bind_MemFnObjectWrapper::Bind_MemFnObjectWrapper
Bind_MemFnObjectWrapper(TYPE &object)
Definition bdlf_bind.h:6991
bdlf::Bind_MemFnObjectWrapper::operator*
TYPE & operator*() const
Definition bdlf_bind.h:7000
bdlf::Bind
Definition bdlf_bind.h:1229
bdlf::Bind::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind, bslma::UsesBslmaAllocator)
bdlf::Bind::Bind
Bind(typename bslmf::ForwardingType< t_FUNC >::Type func, bslmf::MovableRef< t_BOUND_TUPLE > list, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1263
bdlf::Bind::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< t_FUNC >::value &&bslmf::IsBitwiseMoveable< t_BOUND_TUPLE >::value) Bind(typename bslmf
Definition bdlf_bind.h:1239
bdlf::Bind::Bind
Bind(const Bind &other, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1274
bdlf::Bind::Bind
Bind(bslmf::MovableRef< Bind > other, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1288
bdlf::MemFn
Definition bdlf_memfn.h:279
bsl::function
Forward declaration.
Definition bslstl_function.h:934
bsl::shared_ptr
Definition bslstl_sharedptr.h:1830
bsl::shared_ptr::ptr
element_type * ptr() const BSLS_KEYWORD_NOEXCEPT
Definition bslstl_sharedptr.h:5688
bsl::shared_ptr::createInplace
void createInplace()
Definition bslstl_sharedptr.h:5448
bslalg::ConstructorProxy
Definition bslalg_constructorproxy.h:368
bslalg::ConstructorProxy::object
OBJECT_TYPE & object() BSLS_KEYWORD_NOEXCEPT
Return a reference to the modifiable object held by this proxy.
Definition bslalg_constructorproxy.h:1187
bslma::Allocator
Definition bslma_allocator.h:457
bslmf::ForwardingRefType::Type
Imp::Type Type
Definition bslmf_forwardingreftype.h:272
bslmf::ForwardingType
Definition bslmf_forwardingtype.h:428
bslmf::ForwardingType::Type
Imp::Type Type
Definition bslmf_forwardingtype.h:439
bslmf::MovableRef
Definition bslmf_movableref.h:751
BDLF_BIND_EVAL
#define BDLF_BIND_EVAL(N)
Definition bdlf_bind.h:8618
BDLF_BIND_PARAMINDEX
#define BDLF_BIND_PARAMINDEX(N)
Definition bdlf_bind.h:7078
BSLMF_ASSERT
#define BSLMF_ASSERT(expr)
Definition bslmf_assert.h:229
BSLS_COMPILERFEATURES_FORWARD_REF
#define BSLS_COMPILERFEATURES_FORWARD_REF(T)
Definition bsls_compilerfeatures.h:2012
BSLS_COMPILERFEATURES_FORWARD
#define BSLS_COMPILERFEATURES_FORWARD(T, V)
Definition bsls_compilerfeatures.h:2018
BSLS_IDENT
#define BSLS_IDENT(str)
Definition bsls_ident.h:195
BSLS_KEYWORD_NOEXCEPT
#define BSLS_KEYWORD_NOEXCEPT
Definition bsls_keyword.h:632
bdlf
Definition bdlf_bind.h:976
bsl
Definition bdlb_printmethods.h:283
bslmf
Definition bdlbb_blob.h:576
bdlf::Bind_ArgTuple0
This struct provides the creators for a list of zero arguments.
Definition bdlf_bind.h:4636
bdlf::Bind_ArgTuple0::Bind_ArgTuple0
Bind_ArgTuple0(const Bind_ArgTuple0 &)
Definition bdlf_bind.h:4642
bdlf::Bind_ArgTuple0::Bind_ArgTuple0
Bind_ArgTuple0()
Definition bdlf_bind.h:4639
bdlf::Bind_ArgTuple10
This struct stores a list of ten arguments.
Definition bdlf_bind.h:5010
bdlf::Bind_ArgTuple10::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5020
bdlf::Bind_ArgTuple10::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5014
bdlf::Bind_ArgTuple10::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5019
bdlf::Bind_ArgTuple10::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5025
bdlf::Bind_ArgTuple10::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5026
bdlf::Bind_ArgTuple10::Bind_ArgTuple10
Bind_ArgTuple10(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9, FA10 a10)
Definition bdlf_bind.h:5052
bdlf::Bind_ArgTuple10::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5028
bdlf::Bind_ArgTuple10::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5018
bdlf::Bind_ArgTuple10::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5022
bdlf::Bind_ArgTuple10::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5029
bdlf::Bind_ArgTuple10::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5034
bdlf::Bind_ArgTuple10::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5021
bdlf::Bind_ArgTuple10::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5032
bdlf::Bind_ArgTuple10::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5031
bdlf::Bind_ArgTuple10::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5033
bdlf::Bind_ArgTuple10::Bind_ArgTuple10
Bind_ArgTuple10(const Bind_ArgTuple10< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > &orig)
Definition bdlf_bind.h:5037
bdlf::Bind_ArgTuple10::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5027
bdlf::Bind_ArgTuple10::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5030
bdlf::Bind_ArgTuple10::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5013
bdlf::Bind_ArgTuple10::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5017
bdlf::Bind_ArgTuple10::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5016
bdlf::Bind_ArgTuple10::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5015
bdlf::Bind_ArgTuple11
This struct stores a list of eleven arguments.
Definition bdlf_bind.h:5072
bdlf::Bind_ArgTuple11::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5094
bdlf::Bind_ArgTuple11::Bind_ArgTuple11
Bind_ArgTuple11(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11)
Definition bdlf_bind.h:5117
bdlf::Bind_ArgTuple11::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5089
bdlf::Bind_ArgTuple11::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5076
bdlf::Bind_ArgTuple11::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5098
bdlf::Bind_ArgTuple11::Bind_ArgTuple11
Bind_ArgTuple11(const Bind_ArgTuple11< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 > &orig)
Definition bdlf_bind.h:5101
bdlf::Bind_ArgTuple11::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5092
bdlf::Bind_ArgTuple11::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5093
bdlf::Bind_ArgTuple11::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5080
bdlf::Bind_ArgTuple11::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5091
bdlf::Bind_ArgTuple11::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5083
bdlf::Bind_ArgTuple11::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5079
bdlf::Bind_ArgTuple11::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5085
bdlf::Bind_ArgTuple11::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5081
bdlf::Bind_ArgTuple11::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5095
bdlf::Bind_ArgTuple11::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5082
bdlf::Bind_ArgTuple11::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5077
bdlf::Bind_ArgTuple11::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5090
bdlf::Bind_ArgTuple11::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5096
bdlf::Bind_ArgTuple11::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5097
bdlf::Bind_ArgTuple11::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5078
bdlf::Bind_ArgTuple11::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5075
bdlf::Bind_ArgTuple11::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5084
bdlf::Bind_ArgTuple11::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5088
bdlf::Bind_ArgTuple12
This struct stores a list of twelve arguments.
Definition bdlf_bind.h:5139
bdlf::Bind_ArgTuple12::Bind_ArgTuple12
Bind_ArgTuple12(const Bind_ArgTuple12< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 > &orig)
Definition bdlf_bind.h:5170
bdlf::Bind_ArgTuple12::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5145
bdlf::Bind_ArgTuple12::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5151
bdlf::Bind_ArgTuple12::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5152
bdlf::Bind_ArgTuple12::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5165
bdlf::Bind_ArgTuple12::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5143
bdlf::Bind_ArgTuple12::Bind_ArgTuple12
Bind_ArgTuple12(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12)
Definition bdlf_bind.h:5187
bdlf::Bind_ArgTuple12::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5156
bdlf::Bind_ArgTuple12::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5164
bdlf::Bind_ArgTuple12::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5167
bdlf::Bind_ArgTuple12::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5161
bdlf::Bind_ArgTuple12::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5148
bdlf::Bind_ArgTuple12::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5144
bdlf::Bind_ArgTuple12::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5159
bdlf::Bind_ArgTuple12::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5153
bdlf::Bind_ArgTuple12::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5158
bdlf::Bind_ArgTuple12::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5160
bdlf::Bind_ArgTuple12::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5147
bdlf::Bind_ArgTuple12::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5150
bdlf::Bind_ArgTuple12::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5166
bdlf::Bind_ArgTuple12::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5163
bdlf::Bind_ArgTuple12::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5149
bdlf::Bind_ArgTuple12::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5146
bdlf::Bind_ArgTuple12::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5142
bdlf::Bind_ArgTuple12::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5162
bdlf::Bind_ArgTuple12::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5157
bdlf::Bind_ArgTuple13
This struct stores a list of thirteen arguments.
Definition bdlf_bind.h:5210
bdlf::Bind_ArgTuple13::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5239
bdlf::Bind_ArgTuple13::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5235
bdlf::Bind_ArgTuple13::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5238
bdlf::Bind_ArgTuple13::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5216
bdlf::Bind_ArgTuple13::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5234
bdlf::Bind_ArgTuple13::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5231
bdlf::Bind_ArgTuple13::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5228
bdlf::Bind_ArgTuple13::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5237
bdlf::Bind_ArgTuple13::FA13
bslmf::ForwardingType< A13 >::Type FA13
Definition bdlf_bind.h:5225
bdlf::Bind_ArgTuple13::d_a13
Bind_ArgTupleValue< FA13 > d_a13
Definition bdlf_bind.h:5240
bdlf::Bind_ArgTuple13::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5217
bdlf::Bind_ArgTuple13::Bind_ArgTuple13
Bind_ArgTuple13(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12, FA13 a13)
Definition bdlf_bind.h:5261
bdlf::Bind_ArgTuple13::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5230
bdlf::Bind_ArgTuple13::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5229
bdlf::Bind_ArgTuple13::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5236
bdlf::Bind_ArgTuple13::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5224
bdlf::Bind_ArgTuple13::Bind_ArgTuple13
Bind_ArgTuple13(const Bind_ArgTuple13< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 > &orig)
Definition bdlf_bind.h:5243
bdlf::Bind_ArgTuple13::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5219
bdlf::Bind_ArgTuple13::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5233
bdlf::Bind_ArgTuple13::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5218
bdlf::Bind_ArgTuple13::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5223
bdlf::Bind_ArgTuple13::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5215
bdlf::Bind_ArgTuple13::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5214
bdlf::Bind_ArgTuple13::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5232
bdlf::Bind_ArgTuple13::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5221
bdlf::Bind_ArgTuple13::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5222
bdlf::Bind_ArgTuple13::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5220
bdlf::Bind_ArgTuple13::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5213
bdlf::Bind_ArgTuple14
This struct stores a list of fourteen arguments.
Definition bdlf_bind.h:5286
bdlf::Bind_ArgTuple14::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5292
bdlf::Bind_ArgTuple14::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5298
bdlf::Bind_ArgTuple14::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5294
bdlf::Bind_ArgTuple14::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5289
bdlf::Bind_ArgTuple14::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5305
bdlf::Bind_ArgTuple14::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5291
bdlf::Bind_ArgTuple14::d_a13
Bind_ArgTupleValue< FA13 > d_a13
Definition bdlf_bind.h:5317
bdlf::Bind_ArgTuple14::Bind_ArgTuple14
Bind_ArgTuple14(const Bind_ArgTuple14< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 > &orig)
Definition bdlf_bind.h:5321
bdlf::Bind_ArgTuple14::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5296
bdlf::Bind_ArgTuple14::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5300
bdlf::Bind_ArgTuple14::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5311
bdlf::Bind_ArgTuple14::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5314
bdlf::Bind_ArgTuple14::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5307
bdlf::Bind_ArgTuple14::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5315
bdlf::Bind_ArgTuple14::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5309
bdlf::Bind_ArgTuple14::d_a14
Bind_ArgTupleValue< FA14 > d_a14
Definition bdlf_bind.h:5318
bdlf::Bind_ArgTuple14::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5297
bdlf::Bind_ArgTuple14::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5306
bdlf::Bind_ArgTuple14::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5293
bdlf::Bind_ArgTuple14::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5299
bdlf::Bind_ArgTuple14::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5308
bdlf::Bind_ArgTuple14::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5290
bdlf::Bind_ArgTuple14::FA14
bslmf::ForwardingType< A14 >::Type FA14
Definition bdlf_bind.h:5302
bdlf::Bind_ArgTuple14::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5310
bdlf::Bind_ArgTuple14::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5313
bdlf::Bind_ArgTuple14::Bind_ArgTuple14
Bind_ArgTuple14(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12, FA13 a13, FA14 a14)
Definition bdlf_bind.h:5340
bdlf::Bind_ArgTuple14::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5295
bdlf::Bind_ArgTuple14::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5312
bdlf::Bind_ArgTuple14::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5316
bdlf::Bind_ArgTuple14::FA13
bslmf::ForwardingType< A13 >::Type FA13
Definition bdlf_bind.h:5301
bdlf::Bind_ArgTuple1
This struct stores a list of one argument.
Definition bdlf_bind.h:4650
bdlf::Bind_ArgTuple1::Bind_ArgTuple1
Bind_ArgTuple1(FA1 a1)
Definition bdlf_bind.h:4664
bdlf::Bind_ArgTuple1::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4656
bdlf::Bind_ArgTuple1::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4653
bdlf::Bind_ArgTuple1::Bind_ArgTuple1
Bind_ArgTuple1(const Bind_ArgTuple1< A1 > &orig)
Definition bdlf_bind.h:4659
bdlf::Bind_ArgTuple2
This struct stores a list of two arguments.
Definition bdlf_bind.h:4673
bdlf::Bind_ArgTuple2::Bind_ArgTuple2
Bind_ArgTuple2(FA1 a1, FA2 a2)
Definition bdlf_bind.h:4690
bdlf::Bind_ArgTuple2::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4680
bdlf::Bind_ArgTuple2::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4676
bdlf::Bind_ArgTuple2::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4677
bdlf::Bind_ArgTuple2::Bind_ArgTuple2
Bind_ArgTuple2(const Bind_ArgTuple2< A1, A2 > &orig)
Definition bdlf_bind.h:4684
bdlf::Bind_ArgTuple2::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4681
bdlf::Bind_ArgTuple3
This struct stores a list of three arguments.
Definition bdlf_bind.h:4700
bdlf::Bind_ArgTuple3::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4708
bdlf::Bind_ArgTuple3::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4703
bdlf::Bind_ArgTuple3::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4709
bdlf::Bind_ArgTuple3::Bind_ArgTuple3
Bind_ArgTuple3(FA1 a1, FA2 a2, FA3 a3)
Definition bdlf_bind.h:4720
bdlf::Bind_ArgTuple3::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4705
bdlf::Bind_ArgTuple3::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4710
bdlf::Bind_ArgTuple3::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4704
bdlf::Bind_ArgTuple3::Bind_ArgTuple3
Bind_ArgTuple3(const Bind_ArgTuple3< A1, A2, A3 > &orig)
Definition bdlf_bind.h:4713
bdlf::Bind_ArgTuple4
This struct stores a list of four arguments.
Definition bdlf_bind.h:4731
bdlf::Bind_ArgTuple4::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4736
bdlf::Bind_ArgTuple4::Bind_ArgTuple4
Bind_ArgTuple4(FA1 a1, FA2 a2, FA3 a3, FA4 a4)
Definition bdlf_bind.h:4754
bdlf::Bind_ArgTuple4::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4737
bdlf::Bind_ArgTuple4::Bind_ArgTuple4
Bind_ArgTuple4(const Bind_ArgTuple4< A1, A2, A3, A4 > &orig)
Definition bdlf_bind.h:4746
bdlf::Bind_ArgTuple4::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4741
bdlf::Bind_ArgTuple4::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4734
bdlf::Bind_ArgTuple4::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4743
bdlf::Bind_ArgTuple4::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4742
bdlf::Bind_ArgTuple4::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4740
bdlf::Bind_ArgTuple4::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4735
bdlf::Bind_ArgTuple5
This struct stores a list of five arguments.
Definition bdlf_bind.h:4766
bdlf::Bind_ArgTuple5::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4777
bdlf::Bind_ArgTuple5::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4776
bdlf::Bind_ArgTuple5::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4780
bdlf::Bind_ArgTuple5::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4769
bdlf::Bind_ArgTuple5::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4772
bdlf::Bind_ArgTuple5::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4773
bdlf::Bind_ArgTuple5::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4770
bdlf::Bind_ArgTuple5::Bind_ArgTuple5
Bind_ArgTuple5(const Bind_ArgTuple5< A1, A2, A3, A4, A5 > &orig)
Definition bdlf_bind.h:4783
bdlf::Bind_ArgTuple5::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4778
bdlf::Bind_ArgTuple5::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4771
bdlf::Bind_ArgTuple5::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4779
bdlf::Bind_ArgTuple5::Bind_ArgTuple5
Bind_ArgTuple5(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5)
Definition bdlf_bind.h:4792
bdlf::Bind_ArgTuple6
This struct stores a list of six arguments.
Definition bdlf_bind.h:4805
bdlf::Bind_ArgTuple6::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4812
bdlf::Bind_ArgTuple6::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4820
bdlf::Bind_ArgTuple6::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4808
bdlf::Bind_ArgTuple6::Bind_ArgTuple6
Bind_ArgTuple6(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6)
Definition bdlf_bind.h:4834
bdlf::Bind_ArgTuple6::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4813
bdlf::Bind_ArgTuple6::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4810
bdlf::Bind_ArgTuple6::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4821
bdlf::Bind_ArgTuple6::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4817
bdlf::Bind_ArgTuple6::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4809
bdlf::Bind_ArgTuple6::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4811
bdlf::Bind_ArgTuple6::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4816
bdlf::Bind_ArgTuple6::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4818
bdlf::Bind_ArgTuple6::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4819
bdlf::Bind_ArgTuple6::Bind_ArgTuple6
Bind_ArgTuple6(const Bind_ArgTuple6< A1, A2, A3, A4, A5, A6 > &orig)
Definition bdlf_bind.h:4824
bdlf::Bind_ArgTuple7
This struct stores a list of seven arguments.
Definition bdlf_bind.h:4848
bdlf::Bind_ArgTuple7::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4862
bdlf::Bind_ArgTuple7::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4856
bdlf::Bind_ArgTuple7::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4852
bdlf::Bind_ArgTuple7::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4853
bdlf::Bind_ArgTuple7::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4866
bdlf::Bind_ArgTuple7::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4851
bdlf::Bind_ArgTuple7::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4864
bdlf::Bind_ArgTuple7::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4854
bdlf::Bind_ArgTuple7::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4863
bdlf::Bind_ArgTuple7::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4857
bdlf::Bind_ArgTuple7::Bind_ArgTuple7
Bind_ArgTuple7(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7)
Definition bdlf_bind.h:4881
bdlf::Bind_ArgTuple7::Bind_ArgTuple7
Bind_ArgTuple7(const Bind_ArgTuple7< A1, A2, A3, A4, A5, A6, A7 > &orig)
Definition bdlf_bind.h:4870
bdlf::Bind_ArgTuple7::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4855
bdlf::Bind_ArgTuple7::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4861
bdlf::Bind_ArgTuple7::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4865
bdlf::Bind_ArgTuple7::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4860
bdlf::Bind_ArgTuple8
This struct stores a list of eight arguments.
Definition bdlf_bind.h:4897
bdlf::Bind_ArgTuple8::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4906
bdlf::Bind_ArgTuple8::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4911
bdlf::Bind_ArgTuple8::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4910
bdlf::Bind_ArgTuple8::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4904
bdlf::Bind_ArgTuple8::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4914
bdlf::Bind_ArgTuple8::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4901
bdlf::Bind_ArgTuple8::Bind_ArgTuple8
Bind_ArgTuple8(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8)
Definition bdlf_bind.h:4933
bdlf::Bind_ArgTuple8::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4912
bdlf::Bind_ArgTuple8::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4915
bdlf::Bind_ArgTuple8::Bind_ArgTuple8
Bind_ArgTuple8(const Bind_ArgTuple8< A1, A2, A3, A4, A5, A6, A7, A8 > &orig)
Definition bdlf_bind.h:4921
bdlf::Bind_ArgTuple8::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4916
bdlf::Bind_ArgTuple8::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4902
bdlf::Bind_ArgTuple8::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4900
bdlf::Bind_ArgTuple8::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4905
bdlf::Bind_ArgTuple8::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4913
bdlf::Bind_ArgTuple8::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:4917
bdlf::Bind_ArgTuple8::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4903
bdlf::Bind_ArgTuple8::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:4907
bdlf::Bind_ArgTuple9
This struct stores a list of nine arguments.
Definition bdlf_bind.h:4951
bdlf::Bind_ArgTuple9::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:4961
bdlf::Bind_ArgTuple9::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4960
bdlf::Bind_ArgTuple9::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:4972
bdlf::Bind_ArgTuple9::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4969
bdlf::Bind_ArgTuple9::Bind_ArgTuple9
Bind_ArgTuple9(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7, FA8 a8, FA9 a9)
Definition bdlf_bind.h:4990
bdlf::Bind_ArgTuple9::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4954
bdlf::Bind_ArgTuple9::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4958
bdlf::Bind_ArgTuple9::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4968
bdlf::Bind_ArgTuple9::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4965
bdlf::Bind_ArgTuple9::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4957
bdlf::Bind_ArgTuple9::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4956
bdlf::Bind_ArgTuple9::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4959
bdlf::Bind_ArgTuple9::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4966
bdlf::Bind_ArgTuple9::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:4962
bdlf::Bind_ArgTuple9::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4967
bdlf::Bind_ArgTuple9::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:4973
bdlf::Bind_ArgTuple9::Bind_ArgTuple9
Bind_ArgTuple9(const Bind_ArgTuple9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > &orig)
Definition bdlf_bind.h:4977
bdlf::Bind_ArgTuple9::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4971
bdlf::Bind_ArgTuple9::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4970
bdlf::Bind_ArgTuple9::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4955
bdlf::Bind_BoundTuple0
This struct provides the creators for a list of zero arguments.
Definition bdlf_bind.h:1161
bdlf::Bind_BoundTuple0::Bind_BoundTuple0
Bind_BoundTuple0(const Bind_BoundTuple0 &, bslma::Allocator *=0)
Definition bdlf_bind.h:1172
bdlf::Bind_BoundTuple0::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_BoundTuple0, bslmf::IsBitwiseMoveable)
bdlf::Bind_BoundTuple0::Bind_BoundTuple0
Bind_BoundTuple0()
Definition bdlf_bind.h:1168
bdlf::Bind_BoundTuple10
Definition bdlf_bind.h:7892
bdlf::Bind_BoundTuple10::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7914
bdlf::Bind_BoundTuple10::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:7917
bdlf::Bind_BoundTuple10::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7911
bdlf::Bind_BoundTuple10::Bind_BoundTuple10
Bind_BoundTuple10(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslmf::MovableRef< A10 > a10, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7988
bdlf::Bind_BoundTuple10::Bind_BoundTuple10
Bind_BoundTuple10(const Bind_BoundTuple10< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7921
bdlf::Bind_BoundTuple10::Bind_BoundTuple10
Bind_BoundTuple10(bslmf::MovableRef< Bind_BoundTuple10< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7937
bdlf::Bind_BoundTuple10::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple10, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value &&bslmf::IsBitwiseMoveable< A10 >::value)
bdlf::Bind_BoundTuple10::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7913
bdlf::Bind_BoundTuple10::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7916
bdlf::Bind_BoundTuple10::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7912
bdlf::Bind_BoundTuple10::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7909
bdlf::Bind_BoundTuple10::Bind_BoundTuple10
Bind_BoundTuple10(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, A10 const &a10, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7964
bdlf::Bind_BoundTuple10::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7910
bdlf::Bind_BoundTuple10::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7915
bdlf::Bind_BoundTuple10::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:7918
bdlf::Bind_BoundTuple11
Definition bdlf_bind.h:8019
bdlf::Bind_BoundTuple11::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8045
bdlf::Bind_BoundTuple11::Bind_BoundTuple11
Bind_BoundTuple11(const Bind_BoundTuple11< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8050
bdlf::Bind_BoundTuple11::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8039
bdlf::Bind_BoundTuple11::Bind_BoundTuple11
Bind_BoundTuple11(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslmf::MovableRef< A10 > a10, bslmf::MovableRef< A11 > a11, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8122
bdlf::Bind_BoundTuple11::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8047
bdlf::Bind_BoundTuple11::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8043
bdlf::Bind_BoundTuple11::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8042
bdlf::Bind_BoundTuple11::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8044
bdlf::Bind_BoundTuple11::Bind_BoundTuple11
Bind_BoundTuple11(bslmf::MovableRef< Bind_BoundTuple11< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8067
bdlf::Bind_BoundTuple11::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple11, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value &&bslmf::IsBitwiseMoveable< A10 >::value &&bslmf::IsBitwiseMoveable< A11 >::value)
bdlf::Bind_BoundTuple11::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8038
bdlf::Bind_BoundTuple11::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8037
bdlf::Bind_BoundTuple11::Bind_BoundTuple11
Bind_BoundTuple11(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, A10 const &a10, A11 const &a11, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8096
bdlf::Bind_BoundTuple11::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8046
bdlf::Bind_BoundTuple11::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8041
bdlf::Bind_BoundTuple11::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8040
bdlf::Bind_BoundTuple12
Definition bdlf_bind.h:8155
bdlf::Bind_BoundTuple12::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8183
bdlf::Bind_BoundTuple12::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple12, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value &&bslmf::IsBitwiseMoveable< A10 >::value &&bslmf::IsBitwiseMoveable< A11 >::value &&bslmf::IsBitwiseMoveable< A12 >::value)
bdlf::Bind_BoundTuple12::Bind_BoundTuple12
Bind_BoundTuple12(const Bind_BoundTuple12< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8188
bdlf::Bind_BoundTuple12::Bind_BoundTuple12
Bind_BoundTuple12(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, A10 const &a10, A11 const &a11, A12 const &a12, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8237
bdlf::Bind_BoundTuple12::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8174
bdlf::Bind_BoundTuple12::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8175
bdlf::Bind_BoundTuple12::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8177
bdlf::Bind_BoundTuple12::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8178
bdlf::Bind_BoundTuple12::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8181
bdlf::Bind_BoundTuple12::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8180
bdlf::Bind_BoundTuple12::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8182
bdlf::Bind_BoundTuple12::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8179
bdlf::Bind_BoundTuple12::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8185
bdlf::Bind_BoundTuple12::Bind_BoundTuple12
Bind_BoundTuple12(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslmf::MovableRef< A10 > a10, bslmf::MovableRef< A11 > a11, bslmf::MovableRef< A12 > a12, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8265
bdlf::Bind_BoundTuple12::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8176
bdlf::Bind_BoundTuple12::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8184
bdlf::Bind_BoundTuple12::Bind_BoundTuple12
Bind_BoundTuple12(bslmf::MovableRef< Bind_BoundTuple12< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8206
bdlf::Bind_BoundTuple13
Definition bdlf_bind.h:8301
bdlf::Bind_BoundTuple13::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8327
bdlf::Bind_BoundTuple13::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8331
bdlf::Bind_BoundTuple13::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8325
bdlf::Bind_BoundTuple13::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8329
bdlf::Bind_BoundTuple13::d_a13
Bind_BoundTupleValue< A13 > d_a13
Definition bdlf_bind.h:8333
bdlf::Bind_BoundTuple13::Bind_BoundTuple13
Bind_BoundTuple13(const Bind_BoundTuple13< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8336
bdlf::Bind_BoundTuple13::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8322
bdlf::Bind_BoundTuple13::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8321
bdlf::Bind_BoundTuple13::Bind_BoundTuple13
Bind_BoundTuple13(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslmf::MovableRef< A10 > a10, bslmf::MovableRef< A11 > a11, bslmf::MovableRef< A12 > a12, bslmf::MovableRef< A13 > a13, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8418
bdlf::Bind_BoundTuple13::Bind_BoundTuple13
Bind_BoundTuple13(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, A10 const &a10, A11 const &a11, A12 const &a12, A13 const &a13, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8388
bdlf::Bind_BoundTuple13::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8328
bdlf::Bind_BoundTuple13::Bind_BoundTuple13
Bind_BoundTuple13(bslmf::MovableRef< Bind_BoundTuple13< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8355
bdlf::Bind_BoundTuple13::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8330
bdlf::Bind_BoundTuple13::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8332
bdlf::Bind_BoundTuple13::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8324
bdlf::Bind_BoundTuple13::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8323
bdlf::Bind_BoundTuple13::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple13, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value &&bslmf::IsBitwiseMoveable< A10 >::value &&bslmf::IsBitwiseMoveable< A11 >::value &&bslmf::IsBitwiseMoveable< A12 >::value &&bslmf::IsBitwiseMoveable< A13 >::value)
bdlf::Bind_BoundTuple13::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8326
bdlf::Bind_BoundTuple14
Definition bdlf_bind.h:8456
bdlf::Bind_BoundTuple14::Bind_BoundTuple14
Bind_BoundTuple14(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslmf::MovableRef< A10 > a10, bslmf::MovableRef< A11 > a11, bslmf::MovableRef< A12 > a12, bslmf::MovableRef< A13 > a13, bslmf::MovableRef< A14 > a14, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8580
bdlf::Bind_BoundTuple14::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8479
bdlf::Bind_BoundTuple14::d_a14
Bind_BoundTupleValue< A14 > d_a14
Definition bdlf_bind.h:8490
bdlf::Bind_BoundTuple14::Bind_BoundTuple14
Bind_BoundTuple14(const Bind_BoundTuple14< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8493
bdlf::Bind_BoundTuple14::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8487
bdlf::Bind_BoundTuple14::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8480
bdlf::Bind_BoundTuple14::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple14, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value &&bslmf::IsBitwiseMoveable< A10 >::value &&bslmf::IsBitwiseMoveable< A11 >::value &&bslmf::IsBitwiseMoveable< A12 >::value &&bslmf::IsBitwiseMoveable< A13 >::value &&bslmf::IsBitwiseMoveable< A14 >::value)
bdlf::Bind_BoundTuple14::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8486
bdlf::Bind_BoundTuple14::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8482
bdlf::Bind_BoundTuple14::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8483
bdlf::Bind_BoundTuple14::Bind_BoundTuple14
Bind_BoundTuple14(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, A10 const &a10, A11 const &a11, A12 const &a12, A13 const &a13, A14 const &a14, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8548
bdlf::Bind_BoundTuple14::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8477
bdlf::Bind_BoundTuple14::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8485
bdlf::Bind_BoundTuple14::d_a13
Bind_BoundTupleValue< A13 > d_a13
Definition bdlf_bind.h:8489
bdlf::Bind_BoundTuple14::Bind_BoundTuple14
Bind_BoundTuple14(bslmf::MovableRef< Bind_BoundTuple14< A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:8513
bdlf::Bind_BoundTuple14::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8478
bdlf::Bind_BoundTuple14::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8484
bdlf::Bind_BoundTuple14::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8488
bdlf::Bind_BoundTuple14::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8481
bdlf::Bind_BoundTuple1
Definition bdlf_bind.h:1182
bdlf::Bind_BoundTuple1::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:1190
bdlf::Bind_BoundTuple1::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple1, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value)
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(bslmf::MovableRef< Bind_BoundTuple1< A1 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1199
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(const Bind_BoundTuple1< A1 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1193
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(bslmf::MovableRef< A1 > a1, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1212
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(A1 const &a1, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1207
bdlf::Bind_BoundTuple2
Definition bdlf_bind.h:7214
bdlf::Bind_BoundTuple2::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7223
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(A1 const &a1, A2 const &a2, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7244
bdlf::Bind_BoundTuple2::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7224
bdlf::Bind_BoundTuple2::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple2, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value)
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(bslmf::MovableRef< Bind_BoundTuple2< A1, A2 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7234
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(const Bind_BoundTuple2< A1, A2 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7227
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7252
bdlf::Bind_BoundTuple3
Definition bdlf_bind.h:7266
bdlf::Bind_BoundTuple3::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7278
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7311
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(bslmf::MovableRef< Bind_BoundTuple3< A1, A2, A3 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7289
bdlf::Bind_BoundTuple3::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple3, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value)
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(const Bind_BoundTuple3< A1, A2, A3 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7281
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(A1 const &a1, A2 const &a2, A3 const &a3, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7301
bdlf::Bind_BoundTuple3::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7276
bdlf::Bind_BoundTuple3::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7277
bdlf::Bind_BoundTuple4
Definition bdlf_bind.h:7327
bdlf::Bind_BoundTuple4::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7339
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(const Bind_BoundTuple4< A1, A2, A3, A4 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7344
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7379
bdlf::Bind_BoundTuple4::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple4, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value)
bdlf::Bind_BoundTuple4::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7338
bdlf::Bind_BoundTuple4::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7341
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(bslmf::MovableRef< Bind_BoundTuple4< A1, A2, A3, A4 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7353
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7367
bdlf::Bind_BoundTuple4::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7340
bdlf::Bind_BoundTuple5
Definition bdlf_bind.h:7397
bdlf::Bind_BoundTuple5::Bind_BoundTuple5
Bind_BoundTuple5(bslmf::MovableRef< Bind_BoundTuple5< A1, A2, A3, A4, A5 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7426
bdlf::Bind_BoundTuple5::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7411
bdlf::Bind_BoundTuple5::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple5, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value)
bdlf::Bind_BoundTuple5::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7413
bdlf::Bind_BoundTuple5::Bind_BoundTuple5
Bind_BoundTuple5(const Bind_BoundTuple5< A1, A2, A3, A4, A5 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7416
bdlf::Bind_BoundTuple5::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7410
bdlf::Bind_BoundTuple5::Bind_BoundTuple5
Bind_BoundTuple5(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7456
bdlf::Bind_BoundTuple5::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7409
bdlf::Bind_BoundTuple5::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7412
bdlf::Bind_BoundTuple5::Bind_BoundTuple5
Bind_BoundTuple5(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7442
bdlf::Bind_BoundTuple6
Definition bdlf_bind.h:7476
bdlf::Bind_BoundTuple6::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7491
bdlf::Bind_BoundTuple6::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7493
bdlf::Bind_BoundTuple6::Bind_BoundTuple6
Bind_BoundTuple6(bslmf::MovableRef< Bind_BoundTuple6< A1, A2, A3, A4, A5, A6 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7508
bdlf::Bind_BoundTuple6::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7494
bdlf::Bind_BoundTuple6::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7489
bdlf::Bind_BoundTuple6::Bind_BoundTuple6
Bind_BoundTuple6(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7527
bdlf::Bind_BoundTuple6::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple6, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value)
bdlf::Bind_BoundTuple6::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7492
bdlf::Bind_BoundTuple6::Bind_BoundTuple6
Bind_BoundTuple6(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7543
bdlf::Bind_BoundTuple6::Bind_BoundTuple6
Bind_BoundTuple6(const Bind_BoundTuple6< A1, A2, A3, A4, A5, A6 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7497
bdlf::Bind_BoundTuple6::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7490
bdlf::Bind_BoundTuple7
Definition bdlf_bind.h:7565
bdlf::Bind_BoundTuple7::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7583
bdlf::Bind_BoundTuple7::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple7, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value)
bdlf::Bind_BoundTuple7::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7582
bdlf::Bind_BoundTuple7::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7585
bdlf::Bind_BoundTuple7::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7581
bdlf::Bind_BoundTuple7::Bind_BoundTuple7
Bind_BoundTuple7(bslmf::MovableRef< Bind_BoundTuple7< A1, A2, A3, A4, A5, A6, A7 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7601
bdlf::Bind_BoundTuple7::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7580
bdlf::Bind_BoundTuple7::Bind_BoundTuple7
Bind_BoundTuple7(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7622
bdlf::Bind_BoundTuple7::Bind_BoundTuple7
Bind_BoundTuple7(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7640
bdlf::Bind_BoundTuple7::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7584
bdlf::Bind_BoundTuple7::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7579
bdlf::Bind_BoundTuple7::Bind_BoundTuple7
Bind_BoundTuple7(const Bind_BoundTuple7< A1, A2, A3, A4, A5, A6, A7 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7588
bdlf::Bind_BoundTuple8
Definition bdlf_bind.h:7665
bdlf::Bind_BoundTuple8::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7683
bdlf::Bind_BoundTuple8::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7687
bdlf::Bind_BoundTuple8::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7685
bdlf::Bind_BoundTuple8::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7684
bdlf::Bind_BoundTuple8::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7686
bdlf::Bind_BoundTuple8::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7680
bdlf::Bind_BoundTuple8::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple8, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value)
bdlf::Bind_BoundTuple8::Bind_BoundTuple8
Bind_BoundTuple8(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7747
bdlf::Bind_BoundTuple8::Bind_BoundTuple8
Bind_BoundTuple8(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7727
bdlf::Bind_BoundTuple8::Bind_BoundTuple8
Bind_BoundTuple8(const Bind_BoundTuple8< A1, A2, A3, A4, A5, A6, A7, A8 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7690
bdlf::Bind_BoundTuple8::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7681
bdlf::Bind_BoundTuple8::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7682
bdlf::Bind_BoundTuple8::Bind_BoundTuple8
Bind_BoundTuple8(bslmf::MovableRef< Bind_BoundTuple8< A1, A2, A3, A4, A5, A6, A7, A8 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7704
bdlf::Bind_BoundTuple9
Definition bdlf_bind.h:7774
bdlf::Bind_BoundTuple9::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7790
bdlf::Bind_BoundTuple9::BSLMF_NESTED_TRAIT_DECLARATION_IF
BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple9, bslmf::IsBitwiseMoveable, bslmf::IsBitwiseMoveable< A1 >::value &&bslmf::IsBitwiseMoveable< A2 >::value &&bslmf::IsBitwiseMoveable< A3 >::value &&bslmf::IsBitwiseMoveable< A4 >::value &&bslmf::IsBitwiseMoveable< A5 >::value &&bslmf::IsBitwiseMoveable< A6 >::value &&bslmf::IsBitwiseMoveable< A7 >::value &&bslmf::IsBitwiseMoveable< A8 >::value &&bslmf::IsBitwiseMoveable< A9 >::value)
bdlf::Bind_BoundTuple9::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:7798
bdlf::Bind_BoundTuple9::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7796
bdlf::Bind_BoundTuple9::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7794
bdlf::Bind_BoundTuple9::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7797
bdlf::Bind_BoundTuple9::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7793
bdlf::Bind_BoundTuple9::Bind_BoundTuple9
Bind_BoundTuple9(const Bind_BoundTuple9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7801
bdlf::Bind_BoundTuple9::Bind_BoundTuple9
Bind_BoundTuple9(A1 const &a1, A2 const &a2, A3 const &a3, A4 const &a4, A5 const &a5, A6 const &a6, A7 const &a7, A8 const &a8, A9 const &a9, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7841
bdlf::Bind_BoundTuple9::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7791
bdlf::Bind_BoundTuple9::Bind_BoundTuple9
Bind_BoundTuple9(bslmf::MovableRef< Bind_BoundTuple9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7816
bdlf::Bind_BoundTuple9::Bind_BoundTuple9
Bind_BoundTuple9(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslmf::MovableRef< A3 > a3, bslmf::MovableRef< A4 > a4, bslmf::MovableRef< A5 > a5, bslmf::MovableRef< A6 > a6, bslmf::MovableRef< A7 > a7, bslmf::MovableRef< A8 > a8, bslmf::MovableRef< A9 > a9, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7863
bdlf::Bind_BoundTuple9::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7795
bdlf::Bind_BoundTuple9::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7792
bdlf::Bind_CalcParameterMask
Definition bdlf_bind.h:7099
bdlf::Bind_CalcParameterMask::Type8
t_BOUND_TUPLE::template TypeOf< 8 >::TypeOrDefault Type8
Definition bdlf_bind.h:7108
bdlf::Bind_CalcParameterMask::Type2
t_BOUND_TUPLE::template TypeOf< 2 >::TypeOrDefault Type2
Definition bdlf_bind.h:7102
bdlf::Bind_CalcParameterMask::Type10
t_BOUND_TUPLE::template TypeOf< 10 >::TypeOrDefault Type10
Definition bdlf_bind.h:7110
bdlf::Bind_CalcParameterMask::Type6
t_BOUND_TUPLE::template TypeOf< 6 >::TypeOrDefault Type6
Definition bdlf_bind.h:7106
bdlf::Bind_CalcParameterMask::Type3
t_BOUND_TUPLE::template TypeOf< 3 >::TypeOrDefault Type3
Definition bdlf_bind.h:7103
bdlf::Bind_CalcParameterMask::Type4
t_BOUND_TUPLE::template TypeOf< 4 >::TypeOrDefault Type4
Definition bdlf_bind.h:7104
bdlf::Bind_CalcParameterMask::Type1
t_BOUND_TUPLE::template TypeOf< 1 >::TypeOrDefault Type1
Definition bdlf_bind.h:7101
bdlf::Bind_CalcParameterMask::Type7
t_BOUND_TUPLE::template TypeOf< 7 >::TypeOrDefault Type7
Definition bdlf_bind.h:7107
bdlf::Bind_CalcParameterMask::k_PARAM_MASK
@ k_PARAM_MASK
Definition bdlf_bind.h:7137
bdlf::Bind_CalcParameterMask::k_PARAMINDEX10
@ k_PARAMINDEX10
Definition bdlf_bind.h:7192
bdlf::Bind_CalcParameterMask::k_PARAM8
@ k_PARAM8
Definition bdlf_bind.h:7124
bdlf::Bind_CalcParameterMask::k_PARAM2
@ k_PARAM2
Definition bdlf_bind.h:7118
bdlf::Bind_CalcParameterMask::k_PARAM3
@ k_PARAM3
Definition bdlf_bind.h:7119
bdlf::Bind_CalcParameterMask::k_PARAMINDEX13
@ k_PARAMINDEX13
Definition bdlf_bind.h:7195
bdlf::Bind_CalcParameterMask::k_PARAM4
@ k_PARAM4
Definition bdlf_bind.h:7120
bdlf::Bind_CalcParameterMask::k_PARAM13
@ k_PARAM13
Definition bdlf_bind.h:7129
bdlf::Bind_CalcParameterMask::k_PARAM7
@ k_PARAM7
Definition bdlf_bind.h:7123
bdlf::Bind_CalcParameterMask::k_PARAMINDEX7
@ k_PARAMINDEX7
Definition bdlf_bind.h:7189
bdlf::Bind_CalcParameterMask::k_PARAMINDEX5
@ k_PARAMINDEX5
Definition bdlf_bind.h:7187
bdlf::Bind_CalcParameterMask::k_PARAMINDEX9
@ k_PARAMINDEX9
Definition bdlf_bind.h:7191
bdlf::Bind_CalcParameterMask::k_PARAM5
@ k_PARAM5
Definition bdlf_bind.h:7121
bdlf::Bind_CalcParameterMask::k_PARAM11
@ k_PARAM11
Definition bdlf_bind.h:7127
bdlf::Bind_CalcParameterMask::k_PARAMINDEX11
@ k_PARAMINDEX11
Definition bdlf_bind.h:7193
bdlf::Bind_CalcParameterMask::k_PARAMINDEX12
@ k_PARAMINDEX12
Definition bdlf_bind.h:7194
bdlf::Bind_CalcParameterMask::k_PARAMINDEX14
@ k_PARAMINDEX14
Definition bdlf_bind.h:7196
bdlf::Bind_CalcParameterMask::k_PARAM_MASK2
@ k_PARAM_MASK2
Definition bdlf_bind.h:7153
bdlf::Bind_CalcParameterMask::k_PARAMINDEX8
@ k_PARAMINDEX8
Definition bdlf_bind.h:7190
bdlf::Bind_CalcParameterMask::k_PARAM10
@ k_PARAM10
Definition bdlf_bind.h:7126
bdlf::Bind_CalcParameterMask::k_PARAM6
@ k_PARAM6
Definition bdlf_bind.h:7122
bdlf::Bind_CalcParameterMask::k_PARAMINDEX1
@ k_PARAMINDEX1
Definition bdlf_bind.h:7183
bdlf::Bind_CalcParameterMask::k_PARAMINDEX6
@ k_PARAMINDEX6
Definition bdlf_bind.h:7188
bdlf::Bind_CalcParameterMask::k_PARAMINDEX2
@ k_PARAMINDEX2
Definition bdlf_bind.h:7184
bdlf::Bind_CalcParameterMask::k_PARAM14
@ k_PARAM14
Definition bdlf_bind.h:7130
bdlf::Bind_CalcParameterMask::k_PARAM1
@ k_PARAM1
Definition bdlf_bind.h:7117
bdlf::Bind_CalcParameterMask::k_IS_EXPLICIT
@ k_IS_EXPLICIT
Definition bdlf_bind.h:7172
bdlf::Bind_CalcParameterMask::k_PARAMINDEX4
@ k_PARAMINDEX4
Definition bdlf_bind.h:7186
bdlf::Bind_CalcParameterMask::k_PARAM9
@ k_PARAM9
Definition bdlf_bind.h:7125
bdlf::Bind_CalcParameterMask::k_PARAM12
@ k_PARAM12
Definition bdlf_bind.h:7128
bdlf::Bind_CalcParameterMask::k_PARAMINDEX3
@ k_PARAMINDEX3
Definition bdlf_bind.h:7185
bdlf::Bind_CalcParameterMask::Type13
t_BOUND_TUPLE::template TypeOf< 13 >::TypeOrDefault Type13
Definition bdlf_bind.h:7113
bdlf::Bind_CalcParameterMask::Type12
t_BOUND_TUPLE::template TypeOf< 12 >::TypeOrDefault Type12
Definition bdlf_bind.h:7112
bdlf::Bind_CalcParameterMask::Type14
t_BOUND_TUPLE::template TypeOf< 14 >::TypeOrDefault Type14
Definition bdlf_bind.h:7114
bdlf::Bind_CalcParameterMask::Type9
t_BOUND_TUPLE::template TypeOf< 9 >::TypeOrDefault Type9
Definition bdlf_bind.h:7109
bdlf::Bind_CalcParameterMask::Type11
t_BOUND_TUPLE::template TypeOf< 11 >::TypeOrDefault Type11
Definition bdlf_bind.h:7111
bdlf::Bind_CalcParameterMask::Type5
t_BOUND_TUPLE::template TypeOf< 5 >::TypeOrDefault Type5
Definition bdlf_bind.h:7105
bdlf::Bind_Evaluator< BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE >, t_ARG_TUPLE >::eval
static Bind< t_RET, t_FUNC, t_BOUND_TUPLE >::ResultType eval(t_ARG_TUPLE &argList, const BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE > &func)
Definition bdlf_bind.h:9213
bdlf::Bind_Evaluator< Bind< t_RET, t_FUNC, t_BOUND_TUPLE >, t_ARG_TUPLE >::eval
static Bind< t_RET, t_FUNC, t_BOUND_TUPLE >::ResultType eval(t_ARG_TUPLE &argList, const Bind< t_RET, t_FUNC, t_BOUND_TUPLE > &func)
Definition bdlf_bind.h:9195
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 1 > &)
Return the first value from the specified argTuple.
Definition bdlf_bind.h:9088
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 5 > &)
Return the fifth value from the specified argTuple.
Definition bdlf_bind.h:9116
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 9 > &)
Return the ninth value from the specified argTuple.
Definition bdlf_bind.h:9144
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::ReturnType
bslmf::ForwardingType< ReturnType_Impl >::Type ReturnType
Definition bdlf_bind.h:9082
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 12 > &)
Return the twelfth value from the specified argTuple.
Definition bdlf_bind.h:9165
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 2 > &)
Return the second value from the specified argTuple.
Definition bdlf_bind.h:9095
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 10 > &)
Return the tenth value from the specified argTuple.
Definition bdlf_bind.h:9151
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 8 > &)
Return the eighth value from the specified argTuple.
Definition bdlf_bind.h:9137
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 13 > &)
Return the thirteenth value from the specified argTuple.
Definition bdlf_bind.h:9172
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 11 > &)
Return the eleventh value from the specified argTuple.
Definition bdlf_bind.h:9158
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 6 > &)
Return the sixth value from the specified argTuple.
Definition bdlf_bind.h:9123
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 7 > &)
Return the seventh value from the specified argTuple.
Definition bdlf_bind.h:9130
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 3 > &)
Return the third value from the specified argTuple.
Definition bdlf_bind.h:9102
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 14 > &)
Return the fourteenth value from the specified argTuple.
Definition bdlf_bind.h:9179
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::ReturnType_Impl
bslmf::ArrayToConstPointer< typenamebslmf::TypeListTypeOf< t_INDEX, t_ARG_TUPLE >::TypeOrDefault >::Type ReturnType_Impl
Definition bdlf_bind.h:9081
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::eval
static ReturnType eval(t_ARG_TUPLE &argTuple, const PlaceHolder< 4 > &)
Return the fourth value from the specified argTuple.
Definition bdlf_bind.h:9109
bdlf::Bind_Evaluator
Definition bdlf_bind.h:9057
bdlf::Bind_Evaluator::eval
static BoundType eval(t_ARG_TUPLE &, BoundType value)
Return the specified value.
Definition bdlf_bind.h:9065
bdlf::Bind_Evaluator::BoundType
bslmf::ForwardingRefType< BoundType_Impl >::Type BoundType
Definition bdlf_bind.h:9061
bdlf::Bind_Evaluator::BoundType_Impl
bslmf::ArrayToConstPointer< t_BOUND_TUPLE_ELEMENT >::Type BoundType_Impl
Definition bdlf_bind.h:9060
bdlf::Bind_FuncTraitsHasNoEllipsis
Definition bdlf_bind.h:6335
bdlf::Bind_FuncTraitsHasNoEllipsis::k_VAL
@ k_VAL
Definition bdlf_bind.h:6338
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::Type
bsl::function< PROTO > Type
Definition bdlf_bind.h:6767
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::ResultType
bsl::function< PROTO >::result_type ResultType
Definition bdlf_bind.h:6769
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::WrapperType
bsl::function< PROTO > WrapperType
Definition bdlf_bind.h:6768
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::ResultType
bsl::function< PROTO >::result_type ResultType
Definition bdlf_bind.h:6805
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::Type
bsl::function< PROTO > Type
Definition bdlf_bind.h:6803
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::WrapperType
bsl::function< PROTO > * WrapperType
Definition bdlf_bind.h:6804
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6750
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::ResultType
Bind_FuncTraitsImp_OneResultTypeOrAnother< t_FUNC >::type ResultType
Definition bdlf_bind.h:6752
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6749
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::Type
t_FUNC Type
Definition bdlf_bind.h:6727
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::ResultType
bslmf::MemberFunctionPointerTraits< t_FUNC >::ResultType ResultType
Definition bdlf_bind.h:6730
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::FuncArgumentList
bslmf::MemberFunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6732
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::WrapperType
MemFn< t_FUNC > WrapperType
Definition bdlf_bind.h:6728
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::ResultType
bslmf::FunctionPointerTraits< t_FUNC >::ResultType ResultType
Definition bdlf_bind.h:6709
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6706
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6711
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6707
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC * >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6690
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6685
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6686
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::ResultType
bslmf::FunctionPointerTraits< t_FUNC * >::ResultType ResultType
Definition bdlf_bind.h:6688
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::ResultType
Bind_FuncTraitsImp_OneResultTypeOrAnother< t_FUNC >::type ResultType
Definition bdlf_bind.h:6788
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6785
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6786
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6650
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6651
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6652
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::FuncArgumentList
bslmf::MemberFunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6635
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::WrapperType
MemFn< t_FUNC > WrapperType
Definition bdlf_bind.h:6632
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6633
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::Type
t_FUNC Type
Definition bdlf_bind.h:6631
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6613
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6615
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6611
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6612
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6592
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC * >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6595
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::Type
t_FUNC * Type
Definition bdlf_bind.h:6591
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6593
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6667
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6666
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6668
bdlf::Bind_FuncTraitsImp_OneResultTypeOrAnother
Definition bdlf_bind.h:6479
bdlf::Bind_FuncTraitsImp_OneResultTypeOrAnother::type
Result< t_FUNC >::type type
Definition bdlf_bind.h:6551
bdlf::Bind_FuncTraitsImp
Definition bdlf_bind.h:6574
bdlf::Bind_FuncTraits
Definition bdlf_bind.h:6873
bdlf::Bind_ImplSelector
Definition bdlf_bind.h:6305
bdlf::Bind_ImplSelector::Type
bsl::conditional< k_IS_EXPLICIT, Bind_ImplExplicit< t_RET, t_FUNC, t_BOUND_TUPLE >, Bind_Impl< t_RET, t_FUNC, t_BOUND_TUPLE > >::type Type
Definition bdlf_bind.h:6316
bdlf::Bind_ImplSelector::k_IS_EXPLICIT
@ k_IS_EXPLICIT
Definition bdlf_bind.h:6309
bdlf::Bind_Invoker< t_RET, 0 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE &) const
Definition bdlf_bind.h:8628
bdlf::Bind_Invoker< t_RET, 10 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8888
bdlf::Bind_Invoker< t_RET, 11 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8918
bdlf::Bind_Invoker< t_RET, 12 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8950
bdlf::Bind_Invoker< t_RET, 13 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8982
bdlf::Bind_Invoker< t_RET, 14 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9016
bdlf::Bind_Invoker< t_RET, 1 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8648
bdlf::Bind_Invoker< t_RET, 2 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8672
bdlf::Bind_Invoker< t_RET, 3 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8697
bdlf::Bind_Invoker< t_RET, 4 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8722
bdlf::Bind_Invoker< t_RET, 5 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8748
bdlf::Bind_Invoker< t_RET, 6 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8775
bdlf::Bind_Invoker< t_RET, 7 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8802
bdlf::Bind_Invoker< t_RET, 8 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8830
bdlf::Bind_Invoker< t_RET, 9 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8859
bdlf::Bind_Invoker< void, 0 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE &) const
Definition bdlf_bind.h:8638
bdlf::Bind_Invoker< void, 10 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8903
bdlf::Bind_Invoker< void, 11 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8935
bdlf::Bind_Invoker< void, 12 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8967
bdlf::Bind_Invoker< void, 13 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9000
bdlf::Bind_Invoker< void, 14 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9034
bdlf::Bind_Invoker< void, 1 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8660
bdlf::Bind_Invoker< void, 2 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8685
bdlf::Bind_Invoker< void, 3 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8710
bdlf::Bind_Invoker< void, 4 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8735
bdlf::Bind_Invoker< void, 5 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8762
bdlf::Bind_Invoker< void, 6 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8789
bdlf::Bind_Invoker< void, 7 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8816
bdlf::Bind_Invoker< void, 8 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8845
bdlf::Bind_Invoker< void, 9 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8874
bdlf::Bind_Invoker
Definition bdlf_bind.h:979
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 0, t_IS_MEMBER_OFFSET >::Type
const bslmf::MatchAnyType & Type
Definition bdlf_bind.h:7044
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::ObjectType
Traits::ClassType ObjectType
Definition bdlf_bind.h:7032
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::Type
bslmf::ForwardingType< constBind_MemFnObjectWrapper< ObjectType > & >::Type Type
Definition bdlf_bind.h:7034
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::Traits
bslmf::MemberFunctionPointerTraits< t_FUNC > Traits
Definition bdlf_bind.h:7031
bdlf::Bind_MapParameter
Definition bdlf_bind.h:7013
bdlf::Bind_MapParameter::Type
bslmf::ForwardingType< typenamebslmf::TypeListTypeOf< t_INDEX-t_IS_MEMBER_OFFSET, t_FUNC_ARGS, constbslmf::MatchAnyType & >::TypeOrDefault >::Type Type
Definition bdlf_bind.h:7020
bdlf::Bind_PlaceHolderIndex
Definition bdlf_bind.h:6941
bdlf::Bind_PlaceHolderIndex::k_VAL
@ k_VAL
Definition bdlf_bind.h:6944
bdlf::Bind_PlaceHolderMask
Definition bdlf_bind.h:6891
bdlf::Bind_PlaceHolderMask::k_VAL
static const int k_VAL
Definition bdlf_bind.h:6892
bdlf::PlaceHolder
Definition bdlf_placeholder.h:77
bsl::conditional
Definition bslmf_conditional.h:120
bsl::integral_constant
Definition bslmf_integralconstant.h:244
bsl::is_nothrow_move_constructible
Definition bslmf_isnothrowmoveconstructible.h:358
bsl::remove_cv::type
remove_const< typenameremove_volatile< t_TYPE >::type >::type type
Definition bslmf_removecv.h:126
bslma::UsesBslmaAllocator
Definition bslma_usesbslmaallocator.h:343
bslmf::ArrayToConstPointer
Definition bslmf_arraytopointer.h:108
bslmf::ArrayToConstPointer::Type
ArrayToPointer_Imp< constt_TYPE, t_TYPE >::Type Type
Definition bslmf_arraytopointer.h:109
bslmf::FunctionPointerTraits
Definition bslmf_functionpointertraits.h:137
bslmf::HasPointerSemantics
Definition bslmf_haspointersemantics.h:78
bslmf::IsBitwiseMoveable
Definition bslmf_isbitwisemoveable.h:718
bslmf::MatchAnyType
Any type can be converted into this type.
Definition bslmf_matchanytype.h:150
bslmf::MemberFunctionPointerTraits
Definition bslmf_memberfunctionpointertraits.h:150
bslmf::MovableRefUtil::IsReference
Definition bslmf_movableref.h:817
bslmf::MovableRefUtil_RemoveReference::type
t_TYPE type
Definition bslmf_movableref.h:1177
bslmf::MovableRefUtil
Definition bslmf_movableref.h:791
bslmf::MovableRefUtil::move
static MovableRef< t_TYPE > move(t_TYPE &reference) BSLS_KEYWORD_NOEXCEPT
Definition bslmf_movableref.h:1060
bslmf::Nil
This struct is empty and represents a nil type.
Definition bslmf_nil.h:131
bslmf::ResultType_Fallback::type
t_FALLBACK type
Definition bslmf_resulttype.h:260
bslmf::Tag
Definition bslmf_tag.h:163
bslmf::TypeList0
List of 0 types.
Definition bslmf_typelist.h:1643
bslmf::TypeList10
Definition bslmf_typelist.h:1856
bslmf::TypeList11
Definition bslmf_typelist.h:1899
bslmf::TypeList12
Definition bslmf_typelist.h:1945
bslmf::TypeList13
Definition bslmf_typelist.h:1994
bslmf::TypeList14
Definition bslmf_typelist.h:2046
bslmf::TypeList1
List of a single type t_A1 types.
Definition bslmf_typelist.h:1654
bslmf::TypeList2
List of a two types t_A1, t_A2 types.
Definition bslmf_typelist.h:1669
bslmf::TypeList3
List of a three types t_A1, t_A2, t_A3 types.
Definition bslmf_typelist.h:1685
bslmf::TypeList4
Definition bslmf_typelist.h:1703
bslmf::TypeList5
Definition bslmf_typelist.h:1720
bslmf::TypeList6
Definition bslmf_typelist.h:1743
bslmf::TypeList7
Definition bslmf_typelist.h:1768
bslmf::TypeList8
Definition bslmf_typelist.h:1795
bslmf::TypeList9
Definition bslmf_typelist.h:1824
bslmf::TypeListTypeOf
Definition bslmf_typelist.h:1625