BDE 4.39.x 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_movableref.h>
957#include <bslmf_nestedtraitdeclaration.h>
958#include <bslmf_nil.h>
959#include <bslmf_removecv.h>
960#include <bslmf_resulttype.h>
961#include <bslmf_tag.h>
962#include <bslmf_typelist.h>
963#include <bslmf_util.h> // 'forward(V)' for C++03
964#include <bslmf_voidtype.h>
965
966#include <bsls_compilerfeatures.h>
967#include <bsls_keyword.h>
968#include <bsls_util.h> // 'forward<T>(V)' for C++11
969
970#include <bsl_functional.h>
971#include <bsl_memory.h>
972
973#ifndef BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
974#include <bslmf_if.h>
975#endif // BDE_DONT_ALLOW_TRANSITIVE_INCLUDES
976
977
978
979namespace bdlf {
980
981template <class t_RET, class t_FUNC> struct Bind_FuncTraits;
982template <class t_RET, int NUMARGS> struct Bind_Invoker;
983template <class BINDER, class t_ARG_TUPLE> struct Bind_Evaluator;
984
985} // close package namespace
986
987namespace bdlf {
988 struct Bind_BoundTuple0;
989template <class A1>
990 struct Bind_BoundTuple1;
991template <class A1, class A2>
992 struct Bind_BoundTuple2;
993template <class A1, class A2, class A3>
994 struct Bind_BoundTuple3;
995template <class A1, class A2, class A3, class A4>
996 struct Bind_BoundTuple4;
997template <class A1, class A2, class A3, class A4, class A5>
998 struct Bind_BoundTuple5;
999template <class A1, class A2, class A3, class A4, class A5, class A6>
1000 struct Bind_BoundTuple6;
1001template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1002 struct Bind_BoundTuple7;
1003template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1004 class A8>
1005 struct Bind_BoundTuple8;
1006template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1007 class A8, class A9>
1008 struct Bind_BoundTuple9;
1009template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1010 class A8, class A9, class A10>
1011 struct Bind_BoundTuple10;
1012template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1013 class A8, class A9, class A10, class A11>
1014 struct Bind_BoundTuple11;
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>
1017 struct Bind_BoundTuple12;
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 struct Bind_BoundTuple13;
1021template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1022 class A8, class A9, class A10, class A11, class A12, class A13,
1023 class A14>
1024 struct Bind_BoundTuple14;
1025 // 'Bind_BoundTuple ## N' is used by 'Bind' and 'BindWrapper' to
1026 // contain 'N' objects of independent types (some of which may be place
1027 // holders) bound to the functor.
1028
1029} // close package namespace
1030
1031namespace bdlf {
1032
1033 struct Bind_ArgTuple0;
1034template <class A1>
1035 struct Bind_ArgTuple1;
1036template <class A1, class A2>
1037 struct Bind_ArgTuple2;
1038template <class A1, class A2, class A3>
1039 struct Bind_ArgTuple3;
1040template <class A1, class A2, class A3, class A4>
1041 struct Bind_ArgTuple4;
1042template <class A1, class A2, class A3, class A4, class A5>
1043 struct Bind_ArgTuple5;
1044template <class A1, class A2, class A3, class A4, class A5, class A6>
1045 struct Bind_ArgTuple6;
1046template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
1047 struct Bind_ArgTuple7;
1048template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1049 class A8>
1050 struct Bind_ArgTuple8;
1051template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1052 class A8, class A9>
1053 struct Bind_ArgTuple9;
1054template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1055 class A8, class A9, class A10>
1056 struct Bind_ArgTuple10;
1057template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1058 class A8, class A9, class A10, class A11>
1059 struct Bind_ArgTuple11;
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>
1062 struct Bind_ArgTuple12;
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 struct Bind_ArgTuple13;
1066template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
1067 class A8, class A9, class A10, class A11, class A12, class A13,
1068 class A14>
1069 struct Bind_ArgTuple14;
1070 // 'Bind_ArgTuple ## N' is used by a call to a bound function to
1071 // contain 'N' objects (or references to objects) of independent types
1072 // being passed to a call to a bound function, to be forwarded to the
1073 // place holder arguments.
1074
1075template <class t_BOUND_TUPLE> struct Bind_CalcParameterMask;
1076template <class t_FUNC, class t_ARG_TUPLE, int INDEX, int OFFSET>
1077 struct Bind_MapParameter;
1078template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1079 struct Bind_ImplSelector;
1080
1081 // ==========================
1082 // class Bind_BoundTupleValue
1083 // ==========================
1084
1085// IMPLEMENTATION NOTE: This class template, as well as the
1086// 'bind_BoundTuple[0-14]' class templates, are always instantiated with
1087// template argument 'TYPE'. 'TYPE' is one of the 'A[0-14]' template
1088// parameters for 'bind_BoundTuple[0-14]'. Since 'TYPE' is *not* a reference
1089// or const types, it is always appropriate to take any value of these types by
1090// 'const&' to avoid unnecessary copies until the only one and final copy is
1091// done in the constructor proxy.
1092
1093/// This local class provides storage for a value of the specified `TYPE`
1094/// suitable for storing an argument value in one of the `Bind_BoundTuple*`
1095/// local classes. This general template definition ensures that the
1096/// allocator passed to the creators is passed through to the value if it
1097/// uses an allocator, using the `bslalg::ConstructorProxy` mechanism.
1098///
1099/// See @ref bdlf_bind
1100template <class TYPE>
1101class Bind_BoundTupleValue {
1102
1103 BSLMF_ASSERT(!bslmf::MovableRefUtil::IsReference<TYPE>::value);
1104
1105 // PRIVATE INSTANCE DATA
1106 bslalg::ConstructorProxy<TYPE> d_value;
1107
1108 public:
1109 // CREATORS
1110
1111 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1112 /// specified `original` value, using `basicAllocator` to supply any
1113 /// memory.
1114 Bind_BoundTupleValue(const Bind_BoundTupleValue<TYPE>& original,
1115 bslma::Allocator *basicAllocator)
1116 : d_value(original.d_value, basicAllocator)
1117 {
1118 }
1119
1120 /// Create a `Bind_BoundTupleValue` object holding the moved value of
1121 /// the specified `original` value, using `basicAllocator` to supply any
1122 /// memory.
1123 Bind_BoundTupleValue(
1124 bslmf::MovableRef<Bind_BoundTupleValue<TYPE> > original,
1125 bslma::Allocator *basicAllocator)
1126 : d_value(bslmf::MovableRefUtil::move(
1127 bslmf::MovableRefUtil::access(original).d_value),
1128 basicAllocator)
1129 {
1130 }
1131
1132 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1133 /// specified `value`, using `basicAllocator` to supply any memory.
1134 Bind_BoundTupleValue(const TYPE& value,
1135 bslma::Allocator *basicAllocator)
1136 : d_value(value, basicAllocator)
1137 {
1138 }
1139
1140 /// Create a `Bind_BoundTupleValue` object holding a copy of the
1141 /// specified `value`, using `basicAllocator` to supply any memory.
1142 Bind_BoundTupleValue(bslmf::MovableRef<TYPE> value,
1143 bslma::Allocator *basicAllocator)
1144 : d_value(bslmf::MovableRefUtil::move(value), basicAllocator)
1145 {
1146 }
1147
1148 // MANIPULATORS
1149
1150 /// Return a reference to the modifiable object held by this proxy.
1151 TYPE& value() { return d_value.object(); }
1152
1153 // ACCESSORS
1154
1155 /// Return a reference to the non-modifiable object held by this proxy.
1156 const TYPE& value() const { return d_value.object(); }
1157};
1158
1159 // ======================
1160 // class Bind_BoundTuple*
1161 // ======================
1162
1163/// This `struct` provides the creators for a list of zero arguments.
1164struct Bind_BoundTuple0 : bslmf::TypeList0 {
1165
1166 // TRAITS
1167 BSLMF_NESTED_TRAIT_DECLARATION(Bind_BoundTuple0,
1168 bslmf::IsBitwiseMoveable);
1169
1170 // CREATORS
1171 Bind_BoundTuple0()
1172 {
1173 }
1174
1178};
1179
1180/// This `struct` stores a list of one argument. It does *not* use the
1181/// const-forwarding type of its argument, unlike `Bind_ArgTuple1` which
1182/// applies that optimization to avoid unnecessary copying.
1183template <class A1>
1184struct Bind_BoundTuple1 : bslmf::TypeList1<A1>
1185{
1186
1187 // TRAITS
1188 BSLMF_NESTED_TRAIT_DECLARATION_IF(Bind_BoundTuple1,
1189 bslmf::IsBitwiseMoveable,
1190 bslmf::IsBitwiseMoveable<A1>::value);
1191
1192 // INSTANCE DATA
1193 Bind_BoundTupleValue<A1> d_a1;
1194
1195 // CREATORS
1196 Bind_BoundTuple1(const Bind_BoundTuple1<A1>& orig,
1197 bslma::Allocator *allocator = 0)
1198 : d_a1(orig.d_a1, allocator)
1199 {
1200 }
1201
1202 Bind_BoundTuple1(bslmf::MovableRef<Bind_BoundTuple1<A1> > orig,
1203 bslma::Allocator *allocator = 0)
1204 : d_a1(bslmf::MovableRefUtil::move(
1205 bslmf::MovableRefUtil::access(orig).d_a1),
1206 allocator)
1207 {
1208 }
1209
1210 explicit Bind_BoundTuple1(A1 const& a1, bslma::Allocator *allocator = 0)
1211 : d_a1(a1, allocator)
1212 {
1213 }
1214
1215 explicit Bind_BoundTuple1(bslmf::MovableRef<A1> a1,
1216 bslma::Allocator *allocator = 0)
1217 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
1218 {
1219 }
1220};
1221
1222 // ==========
1223 // class Bind
1224 // ==========
1225
1226/// This bind class select the implementation for the given template arguments.
1227///
1228/// \note Note that instances of this class should not be created
1229/// explicitly, instead use the `BindUtil` factory methods.
1230///
1231/// See @ref bdlf_bind
1232template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1233class Bind : public Bind_ImplSelector<t_RET, t_FUNC, t_BOUND_TUPLE>::Type {
1234
1235 // PRIVATE TYPES
1236 typedef typename Bind_ImplSelector<t_RET,
1237 t_FUNC,
1238 t_BOUND_TUPLE>::Type Base;
1239
1240 public:
1241 // TRAITS
1242 BSLMF_NESTED_TRAIT_DECLARATION(Bind, bslma::UsesBslmaAllocator);
1243 BSLMF_NESTED_TRAIT_DECLARATION_IF(
1244 Bind,
1245 bslmf::IsBitwiseMoveable,
1246 bslmf::IsBitwiseMoveable<t_FUNC>::value &&
1247 bslmf::IsBitwiseMoveable<t_BOUND_TUPLE>::value)
1248
1249 // CREATORS
1250
1251 /// Create a `Bind` object that is bound to the specified `func`
1252 /// invocable object with the specified argument list `list`.
1253 /// Optionally specify an `allocator` used to supply memory. If
1254 /// `allocator` is 0, the currently installed default allocator is used.
1255 Bind(typename bslmf::ForwardingType<t_FUNC>::Type func,
1256 t_BOUND_TUPLE const& list,
1257 bslma::Allocator *allocator = 0)
1258 : Base(func, list, allocator)
1259 {
1260 }
1261
1262 /// Create a `Bind` object that is bound to the specified `func`
1263 /// invocable object with the specified argument list `list` moved into
1264 /// the object. Optionally specify an `allocator` used to supply
1265 /// memory. If `allocator` is 0, the currently installed default
1266 /// allocator is used.
1267 Bind(typename bslmf::ForwardingType<t_FUNC>::Type func,
1268 bslmf::MovableRef<t_BOUND_TUPLE> list,
1269 bslma::Allocator *allocator = 0)
1270 : Base(func, bslmf::MovableRefUtil::move(list), allocator)
1271 {
1272 }
1273
1274 /// Create a `Bind` object that is bound to the same invocable object
1275 /// with the same bound parameters as the specified `other`. Optionally
1276 /// specify an `allocator` used to supply memory. If `allocator` is 0,
1277 /// the currently installed default allocator is used.
1278 Bind(const Bind& other, bslma::Allocator *allocator = 0)
1279 : Base(other, allocator)
1280 {
1281 }
1282
1283 // NOTE: This should probably be conditionally noexcept based on
1284 // bsl::is_nothrow_move_constructible for 't_FUNC' and 't_BOUND_TUPLE'.
1285 // Not sure if Bind_BoundTupleValue could be made conditionally nothrow
1286 // move constructible though due to its use of ConstructorProxy
1287
1288 /// Create a `Bind` object that is bound to the same invocable object
1289 /// with the same bound parameters as the specified `other`. Optionally
1290 /// specify an `allocator` used to supply memory. If `allocator` is 0,
1291 /// the currently installed default allocator is used.
1292 Bind(bslmf::MovableRef<Bind> other, bslma::Allocator *allocator = 0)
1293 : Base(bslmf::MovableRefUtil::move(other), allocator)
1294 {
1295 }
1296};
1297
1298 // =================
1299 // class BindWrapper
1300 // =================
1301
1302/// This wrapper class provides a binder with shared pointer semantics to a
1303/// non-modifiable binder (both `operator*` and `operator->` accessors) and
1304/// forward its construction arguments to the underlying binder.
1305///
1306/// \note Note that instances of this class should not be created explicitly, instead use
1307/// the `BindUtil` factory methods. Note also that instances of this class
1308/// can be invoked directly, in order to meet user expectations that the
1309/// result of `BindUtil::bind` be an invocable just as the result of
1310/// `bdlf::BindUtil::bind` is; in that case, the invocation parameters are
1311/// simply forwarded to the shared binder. Note finally that even though
1312/// this wrapper has pointer semantics for the `operator*` and `operator->`,
1313/// it has value semantics for the invocation: invoking a non-modifiable
1314/// wrapper will forward the invocation to the non-modifiable binder shared
1315/// by that wrapper, even though pointer semantics have it .
1316///
1317/// See @ref bdlf_bind
1318template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
1319class BindWrapper {
1320
1321 private:
1322 // PRIVATE TYPES
1323
1324 /// This `typedef` is a convenient alias for the utility associated with
1325 /// movable references.
1326 typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
1327
1328 // DATA
1329 bsl::shared_ptr<const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE> > d_impl;
1330
1331 public:
1332 // TRAITS
1333 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::HasPointerSemantics);
1334 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper, bslmf::IsBitwiseMoveable);
1335 BSLMF_NESTED_TRAIT_DECLARATION(BindWrapper,
1336 bsl::is_nothrow_move_constructible);
1337
1338 // PUBLIC TYPES
1339
1340 /// The return type of this binder object.
1341 typedef typename bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
1342 ResultType;
1343
1344 // CREATORS
1345
1346 /// Create a wrapper with shared pointer semantics around a binder
1347 /// constructed with the specified `func` invocable and specified
1348 /// `tuple` bound arguments. Optionally specify the `allocator`.
1349 BindWrapper(typename bslmf::ForwardingType<t_FUNC>::Type func,
1350 const t_BOUND_TUPLE& tuple,
1351 bslma::Allocator *allocator = 0)
1352 {
1353 this->d_impl.createInplace(allocator, func, tuple, allocator);
1354 }
1355
1356 /// Create a wrapper with shared pointer semantics around a binder
1357 /// constructed with the specified `func` invocable and specified
1358 /// `tuple` bound arguments. Optionally specify the `allocator`.
1359 BindWrapper(typename bslmf::ForwardingType<t_FUNC>::Type func,
1360 bslmf::MovableRef<t_BOUND_TUPLE> tuple,
1361 bslma::Allocator *allocator = 0)
1362 {
1363 this->d_impl.createInplace(allocator,
1364 func,
1365 bslmf::MovableRefUtil::move(tuple),
1366 allocator);
1367 }
1368
1369 /// Create a wrapper that shares ownership of the binder of the
1370 /// specified `original`.
1371 BindWrapper(const BindWrapper<t_RET,t_FUNC,t_BOUND_TUPLE>& original)
1372 : d_impl(original.d_impl)
1373 {
1374 }
1375
1376 /// Create a wrapper that assumes ownership of the binder of the
1377 /// specified `original`.
1378 BindWrapper(bslmf::MovableRef<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE> >
1379 original) BSLS_KEYWORD_NOEXCEPT
1380 : d_impl(MoveUtil::move(MoveUtil::access(original).d_impl))
1381 {
1382 }
1383
1384 //ACCESSORS
1385
1386 /// Invoke the bound object using the invocation parameters provided at
1387 /// construction of this `bdlf::Bind` object, substituting place-holders
1388 /// for their respective values in the specified `arguments`.
1389 template <class t_ARG_TUPLE>
1390 inline ResultType invoke(t_ARG_TUPLE& arguments) const
1391 {
1392 return d_impl->invoke(arguments);
1393 }
1394
1395 /// Return a reference to the non-modifiable binder shared by this
1396 /// wrapper.
1397 const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>& operator*() const
1398 {
1399 return *(this->d_impl);
1400 }
1401
1402 /// Return the address of the non-modifiable binder shared by this
1403 /// wrapper.
1404 const bdlf::Bind<t_RET, t_FUNC, t_BOUND_TUPLE>* operator->() const
1405 {
1406 return this->d_impl.ptr();
1407 }
1408
1409 /// Invoke the bound object using only the invocation parameters
1410 /// provided at construction of this `bdlf::Bind` object and return the
1411 /// result.
1412 inline ResultType operator()() const
1413 {
1414 return (*d_impl)();
1415 }
1416
1417 /// Invoke the bound object using the invocation template provided at
1418 /// construction of this `bdlf::Bind` object, substituting place-holders
1419 /// for argument 1 with the value of the specified argument `p1`.
1420 /// Return the result.
1421 template <class P1>
1422 inline ResultType operator()(P1& p1) const
1423 {
1424 return (*d_impl)(p1);
1425 }
1426
1427 /// Invoke the bound object using the invocation template provided at
1428 /// construction of this `bdlf::Bind` object, substituting place-holders
1429 /// for argument 1 with the value of the specified argument `p1`.
1430 /// Return the result.
1431 template <class P1>
1432 inline ResultType operator()(P1 const& p1) const
1433 {
1434 return (*d_impl)(p1);
1435 }
1436
1437 /// Invoke the bound object using the invocation template provided at
1438 /// construction of this `bdlf::Bind` object, substituting place-holders
1439 /// for arguments 1 and 2 with the value of the specified arguments
1440 /// `p1`, and `p2` respectively. Return the result.
1441 template <class P1, class P2>
1442 inline ResultType operator()(P1& p1, P2& p2) const
1443 {
1444 return (*d_impl)(p1, p2);
1445 }
1446
1447 /// Invoke the bound object using the invocation template provided at
1448 /// construction of this `bdlf::Bind` object, substituting place-holders
1449 /// for arguments 1 and 2 with the value of the specified arguments
1450 /// `p1`, and `p2` respectively. Return the result.
1451 template <class P1, class P2>
1452 inline ResultType operator()(P1 const& p1, P2 const& p2) const
1453 {
1454 return (*d_impl)(p1, p2);
1455 }
1456
1457 /// Invoke the bound object using the invocation template provided at
1458 /// construction of this `bdlf::Bind` object, substituting place-holders
1459 /// for arguments 1, 2, and 3 with the values of the specified arguments
1460 /// `p1`, `p2` and `p3` respectively. Return the result.
1461 template <class P1, class P2, class P3>
1462 inline ResultType operator()(P1& p1, P2& p2, P3& p3) const
1463 {
1464 return (*d_impl)(p1, p2, p3);
1465 }
1466
1467 /// Invoke the bound object using the invocation template provided at
1468 /// construction of this `bdlf::Bind` object, substituting place-holders
1469 /// for arguments 1, 2, and 3 with the values of the specified arguments
1470 /// `p1`, `p2` and `p3` respectively. Return the result.
1471 template <class P1, class P2, class P3>
1472 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3)
1473 const
1474 {
1475 return (*d_impl)(p1, p2, p3);
1476 }
1477
1478 /// Invoke the bound object using the invocation template provided at
1479 /// construction of this `bdlf::Bind` object, substituting place-holders
1480 /// for arguments 1 - 4 with the values of the specified arguments `p1`
1481 /// - `p4` respectively. Return the result.
1482 template <class P1, class P2, class P3, class P4>
1483 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4) const
1484 {
1485 return (*d_impl)(p1, p2, p3, p4);
1486 }
1487
1488 /// Invoke the bound object using the invocation template provided at
1489 /// construction of this `bdlf::Bind` object, substituting place-holders
1490 /// for arguments 1 - 4 with the values of the specified arguments `p1`
1491 /// - `p4` respectively. Return the result.
1492 template <class P1, class P2, class P3, class P4>
1493 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1494 P4 const& p4) const
1495 {
1496 return (*d_impl)(p1, p2, p3, p4);
1497 }
1498
1499 /// Invoke the bound object using the invocation template provided at
1500 /// construction of this `bdlf::Bind` object, substituting place-holders
1501 /// for arguments 1 - 5 with the values of the specified arguments `p1`
1502 /// - `p5` respectively. Return the result.
1503 template <class P1, class P2, class P3, class P4, class P5>
1504 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5) const
1505 {
1506 return (*d_impl)(p1, p2, p3, p4, p5);
1507 }
1508
1509 /// Invoke the bound object using the invocation template provided at
1510 /// construction of this `bdlf::Bind` object, substituting place-holders
1511 /// for arguments 1 - 5 with the values of the specified arguments `p1`
1512 /// - `p5` respectively. Return the result.
1513 template <class P1, class P2, class P3, class P4, class P5>
1514 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1515 P4 const& p4, P5 const& p5) const
1516 {
1517 return (*d_impl)(p1, p2, p3, p4, p5);
1518 }
1519
1520 /// Invoke the bound object using the invocation template provided at
1521 /// construction of this `bdlf::Bind` object, substituting place-holders
1522 /// for arguments 1 - 6 with the values of the specified arguments `p1`
1523 /// - `p7` respectively. Return the result.
1524 template <class P1, class P2, class P3, class P4, class P5, class P6>
1525 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1526 P6& p6) const
1527 {
1528 return (*d_impl)(p1, p2, p3, p4, p5, p6);
1529 }
1530
1531 /// Invoke the bound object using the invocation template provided at
1532 /// construction of this `bdlf::Bind` object, substituting place-holders
1533 /// for arguments 1 - 6 with the values of the specified arguments `p1`
1534 /// - `p7` respectively. Return the result.
1535 template <class P1, class P2, class P3, class P4, class P5, class P6>
1536 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1537 P4 const& p4, P5 const& p5, P6 const& p6)
1538 const
1539 {
1540 return (*d_impl)(p1, p2, p3, p4, p5, p6);
1541 }
1542
1543 /// Invoke the bound object using the invocation template provided at
1544 /// construction of this `bdlf::Bind` object, substituting place-holders
1545 /// for arguments 1 - 7 with the values of the specified arguments `p1`
1546 /// - `p7` respectively. Return the result.
1547 template <class P1, class P2, class P3, class P4, class P5, class P6,
1548 class P7>
1549 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1550 P6& p6, P7& p7) const
1551
1552 {
1553 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7);
1554 }
1555
1556 /// Invoke the bound object using the invocation template provided at
1557 /// construction of this `bdlf::Bind` object, substituting place-holders
1558 /// for arguments 1 - 7 with the values of the specified arguments `p1`
1559 /// - `p7` respectively. Return the result.
1560 template <class P1, class P2, class P3, class P4, class P5, class P6,
1561 class P7>
1562 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1563 P4 const& p4, P5 const& p5, P6 const& p6,
1564 P7 const& p7) const
1565
1566 {
1567 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7);
1568 }
1569
1570 /// Invoke the bound object using the invocation template provided at
1571 /// construction of this `bdlf::Bind` object, substituting place-holders
1572 /// for arguments 1 - 8 with the values of the specified arguments `p1`
1573 /// - `p8` respectively. Return the result.
1574 template <class P1, class P2, class P3, class P4, class P5, class P6,
1575 class P7, class P8>
1576 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1577 P6& p6, P7& p7, P8& p8) const
1578 {
1579 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8);
1580 }
1581
1582 /// Invoke the bound object using the invocation template provided at
1583 /// construction of this `bdlf::Bind` object, substituting place-holders
1584 /// for arguments 1 - 8 with the values of the specified arguments `p1`
1585 /// - `p8` respectively. Return the result.
1586 template <class P1, class P2, class P3, class P4, class P5, class P6,
1587 class P7, class P8>
1588 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1589 P4 const& p4, P5 const& p5, P6 const& p6,
1590 P7 const& p7, P8 const& p8) const
1591 {
1592 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8);
1593 }
1594
1595 /// Invoke the bound object using the invocation template provided at
1596 /// construction of this `bdlf::Bind` object, substituting place-holders
1597 /// for arguments 1 - 9 with the values of the specified arguments `p1`
1598 /// - `p9` respectively. Return the result.
1599 template <class P1, class P2, class P3, class P4, class P5, class P6,
1600 class P7, class P8, class P9>
1601 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1602 P6& p6, P7& p7, P8& p8, P9& p9) const
1603 {
1604 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1605 }
1606
1607 /// Invoke the bound object using the invocation template provided at
1608 /// construction of this `bdlf::Bind` object, substituting place-holders
1609 /// for arguments 1 - 9 with the values of the specified arguments `p1`
1610 /// - `p9` respectively. Return the result.
1611 template <class P1, class P2, class P3, class P4, class P5, class P6,
1612 class P7, class P8, class P9>
1613 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1614 P4 const& p4, P5 const& p5, P6 const& p6,
1615 P7 const& p7, P8 const& p8, P9 const& p9)
1616 const
1617 {
1618 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1619 }
1620
1621 /// Invoke the bound object using the invocation template provided at
1622 /// construction of this `bdlf::Bind` object, substituting place-holders
1623 /// for arguments 1 - 10 with the values of the specified arguments `p1`
1624 /// - `p10` respectively. Return the result.
1625 template <class P1, class P2, class P3, class P4, class P5, class P6,
1626 class P7, class P8, class P9, class P10>
1627 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1628 P6& p6, P7& p7, P8& p8, P9& p9,
1629 P10& p10) const
1630 {
1631 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1632 }
1633
1634 /// Invoke the bound object using the invocation template provided at
1635 /// construction of this `bdlf::Bind` object, substituting place-holders
1636 /// for arguments 1 - 10 with the values of the specified arguments `p1`
1637 /// - `p10` respectively. Return the result.
1638 template <class P1, class P2, class P3, class P4, class P5, class P6,
1639 class P7, class P8, class P9, class P10>
1640 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1641 P4 const& p4, P5 const& p5, P6 const& p6,
1642 P7 const& p7, P8 const& p8, P9 const& p9,
1643 P10 const& p10) const
1644 {
1645 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1646 }
1647
1648 /// Invoke the bound object using the invocation template provided at
1649 /// construction of this `bdlf::Bind` object, substituting place-holders
1650 /// for arguments 1 - 11 with the values of the specified arguments `p1`
1651 /// - `p11` respectively. Return the result.
1652 template <class P1, class P2, class P3, class P4, class P5, class P6,
1653 class P7, class P8, class P9, class P10, class P11>
1654 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1655 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1656 P11& p11) const
1657 {
1658 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
1659 }
1660
1661 /// Invoke the bound object using the invocation template provided at
1662 /// construction of this `bdlf::Bind` object, substituting place-holders
1663 /// for arguments 1 - 11 with the values of the specified arguments `p1`
1664 /// - `p11` respectively. Return the result.
1665 template <class P1, class P2, class P3, class P4, class P5, class P6,
1666 class P7, class P8, class P9, class P10, class P11>
1667 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1668 P4 const& p4, P5 const& p5, P6 const& p6,
1669 P7 const& p7, P8 const& p8, P9 const& p9,
1670 P10 const& p10, P11 const& p11) const
1671 {
1672 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
1673 }
1674
1675 /// Invoke the bound object using the invocation template provided at
1676 /// construction of this `bdlf::Bind` object, substituting place-holders
1677 /// for arguments 1 - 12 with the values of the specified arguments `p1`
1678 /// - `p12` respectively. Return the result.
1679 template <class P1, class P2, class P3, class P4, class P5, class P6,
1680 class P7, class P8, class P9, class P10, class P11, class P12>
1681 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1682 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1683 P11& p11, P12& p12) const
1684 {
1685 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
1686 }
1687
1688 /// Invoke the bound object using the invocation template provided at
1689 /// construction of this `bdlf::Bind` object, substituting place-holders
1690 /// for arguments 1 - 12 with the values of the specified arguments `p1`
1691 /// - `p12` respectively. Return the result.
1692 template <class P1, class P2, class P3, class P4, class P5, class P6,
1693 class P7, class P8, class P9, class P10, class P11, class P12>
1694 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1695 P4 const& p4, P5 const& p5, P6 const& p6,
1696 P7 const& p7, P8 const& p8, P9 const& p9,
1697 P10 const& p10, P11 const& p11,
1698 P12 const& p12) const
1699 {
1700 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
1701 }
1702
1703 /// Invoke the bound object using the invocation template provided at
1704 /// construction of this `bdlf::Bind` object, substituting place-holders
1705 /// for arguments 1 - 13 with the values of the specified arguments `p1`
1706 /// - `p13` respectively. Return the result.
1707 template <class P1, class P2, class P3, class P4, class P5, class P6,
1708 class P7, class P8, class P9, class P10, class P11, class P12,
1709 class P13>
1710 inline ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
1711 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
1712 P11& p11, P12& p12, P13& p13) const
1713 {
1714 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1715 p13);
1716 }
1717
1718 /// Invoke the bound object using the invocation template provided at
1719 /// construction of this `bdlf::Bind` object, substituting place-holders
1720 /// for arguments 1 - 13 with the values of the specified arguments `p1`
1721 /// - `p13` respectively. Return the result.
1722 template <class P1, class P2, class P3, class P4, class P5, class P6,
1723 class P7, class P8, class P9, class P10, class P11, class P12,
1724 class P13>
1725 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1726 P4 const& p4, P5 const& p5, P6 const& p6,
1727 P7 const& p7, P8 const& p8, P9 const& p9,
1728 P10 const& p10, P11 const& p11,
1729 P12 const& p12, P13 const& p13) const
1730 {
1731 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1732 p13);
1733 }
1734
1735 /// Invoke the bound object using the invocation template provided at
1736 /// construction of this `bdlf::Bind` object, substituting place-holders
1737 /// for arguments 1 - 14 with the values of the specified arguments `p1`
1738 /// - `p14` respectively. Return the result.
1739 template <class P1, class P2, class P3, class P4, class P5, class P6,
1740 class P7, class P8, class P9, class P10, class P11, class P12,
1741 class P13, class P14>
1742 inline ResultType operator()(P1& p1, P2& p2, P3& p3,
1743 P4& p4, P5& p5, P6& p6,
1744 P7& p7, P8& p8, P9& p9,
1745 P10& p10, P11& p11, P12& p12,
1746 P13& p13, P14& p14) const
1747 {
1748 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1749 p13, p14);
1750 }
1751
1752 /// Invoke the bound object using the invocation template provided at
1753 /// construction of this `bdlf::Bind` object, substituting place-holders
1754 /// for arguments 1 - 14 with the values of the specified arguments `p1`
1755 /// - `p14` respectively. Return the result.
1756 template <class P1, class P2, class P3, class P4, class P5, class P6,
1757 class P7, class P8, class P9, class P10, class P11, class P12,
1758 class P13, class P14>
1759 inline ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
1760 P4 const& p4, P5 const& p5, P6 const& p6,
1761 P7 const& p7, P8 const& p8, P9 const& p9,
1762 P10 const& p10, P11 const& p11,
1763 P12 const& p12, P13 const& p13,
1764 P14 const& p14) const
1765 {
1766 return (*d_impl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
1767 p13, p14);
1768 }
1769};
1770
1771 // ==============
1772 // class BindUtil
1773 // ==============
1774
1775/// This `struct` provides a namespace for utility functions used to
1776/// construct `Bind` and `BindWrapper` objects. Four families of factory
1777/// methods are provided: `bind`, `bindR`, `bindS`, and `bindSR`.
1778/// All factory methods accept an invocable object, optionally followed by
1779/// up to fourteen additional arguments. Each argument can be either a
1780/// literal value, a place-holder, or another `Bind` or `BindWrapper`
1781/// object.
1782///
1783/// The `BindUtil` class methods compute the signature of the function
1784/// object automatically, including the return type, and return a binder
1785/// object with the specified bound functor and bound arguments. Memory for
1786/// copying the bound functor and bound arguments is supplied by the user
1787/// specified allocator if `bindS`, or `bindSR` is used, or the currently
1788/// installed default allocator, if `bind` or `bindR` is used. The return
1789/// type is inferred by using `bslmf::FunctionPointerTraits` for free
1790/// function references and pointers, `bslmf::MemberFunctionPointerTraits`
1791/// for member function pointers, and `typenname t_FUNC::ResultType` for a
1792/// functor of type `t_FUNC`.
1793///
1794/// The `bindR` and `bindSR` variations must be used when binding to an
1795/// object for which a result type cannot be automatically determined.
1796///
1797/// See @ref bdlf_bind
1798class BindUtil {
1799
1800 // PRIVATE TYPES
1801
1802 /// Decay the type of the argument to the `bind*` function into the type
1803 /// of storage needed to store in in the `Bind_BoundTuple`. We cannot
1804 /// just use `bslmf::MovableRefUtil::Decay` because it will turn
1805 /// `const Type(&)[]` into `Type *` which cannot be constructed from
1806 /// `const Type(&)[]`, so we use `ArrayToConstPointer` to turn such
1807 /// arrays into `const Type *`.
1808 ///
1809 /// See @ref bdlf_bind
1810 template <class TYPE>
1811 class Storage_Type {
1812
1813 // PRIVATE TYPES
1814 typedef typename bslmf::MovableRefUtil::RemoveReference<TYPE>::type
1815 TypeA;
1816 typedef typename bslmf::ArrayToConstPointer<TypeA>::Type TypeB;
1817
1818 public:
1819 // PUBLIC TYPES
1820 typedef typename bsl::remove_cv<TypeB>::type type;
1821 };
1822
1823 typedef bslmf::MovableRefUtil MoveUtil;
1824
1825 public:
1826 // CLASS METHODS
1827
1828 // - - - - 'bind' methods - - - -
1829
1830 /// Return a `Bind` object that is bound to the specified `func`
1831 /// invocable object, which can be invoked with no parameters.
1832 template <class t_FUNC>
1833 static
1834 Bind<bslmf::Nil, t_FUNC, Bind_BoundTuple0>
1835 bind(t_FUNC func)
1836 {
1837 return Bind<bslmf::Nil, t_FUNC, Bind_BoundTuple0>
1838 (func, Bind_BoundTuple0());
1839 }
1840
1841 /// Return a `Bind` object that is bound to the specified invocable
1842 /// object `func`, which can be invoked with one parameter.
1843 template <class t_FUNC, class P1>
1844 static
1845 Bind<bslmf::Nil,
1846 t_FUNC,
1847 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
1848 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
1849 {
1850 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
1851 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1));
1852
1853 return Bind<bslmf::Nil,
1854 t_FUNC,
1855 BoundList>(func, MoveUtil::move(list));
1856 }
1857
1858 /// Return a `Bind` object that is bound to the specified invocable
1859 /// object `func`, which can be invoked with two parameters.
1860 template <class t_FUNC, class P1, class P2>
1861 static
1862 Bind<bslmf::Nil,
1863 t_FUNC,
1864 Bind_BoundTuple2<typename Storage_Type<P1>::type,
1865 typename Storage_Type<P2>::type> >
1866 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1867 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
1868 {
1869 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
1870 typename Storage_Type<P2>::type> BoundList;
1871
1872 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1873 BSLS_COMPILERFEATURES_FORWARD(P2, p2));
1874
1875 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1876 }
1877
1878 /// Return a `Bind` object that is bound to the specified invocable
1879 /// object `func`, which can be invoked with three parameters.
1880 template <class t_FUNC, class P1, class P2, class P3>
1881 static
1882 Bind<bslmf::Nil,
1883 t_FUNC,
1884 Bind_BoundTuple3<typename Storage_Type<P1>::type,
1885 typename Storage_Type<P2>::type,
1886 typename Storage_Type<P3>::type> >
1887 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1888 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1889 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
1890 {
1891 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
1892 typename Storage_Type<P2>::type,
1893 typename Storage_Type<P3>::type> BoundList;
1894
1895 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1896 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1897 BSLS_COMPILERFEATURES_FORWARD(P3, p3));
1898
1899 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1900 }
1901
1902 /// Return a `Bind` object that is bound to the specified invocable
1903 /// object `func`, which can be invoked with four parameters.
1904 template <class t_FUNC, class P1, class P2, class P3, class P4>
1905 static
1906 Bind<bslmf::Nil,
1907 t_FUNC,
1908 Bind_BoundTuple4<typename Storage_Type<P1>::type,
1909 typename Storage_Type<P2>::type,
1910 typename Storage_Type<P3>::type,
1911 typename Storage_Type<P4>::type> >
1912 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1913 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1914 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1915 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
1916 {
1917 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
1918 typename Storage_Type<P2>::type,
1919 typename Storage_Type<P3>::type,
1920 typename Storage_Type<P4>::type> BoundList;
1921
1922 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1923 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1924 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1925 BSLS_COMPILERFEATURES_FORWARD(P4, p4));
1926
1927 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1928 }
1929
1930 /// Return a `Bind` object that is bound to the specified invocable
1931 /// object `func`, which can be invoked with five parameters.
1932 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5>
1933 static
1934 Bind<bslmf::Nil,
1935 t_FUNC,
1936 Bind_BoundTuple5<typename Storage_Type<P1>::type,
1937 typename Storage_Type<P2>::type,
1938 typename Storage_Type<P3>::type,
1939 typename Storage_Type<P4>::type,
1940 typename Storage_Type<P5>::type> >
1941 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1942 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1943 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1944 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
1945 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
1946 {
1947 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
1948 typename Storage_Type<P2>::type,
1949 typename Storage_Type<P3>::type,
1950 typename Storage_Type<P4>::type,
1951 typename Storage_Type<P5>::type> BoundList;
1952
1953 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1954 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1955 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1956 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
1957 BSLS_COMPILERFEATURES_FORWARD(P5, p5));
1958
1959 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1960 }
1961
1962 /// Return a `Bind` object that is bound to the specified invocable
1963 /// object `func`, which can be invoked with six parameters.
1964 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
1965 class P6>
1966 static
1967 Bind<bslmf::Nil,
1968 t_FUNC,
1969 Bind_BoundTuple6<typename Storage_Type<P1>::type,
1970 typename Storage_Type<P2>::type,
1971 typename Storage_Type<P3>::type,
1972 typename Storage_Type<P4>::type,
1973 typename Storage_Type<P5>::type,
1974 typename Storage_Type<P6>::type> >
1975 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
1976 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
1977 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
1978 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
1979 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
1980 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
1981 {
1982 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
1983 typename Storage_Type<P2>::type,
1984 typename Storage_Type<P3>::type,
1985 typename Storage_Type<P4>::type,
1986 typename Storage_Type<P5>::type,
1987 typename Storage_Type<P6>::type> BoundList;
1988
1989 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
1990 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
1991 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
1992 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
1993 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
1994 BSLS_COMPILERFEATURES_FORWARD(P6, p6));
1995
1996 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
1997 }
1998
1999 /// Return a `Bind` object that is bound to the specified invocable
2000 /// object `func`, which can be invoked with seven parameters.
2001 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2002 class P6, class P7>
2003 static
2004 Bind<bslmf::Nil,
2005 t_FUNC,
2006 Bind_BoundTuple7<typename Storage_Type<P1>::type,
2007 typename Storage_Type<P2>::type,
2008 typename Storage_Type<P3>::type,
2009 typename Storage_Type<P4>::type,
2010 typename Storage_Type<P5>::type,
2011 typename Storage_Type<P6>::type,
2012 typename Storage_Type<P7>::type> >
2013 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2014 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2015 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2016 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2017 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2018 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2019 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
2020 {
2021 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
2022 typename Storage_Type<P2>::type,
2023 typename Storage_Type<P3>::type,
2024 typename Storage_Type<P4>::type,
2025 typename Storage_Type<P5>::type,
2026 typename Storage_Type<P6>::type,
2027 typename Storage_Type<P7>::type> BoundList;
2028
2029 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2030 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2031 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2032 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2033 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2034 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2035 BSLS_COMPILERFEATURES_FORWARD(P7, p7));
2036
2037 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2038 }
2039
2040 /// Return a `Bind` object that is bound to the specified invocable
2041 /// object `func`, which can be invoked with eight parameters.
2042 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2043 class P6, class P7, class P8>
2044 static
2045 Bind<bslmf::Nil,
2046 t_FUNC,
2047 Bind_BoundTuple8<typename Storage_Type<P1>::type,
2048 typename Storage_Type<P2>::type,
2049 typename Storage_Type<P3>::type,
2050 typename Storage_Type<P4>::type,
2051 typename Storage_Type<P5>::type,
2052 typename Storage_Type<P6>::type,
2053 typename Storage_Type<P7>::type,
2054 typename Storage_Type<P8>::type> >
2055 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2056 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2057 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2058 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2059 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2060 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2061 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2062 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
2063 {
2064 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
2065 typename Storage_Type<P2>::type,
2066 typename Storage_Type<P3>::type,
2067 typename Storage_Type<P4>::type,
2068 typename Storage_Type<P5>::type,
2069 typename Storage_Type<P6>::type,
2070 typename Storage_Type<P7>::type,
2071 typename Storage_Type<P8>::type> BoundList;
2072
2073 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2074 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2075 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2076 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2077 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2078 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2079 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2080 BSLS_COMPILERFEATURES_FORWARD(P8, p8));
2081
2082 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2083 }
2084
2085 /// Return a `Bind` object that is bound to the specified invocable
2086 /// object `func`, which can be invoked with nine parameters.
2087 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2088 class P6, class P7, class P8, class P9>
2089 static
2090 Bind<bslmf::Nil,
2091 t_FUNC,
2092 Bind_BoundTuple9<typename Storage_Type<P1>::type,
2093 typename Storage_Type<P2>::type,
2094 typename Storage_Type<P3>::type,
2095 typename Storage_Type<P4>::type,
2096 typename Storage_Type<P5>::type,
2097 typename Storage_Type<P6>::type,
2098 typename Storage_Type<P7>::type,
2099 typename Storage_Type<P8>::type,
2100 typename Storage_Type<P9>::type> >
2101 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2102 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2103 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2104 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2105 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2106 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2107 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2108 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2109 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
2110 {
2111 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
2112 typename Storage_Type<P2>::type,
2113 typename Storage_Type<P3>::type,
2114 typename Storage_Type<P4>::type,
2115 typename Storage_Type<P5>::type,
2116 typename Storage_Type<P6>::type,
2117 typename Storage_Type<P7>::type,
2118 typename Storage_Type<P8>::type,
2119 typename Storage_Type<P9>::type> BoundList;
2120
2121 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2122 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2123 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2124 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2125 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2126 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2127 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2128 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2129 BSLS_COMPILERFEATURES_FORWARD(P9, p9));
2130
2131 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2132 }
2133
2134 /// Return a `Bind` object that is bound to the specified invocable
2135 /// object `func`, which can be invoked with ten parameters.
2136 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2137 class P6, class P7, class P8, class P9, class P10>
2138 static
2139 Bind<bslmf::Nil,
2140 t_FUNC,
2141 Bind_BoundTuple10<typename Storage_Type<P1>::type,
2142 typename Storage_Type<P2>::type,
2143 typename Storage_Type<P3>::type,
2144 typename Storage_Type<P4>::type,
2145 typename Storage_Type<P5>::type,
2146 typename Storage_Type<P6>::type,
2147 typename Storage_Type<P7>::type,
2148 typename Storage_Type<P8>::type,
2149 typename Storage_Type<P9>::type,
2150 typename Storage_Type<P10>::type> >
2151 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2152 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2153 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2154 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2155 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2156 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2157 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2158 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2159 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2160 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
2161 {
2162 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
2163 typename Storage_Type<P2>::type,
2164 typename Storage_Type<P3>::type,
2165 typename Storage_Type<P4>::type,
2166 typename Storage_Type<P5>::type,
2167 typename Storage_Type<P6>::type,
2168 typename Storage_Type<P7>::type,
2169 typename Storage_Type<P8>::type,
2170 typename Storage_Type<P9>::type,
2171 typename Storage_Type<P10>::type> BoundList;
2172
2173 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2174 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2175 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2176 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2177 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2178 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2179 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2180 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2181 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2182 BSLS_COMPILERFEATURES_FORWARD(P10, p10));
2183
2184 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2185 }
2186
2187 /// Return a `Bind` object that is bound to the specified invocable
2188 /// object `func`, which can be invoked with eleven parameters.
2189 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2190 class P6, class P7, class P8, class P9, class P10, class P11>
2191 static
2192 Bind<bslmf::Nil,
2193 t_FUNC,
2194 Bind_BoundTuple11<typename Storage_Type<P1>::type,
2195 typename Storage_Type<P2>::type,
2196 typename Storage_Type<P3>::type,
2197 typename Storage_Type<P4>::type,
2198 typename Storage_Type<P5>::type,
2199 typename Storage_Type<P6>::type,
2200 typename Storage_Type<P7>::type,
2201 typename Storage_Type<P8>::type,
2202 typename Storage_Type<P9>::type,
2203 typename Storage_Type<P10>::type,
2204 typename Storage_Type<P11>::type> >
2205 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2206 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2207 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2208 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2209 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2210 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2211 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2212 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2213 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2214 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2215 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
2216 {
2217 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
2218 typename Storage_Type<P2>::type,
2219 typename Storage_Type<P3>::type,
2220 typename Storage_Type<P4>::type,
2221 typename Storage_Type<P5>::type,
2222 typename Storage_Type<P6>::type,
2223 typename Storage_Type<P7>::type,
2224 typename Storage_Type<P8>::type,
2225 typename Storage_Type<P9>::type,
2226 typename Storage_Type<P10>::type,
2227 typename Storage_Type<P11>::type> BoundList;
2228
2229 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2230 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2231 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2232 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2233 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2234 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2235 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2236 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2237 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2238 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2239 BSLS_COMPILERFEATURES_FORWARD(P11, p11));
2240
2241 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2242 }
2243
2244 /// Return a `Bind` object that is bound to the specified invocable
2245 /// object `func`, which can be invoked with twelve parameters.
2246 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2247 class P6, class P7, class P8, class P9, class P10, class P11,
2248 class P12>
2249 static
2250 Bind<bslmf::Nil,
2251 t_FUNC,
2252 Bind_BoundTuple12<typename Storage_Type<P1>::type,
2253 typename Storage_Type<P2>::type,
2254 typename Storage_Type<P3>::type,
2255 typename Storage_Type<P4>::type,
2256 typename Storage_Type<P5>::type,
2257 typename Storage_Type<P6>::type,
2258 typename Storage_Type<P7>::type,
2259 typename Storage_Type<P8>::type,
2260 typename Storage_Type<P9>::type,
2261 typename Storage_Type<P10>::type,
2262 typename Storage_Type<P11>::type,
2263 typename Storage_Type<P12>::type> >
2264 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2265 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2266 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2267 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2268 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2269 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2270 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2271 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2272 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2273 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2274 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2275 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
2276 {
2277 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
2278 typename Storage_Type<P2>::type,
2279 typename Storage_Type<P3>::type,
2280 typename Storage_Type<P4>::type,
2281 typename Storage_Type<P5>::type,
2282 typename Storage_Type<P6>::type,
2283 typename Storage_Type<P7>::type,
2284 typename Storage_Type<P8>::type,
2285 typename Storage_Type<P9>::type,
2286 typename Storage_Type<P10>::type,
2287 typename Storage_Type<P11>::type,
2288 typename Storage_Type<P12>::type> BoundList;
2289
2290 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2291 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2292 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2293 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2294 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2295 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2296 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2297 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2298 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2299 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2300 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2301 BSLS_COMPILERFEATURES_FORWARD(P12, p12));
2302
2303 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2304 }
2305
2306 /// Return a `Bind` object that is bound to the specified invocable
2307 /// object `func`, which can be invoked with thirteen parameters.
2308 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2309 class P6, class P7, class P8, class P9, class P10, class P11,
2310 class P12, class P13>
2311 static
2312 Bind<bslmf::Nil,
2313 t_FUNC,
2314 Bind_BoundTuple13<typename Storage_Type<P1>::type,
2315 typename Storage_Type<P2>::type,
2316 typename Storage_Type<P3>::type,
2317 typename Storage_Type<P4>::type,
2318 typename Storage_Type<P5>::type,
2319 typename Storage_Type<P6>::type,
2320 typename Storage_Type<P7>::type,
2321 typename Storage_Type<P8>::type,
2322 typename Storage_Type<P9>::type,
2323 typename Storage_Type<P10>::type,
2324 typename Storage_Type<P11>::type,
2325 typename Storage_Type<P12>::type,
2326 typename Storage_Type<P13>::type> >
2327 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2328 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2329 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2330 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2331 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2332 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2333 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2334 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2335 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2336 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2337 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2338 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2339 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
2340 {
2341 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
2342 typename Storage_Type<P2>::type,
2343 typename Storage_Type<P3>::type,
2344 typename Storage_Type<P4>::type,
2345 typename Storage_Type<P5>::type,
2346 typename Storage_Type<P6>::type,
2347 typename Storage_Type<P7>::type,
2348 typename Storage_Type<P8>::type,
2349 typename Storage_Type<P9>::type,
2350 typename Storage_Type<P10>::type,
2351 typename Storage_Type<P11>::type,
2352 typename Storage_Type<P12>::type,
2353 typename Storage_Type<P13>::type> BoundList;
2354
2355 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2356 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2357 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2358 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2359 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2360 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2361 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2362 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2363 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2364 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2365 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2366 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
2367 BSLS_COMPILERFEATURES_FORWARD(P13, p13));
2368
2369 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2370 }
2371
2372 /// Return a `Bind` object that is bound to the specified invocable
2373 /// object `func`, which can be invoked with fourteen parameters.
2374 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
2375 class P6, class P7, class P8, class P9, class P10, class P11,
2376 class P12, class P13, class P14>
2377 static
2378 Bind<bslmf::Nil,
2379 t_FUNC,
2380 Bind_BoundTuple14<typename Storage_Type<P1>::type,
2381 typename Storage_Type<P2>::type,
2382 typename Storage_Type<P3>::type,
2383 typename Storage_Type<P4>::type,
2384 typename Storage_Type<P5>::type,
2385 typename Storage_Type<P6>::type,
2386 typename Storage_Type<P7>::type,
2387 typename Storage_Type<P8>::type,
2388 typename Storage_Type<P9>::type,
2389 typename Storage_Type<P10>::type,
2390 typename Storage_Type<P11>::type,
2391 typename Storage_Type<P12>::type,
2392 typename Storage_Type<P13>::type,
2393 typename Storage_Type<P14>::type> >
2394 bind(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2395 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2396 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2397 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2398 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2399 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2400 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2401 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2402 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2403 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2404 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2405 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2406 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
2407 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
2408 {
2409 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
2410 typename Storage_Type<P2>::type,
2411 typename Storage_Type<P3>::type,
2412 typename Storage_Type<P4>::type,
2413 typename Storage_Type<P5>::type,
2414 typename Storage_Type<P6>::type,
2415 typename Storage_Type<P7>::type,
2416 typename Storage_Type<P8>::type,
2417 typename Storage_Type<P9>::type,
2418 typename Storage_Type<P10>::type,
2419 typename Storage_Type<P11>::type,
2420 typename Storage_Type<P12>::type,
2421 typename Storage_Type<P13>::type,
2422 typename Storage_Type<P14>::type> BoundList;
2423
2424 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2425 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2426 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2427 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2428 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2429 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2430 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2431 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2432 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2433 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2434 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2435 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
2436 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
2437 BSLS_COMPILERFEATURES_FORWARD(P14, p14));
2438
2439 return Bind<bslmf::Nil, t_FUNC, BoundList>(func, MoveUtil::move(list));
2440 }
2441
2442 // - - - - 'bindR' methods - - - -
2443
2444 /// Return a `Bind` object that is bound to the specified invocable
2445 /// object `func`, which can be invoked with no parameters and returns a
2446 /// value of type `t_RET`.
2447 template <class t_RET, class t_FUNC>
2448 static
2449 Bind<t_RET, t_FUNC, Bind_BoundTuple0>
2450 bindR(t_FUNC func)
2451 {
2452 return Bind<t_RET, t_FUNC, Bind_BoundTuple0>
2453 (func, Bind_BoundTuple0());
2454 }
2455
2456 /// Return a `Bind` object that is bound to the specified invocable
2457 /// object `func`, which can be invoked with one parameter and returns a
2458 /// value of type `t_RET`.
2459 template <class t_RET, class t_FUNC, class P1>
2460 static
2461 Bind<t_RET,
2462 t_FUNC,
2463 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
2464 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
2465 {
2466 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
2467 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1));
2468
2469 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2470 }
2471
2472 /// Return a `Bind` object that is bound to the specified invocable
2473 /// object `func`, which can be invoked with two parameters and returns
2474 /// a value of type `t_RET`.
2475 template <class t_RET, class t_FUNC, class P1, class P2>
2476 static
2477 Bind<t_RET,
2478 t_FUNC,
2479 Bind_BoundTuple2<typename Storage_Type<P1>::type,
2480 typename Storage_Type<P2>::type> >
2481 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2482 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
2483 {
2484 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
2485 typename Storage_Type<P2>::type> BoundList;
2486
2487 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2488 BSLS_COMPILERFEATURES_FORWARD(P2, p2));
2489
2490 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2491 }
2492
2493 /// Return a `Bind` object that is bound to the specified invocable
2494 /// object `func`, which can be invoked with three parameters and
2495 /// returns a value of type `t_RET`.
2496 template <class t_RET, class t_FUNC, class P1, class P2, class P3>
2497 static
2498 Bind<t_RET,
2499 t_FUNC,
2500 Bind_BoundTuple3<typename Storage_Type<P1>::type,
2501 typename Storage_Type<P2>::type,
2502 typename Storage_Type<P3>::type> >
2503 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2504 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2505 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
2506 {
2507 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
2508 typename Storage_Type<P2>::type,
2509 typename Storage_Type<P3>::type> BoundList;
2510
2511 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2512 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2513 BSLS_COMPILERFEATURES_FORWARD(P3, p3));
2514
2515 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2516 }
2517
2518 /// Return a `Bind` object that is bound to the specified invocable
2519 /// object `func`, which can be invoked with four parameters and returns
2520 /// a value of type `t_RET`.
2521 template <class t_RET, class t_FUNC, class P1, class P2,
2522 class P3, class P4>
2523 static
2524 Bind<t_RET,
2525 t_FUNC,
2526 Bind_BoundTuple4<typename Storage_Type<P1>::type,
2527 typename Storage_Type<P2>::type,
2528 typename Storage_Type<P3>::type,
2529 typename Storage_Type<P4>::type> >
2530 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2531 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2532 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2533 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
2534 {
2535 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
2536 typename Storage_Type<P2>::type,
2537 typename Storage_Type<P3>::type,
2538 typename Storage_Type<P4>::type> BoundList;
2539
2540 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2541 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2542 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2543 BSLS_COMPILERFEATURES_FORWARD(P4, p4));
2544
2545 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2546 }
2547
2548 /// Return a `Bind` object that is bound to the specified invocable
2549 /// object `func`, which can be invoked with five parameters and returns
2550 /// a value of type `t_RET`.
2551 template <class t_RET, class t_FUNC, class P1, class P2,
2552 class P3, class P4, class P5>
2553 static
2554 Bind<t_RET,
2555 t_FUNC,
2556 Bind_BoundTuple5<typename Storage_Type<P1>::type,
2557 typename Storage_Type<P2>::type,
2558 typename Storage_Type<P3>::type,
2559 typename Storage_Type<P4>::type,
2560 typename Storage_Type<P5>::type> >
2561 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2562 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2563 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2564 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2565 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
2566 {
2567 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
2568 typename Storage_Type<P2>::type,
2569 typename Storage_Type<P3>::type,
2570 typename Storage_Type<P4>::type,
2571 typename Storage_Type<P5>::type> BoundList;
2572
2573 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2574 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2575 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2576 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2577 BSLS_COMPILERFEATURES_FORWARD(P5, p5));
2578
2579 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2580 }
2581
2582 /// Return a `Bind` object that is bound to the specified invocable
2583 /// object `func`, which can be invoked with six parameters and returns
2584 /// a value of type `t_RET`.
2585 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2586 class P4, class P5, class P6>
2587 static
2588 Bind<t_RET,
2589 t_FUNC,
2590 Bind_BoundTuple6<typename Storage_Type<P1>::type,
2591 typename Storage_Type<P2>::type,
2592 typename Storage_Type<P3>::type,
2593 typename Storage_Type<P4>::type,
2594 typename Storage_Type<P5>::type,
2595 typename Storage_Type<P6>::type> >
2596 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2597 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2598 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2599 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2600 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2601 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
2602 {
2603 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
2604 typename Storage_Type<P2>::type,
2605 typename Storage_Type<P3>::type,
2606 typename Storage_Type<P4>::type,
2607 typename Storage_Type<P5>::type,
2608 typename Storage_Type<P6>::type> BoundList;
2609
2610 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2611 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2612 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2613 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2614 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2615 BSLS_COMPILERFEATURES_FORWARD(P6, p6));
2616
2617 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2618 }
2619
2620 /// Return a `Bind` object that is bound to the specified invocable
2621 /// object `func`, which can be invoked with seven parameters and
2622 /// returns a value of type `t_RET`.
2623 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2624 class P4, class P5, class P6,
2625 class P7>
2626 static
2627 Bind<t_RET,
2628 t_FUNC,
2629 Bind_BoundTuple7<typename Storage_Type<P1>::type,
2630 typename Storage_Type<P2>::type,
2631 typename Storage_Type<P3>::type,
2632 typename Storage_Type<P4>::type,
2633 typename Storage_Type<P5>::type,
2634 typename Storage_Type<P6>::type,
2635 typename Storage_Type<P7>::type> >
2636 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2637 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2638 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2639 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2640 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2641 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2642 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
2643 {
2644 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
2645 typename Storage_Type<P2>::type,
2646 typename Storage_Type<P3>::type,
2647 typename Storage_Type<P4>::type,
2648 typename Storage_Type<P5>::type,
2649 typename Storage_Type<P6>::type,
2650 typename Storage_Type<P7>::type> BoundList;
2651
2652 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2653 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2654 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2655 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2656 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2657 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2658 BSLS_COMPILERFEATURES_FORWARD(P7, p7));
2659
2660 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2661 }
2662
2663 /// Return a `Bind` object that is bound to the specified invocable
2664 /// object `func`, which can be invoked with eight parameters and
2665 /// returns a value of type `t_RET`.
2666 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2667 class P4, class P5, class P6,
2668 class P7, class P8>
2669 static
2670 Bind<t_RET,
2671 t_FUNC,
2672 Bind_BoundTuple8<typename Storage_Type<P1>::type,
2673 typename Storage_Type<P2>::type,
2674 typename Storage_Type<P3>::type,
2675 typename Storage_Type<P4>::type,
2676 typename Storage_Type<P5>::type,
2677 typename Storage_Type<P6>::type,
2678 typename Storage_Type<P7>::type,
2679 typename Storage_Type<P8>::type> >
2680 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2681 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2682 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2683 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2684 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2685 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2686 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2687 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
2688 {
2689 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
2690 typename Storage_Type<P2>::type,
2691 typename Storage_Type<P3>::type,
2692 typename Storage_Type<P4>::type,
2693 typename Storage_Type<P5>::type,
2694 typename Storage_Type<P6>::type,
2695 typename Storage_Type<P7>::type,
2696 typename Storage_Type<P8>::type> BoundList;
2697
2698 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2699 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2700 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2701 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2702 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2703 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2704 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2705 BSLS_COMPILERFEATURES_FORWARD(P8, p8));
2706
2707 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2708 }
2709
2710 /// Return a `Bind` object that is bound to the specified invocable
2711 /// object `func`, which can be invoked with nine parameters and returns
2712 /// a value of type `t_RET`.
2713 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2714 class P4, class P5, class P6,
2715 class P7, class P8, class P9>
2716 static
2717 Bind<t_RET,
2718 t_FUNC,
2719 Bind_BoundTuple9<typename Storage_Type<P1>::type,
2720 typename Storage_Type<P2>::type,
2721 typename Storage_Type<P3>::type,
2722 typename Storage_Type<P4>::type,
2723 typename Storage_Type<P5>::type,
2724 typename Storage_Type<P6>::type,
2725 typename Storage_Type<P7>::type,
2726 typename Storage_Type<P8>::type,
2727 typename Storage_Type<P9>::type> >
2728 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2729 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2730 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2731 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2732 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2733 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2734 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2735 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2736 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
2737 {
2738 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
2739 typename Storage_Type<P2>::type,
2740 typename Storage_Type<P3>::type,
2741 typename Storage_Type<P4>::type,
2742 typename Storage_Type<P5>::type,
2743 typename Storage_Type<P6>::type,
2744 typename Storage_Type<P7>::type,
2745 typename Storage_Type<P8>::type,
2746 typename Storage_Type<P9>::type> BoundList;
2747
2748 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2749 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2750 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2751 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2752 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2753 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2754 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2755 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2756 BSLS_COMPILERFEATURES_FORWARD(P9, p9));
2757
2758 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2759 }
2760
2761 /// Return a `Bind` object that is bound to the specified invocable
2762 /// object `func`, which can be invoked with ten parameters and returns
2763 /// a value of type `t_RET`.
2764 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2765 class P4, class P5, class P6,
2766 class P7, class P8, class P9,
2767 class P10>
2768 static
2769 Bind<t_RET,
2770 t_FUNC,
2771 Bind_BoundTuple10<typename Storage_Type<P1>::type,
2772 typename Storage_Type<P2>::type,
2773 typename Storage_Type<P3>::type,
2774 typename Storage_Type<P4>::type,
2775 typename Storage_Type<P5>::type,
2776 typename Storage_Type<P6>::type,
2777 typename Storage_Type<P7>::type,
2778 typename Storage_Type<P8>::type,
2779 typename Storage_Type<P9>::type,
2780 typename Storage_Type<P10>::type> >
2781 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2782 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2783 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2784 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2785 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2786 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2787 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2788 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2789 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2790 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
2791 {
2792 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
2793 typename Storage_Type<P2>::type,
2794 typename Storage_Type<P3>::type,
2795 typename Storage_Type<P4>::type,
2796 typename Storage_Type<P5>::type,
2797 typename Storage_Type<P6>::type,
2798 typename Storage_Type<P7>::type,
2799 typename Storage_Type<P8>::type,
2800 typename Storage_Type<P9>::type,
2801 typename Storage_Type<P10>::type> BoundList;
2802
2803 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2804 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2805 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2806 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2807 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2808 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2809 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2810 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2811 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2812 BSLS_COMPILERFEATURES_FORWARD(P10, p10));
2813
2814 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2815 }
2816
2817 /// Return a `Bind` object that is bound to the specified invocable
2818 /// object `func`, which can be invoked with eleven parameters and
2819 /// returns a value of type `t_RET`.
2820 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2821 class P4, class P5, class P6,
2822 class P7, class P8, class P9,
2823 class P10, class P11>
2824 static
2825 Bind<t_RET,
2826 t_FUNC,
2827 Bind_BoundTuple11<typename Storage_Type<P1>::type,
2828 typename Storage_Type<P2>::type,
2829 typename Storage_Type<P3>::type,
2830 typename Storage_Type<P4>::type,
2831 typename Storage_Type<P5>::type,
2832 typename Storage_Type<P6>::type,
2833 typename Storage_Type<P7>::type,
2834 typename Storage_Type<P8>::type,
2835 typename Storage_Type<P9>::type,
2836 typename Storage_Type<P10>::type,
2837 typename Storage_Type<P11>::type> >
2838 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2839 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2840 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2841 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2842 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2843 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2844 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2845 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2846 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2847 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2848 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
2849 {
2850 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
2851 typename Storage_Type<P2>::type,
2852 typename Storage_Type<P3>::type,
2853 typename Storage_Type<P4>::type,
2854 typename Storage_Type<P5>::type,
2855 typename Storage_Type<P6>::type,
2856 typename Storage_Type<P7>::type,
2857 typename Storage_Type<P8>::type,
2858 typename Storage_Type<P9>::type,
2859 typename Storage_Type<P10>::type,
2860 typename Storage_Type<P11>::type> BoundList;
2861
2862 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2863 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2864 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2865 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2866 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2867 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2868 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2869 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2870 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2871 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2872 BSLS_COMPILERFEATURES_FORWARD(P11, p11));
2873
2874 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2875 }
2876
2877 /// Return a `Bind` object that is bound to the specified invocable
2878 /// object `func`, which can be invoked with twelve parameters and
2879 /// returns a value of type `t_RET`.
2880 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2881 class P4, class P5, class P6,
2882 class P7, class P8, class P9,
2883 class P10, class P11, class P12>
2884 static
2885 Bind<t_RET,
2886 t_FUNC,
2887 Bind_BoundTuple12<typename Storage_Type<P1>::type,
2888 typename Storage_Type<P2>::type,
2889 typename Storage_Type<P3>::type,
2890 typename Storage_Type<P4>::type,
2891 typename Storage_Type<P5>::type,
2892 typename Storage_Type<P6>::type,
2893 typename Storage_Type<P7>::type,
2894 typename Storage_Type<P8>::type,
2895 typename Storage_Type<P9>::type,
2896 typename Storage_Type<P10>::type,
2897 typename Storage_Type<P11>::type,
2898 typename Storage_Type<P12>::type> >
2899 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2900 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2901 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2902 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2903 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2904 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2905 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2906 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2907 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2908 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2909 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2910 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
2911 {
2912 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
2913 typename Storage_Type<P2>::type,
2914 typename Storage_Type<P3>::type,
2915 typename Storage_Type<P4>::type,
2916 typename Storage_Type<P5>::type,
2917 typename Storage_Type<P6>::type,
2918 typename Storage_Type<P7>::type,
2919 typename Storage_Type<P8>::type,
2920 typename Storage_Type<P9>::type,
2921 typename Storage_Type<P10>::type,
2922 typename Storage_Type<P11>::type,
2923 typename Storage_Type<P12>::type> BoundList;
2924
2925 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2926 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2927 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2928 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2929 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2930 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2931 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
2932 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
2933 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
2934 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
2935 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
2936 BSLS_COMPILERFEATURES_FORWARD(P12, p12));
2937
2938 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
2939 }
2940
2941 /// Return a `Bind` object that is bound to the specified invocable
2942 /// object `func`, which can be invoked with thirteen parameters and
2943 /// returns a value of type `t_RET`.
2944 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
2945 class P4, class P5, class P6,
2946 class P7, class P8, class P9,
2947 class P10, class P11, class P12,
2948 class P13>
2949 static
2950 Bind<t_RET,
2951 t_FUNC,
2952 Bind_BoundTuple13<typename Storage_Type<P1>::type,
2953 typename Storage_Type<P2>::type,
2954 typename Storage_Type<P3>::type,
2955 typename Storage_Type<P4>::type,
2956 typename Storage_Type<P5>::type,
2957 typename Storage_Type<P6>::type,
2958 typename Storage_Type<P7>::type,
2959 typename Storage_Type<P8>::type,
2960 typename Storage_Type<P9>::type,
2961 typename Storage_Type<P10>::type,
2962 typename Storage_Type<P11>::type,
2963 typename Storage_Type<P12>::type,
2964 typename Storage_Type<P13>::type> >
2965 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
2966 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
2967 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
2968 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
2969 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
2970 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
2971 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
2972 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
2973 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
2974 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
2975 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
2976 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
2977 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
2978 {
2979 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
2980 typename Storage_Type<P2>::type,
2981 typename Storage_Type<P3>::type,
2982 typename Storage_Type<P4>::type,
2983 typename Storage_Type<P5>::type,
2984 typename Storage_Type<P6>::type,
2985 typename Storage_Type<P7>::type,
2986 typename Storage_Type<P8>::type,
2987 typename Storage_Type<P9>::type,
2988 typename Storage_Type<P10>::type,
2989 typename Storage_Type<P11>::type,
2990 typename Storage_Type<P12>::type,
2991 typename Storage_Type<P13>::type> BoundList;
2992
2993 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
2994 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
2995 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
2996 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
2997 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
2998 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
2999 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3000 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3001 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3002 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3003 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3004 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3005 BSLS_COMPILERFEATURES_FORWARD(P13, p13));
3006
3007 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
3008 }
3009
3010 /// Return a `Bind` object that is bound to the specified invocable
3011 /// object `func`, which can be invoked with fourteen parameters and
3012 /// returns a value of type `t_RET`.
3013 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3014 class P4, class P5, class P6,
3015 class P7, class P8, class P9,
3016 class P10, class P11, class P12,
3017 class P13, class P14>
3018 static
3019 Bind<t_RET,
3020 t_FUNC,
3021 Bind_BoundTuple14<typename Storage_Type<P1>::type,
3022 typename Storage_Type<P2>::type,
3023 typename Storage_Type<P3>::type,
3024 typename Storage_Type<P4>::type,
3025 typename Storage_Type<P5>::type,
3026 typename Storage_Type<P6>::type,
3027 typename Storage_Type<P7>::type,
3028 typename Storage_Type<P8>::type,
3029 typename Storage_Type<P9>::type,
3030 typename Storage_Type<P10>::type,
3031 typename Storage_Type<P11>::type,
3032 typename Storage_Type<P12>::type,
3033 typename Storage_Type<P13>::type,
3034 typename Storage_Type<P14>::type> >
3035 bindR(t_FUNC func, BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3036 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3037 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3038 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3039 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3040 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3041 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3042 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3043 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3044 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3045 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3046 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3047 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
3048 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
3049 {
3050 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
3051 typename Storage_Type<P2>::type,
3052 typename Storage_Type<P3>::type,
3053 typename Storage_Type<P4>::type,
3054 typename Storage_Type<P5>::type,
3055 typename Storage_Type<P6>::type,
3056 typename Storage_Type<P7>::type,
3057 typename Storage_Type<P8>::type,
3058 typename Storage_Type<P9>::type,
3059 typename Storage_Type<P10>::type,
3060 typename Storage_Type<P11>::type,
3061 typename Storage_Type<P12>::type,
3062 typename Storage_Type<P13>::type,
3063 typename Storage_Type<P14>::type> BoundList;
3064
3065 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3066 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3067 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3068 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3069 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3070 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3071 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3072 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3073 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3074 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3075 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3076 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3077 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3078 BSLS_COMPILERFEATURES_FORWARD(P14, p14));
3079
3080 return Bind<t_RET, t_FUNC, BoundList>(func, MoveUtil::move(list));
3081 }
3082
3083 // - - - - 'bindS' methods - - - -
3084
3085 /// Return a `BindWrapper` object that is bound to the specified `func`
3086 /// invocable object which can be invoked with no parameters, using the
3087 /// specified `allocator` to supply memory, or the currently installed
3088 /// default allocator if `allocator == 0`.
3089 template <class t_FUNC>
3090 static
3091 BindWrapper<bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0 >
3092 bindS(bslma::Allocator *allocator, t_FUNC func)
3093 {
3094 return BindWrapper<bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0>
3095 (func, bdlf::Bind_BoundTuple0(),allocator);
3096 }
3097
3098 /// Return a `BindWrapper` object that is bound to the specified
3099 /// invocable object `func`, which can be invoked with one parameters,
3100 /// using the specified `allocator` to supply memory, or the currently
3101 /// installed default allocator if `allocator == 0`.
3102 template <class t_FUNC, class P1>
3103 static
3104 BindWrapper<bslmf::Nil,
3105 t_FUNC,
3106 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
3107 bindS(bslma::Allocator *allocator,
3108 t_FUNC func,
3109 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
3110 {
3111 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
3112 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1), allocator);
3113
3114 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3115 (func, MoveUtil::move(list), allocator);
3116 }
3117
3118 /// Return a `BindWrapper` object that is bound to the specified
3119 /// invocable object `func`, which can be invoked with two parameters,
3120 /// using the specified `allocator` to supply memory, or the currently
3121 /// installed default allocator if `allocator == 0`.
3122 template <class t_FUNC, class P1, class P2>
3123 static
3124 BindWrapper<bslmf::Nil,
3125 t_FUNC,
3126 Bind_BoundTuple2<typename Storage_Type<P1>::type,
3127 typename Storage_Type<P2>::type> >
3128 bindS(bslma::Allocator *allocator,
3129 t_FUNC func,
3130 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3131 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
3132 {
3133 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
3134 typename Storage_Type<P2>::type> BoundList;
3135
3136 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3137 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3138 allocator);
3139
3140 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3141 (func, MoveUtil::move(list), allocator);
3142 }
3143
3144 /// Return a `BindWrapper` object that is bound to the specified
3145 /// invocable object `func`, which can be invoked with three parameters,
3146 /// using the specified `allocator` to supply memory, or the currently
3147 /// installed default allocator if `allocator == 0`.
3148 template <class t_FUNC, class P1, class P2, class P3>
3149 static
3150 BindWrapper<bslmf::Nil,
3151 t_FUNC,
3152 Bind_BoundTuple3<typename Storage_Type<P1>::type,
3153 typename Storage_Type<P2>::type,
3154 typename Storage_Type<P3>::type> >
3155 bindS(bslma::Allocator *allocator,
3156 t_FUNC func,
3157 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3158 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3159 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
3160 {
3161 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
3162 typename Storage_Type<P2>::type,
3163 typename Storage_Type<P3>::type> BoundList;
3164
3165 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3166 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3167 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3168 allocator);
3169
3170 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3171 (func, MoveUtil::move(list), allocator);
3172 }
3173
3174 /// Return a `BindWrapper` object that is bound to the specified
3175 /// invocable object `func`, which can be invoked with four parameters,
3176 /// using the specified `allocator` to supply memory, or the currently
3177 /// installed default allocator if `allocator == 0`.
3178 template <class t_FUNC, class P1, class P2, class P3, class P4>
3179 static
3180 BindWrapper<bslmf::Nil,
3181 t_FUNC,
3182 Bind_BoundTuple4<typename Storage_Type<P1>::type,
3183 typename Storage_Type<P2>::type,
3184 typename Storage_Type<P3>::type,
3185 typename Storage_Type<P4>::type> >
3186 bindS(bslma::Allocator *allocator,
3187 t_FUNC func,
3188 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3189 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3190 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3191 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
3192 {
3193 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
3194 typename Storage_Type<P2>::type,
3195 typename Storage_Type<P3>::type,
3196 typename Storage_Type<P4>::type> BoundList;
3197
3198 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3199 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3200 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3201 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3202 allocator);
3203
3204 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3205 (func, MoveUtil::move(list), allocator);
3206 }
3207
3208 /// Return a `BindWrapper` object that is bound to the specified
3209 /// invocable object `func`, which can be invoked with five parameters,
3210 /// using the specified `allocator` to supply memory, or the currently
3211 /// installed default allocator if `allocator == 0`.
3212 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5>
3213 static
3214 BindWrapper<bslmf::Nil,
3215 t_FUNC,
3216 Bind_BoundTuple5<typename Storage_Type<P1>::type,
3217 typename Storage_Type<P2>::type,
3218 typename Storage_Type<P3>::type,
3219 typename Storage_Type<P4>::type,
3220 typename Storage_Type<P5>::type> >
3221 bindS(bslma::Allocator *allocator,
3222 t_FUNC func,
3223 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3224 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3225 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3226 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3227 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
3228 {
3229 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
3230 typename Storage_Type<P2>::type,
3231 typename Storage_Type<P3>::type,
3232 typename Storage_Type<P4>::type,
3233 typename Storage_Type<P5>::type> BoundList;
3234
3235 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3236 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3237 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3238 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3239 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3240 allocator);
3241
3242 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3243 (func, MoveUtil::move(list), allocator);
3244 }
3245
3246 /// Return a `BindWrapper` object that is bound to the specified
3247 /// invocable object `func`, which can be invoked with six parameters,
3248 /// using the specified `allocator` to supply memory, or the currently
3249 /// installed default allocator if `allocator == 0`.
3250 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3251 class P6>
3252 static
3253 BindWrapper<bslmf::Nil,
3254 t_FUNC,
3255 Bind_BoundTuple6<typename Storage_Type<P1>::type,
3256 typename Storage_Type<P2>::type,
3257 typename Storage_Type<P3>::type,
3258 typename Storage_Type<P4>::type,
3259 typename Storage_Type<P5>::type,
3260 typename Storage_Type<P6>::type> >
3261 bindS(bslma::Allocator *allocator,
3262 t_FUNC func,
3263 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3264 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3265 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3266 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3267 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3268 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
3269 {
3270 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
3271 typename Storage_Type<P2>::type,
3272 typename Storage_Type<P3>::type,
3273 typename Storage_Type<P4>::type,
3274 typename Storage_Type<P5>::type,
3275 typename Storage_Type<P6>::type> BoundList;
3276
3277 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3278 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3279 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3280 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3281 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3282 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3283 allocator);
3284
3285 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3286 (func, MoveUtil::move(list), allocator);
3287 }
3288
3289 /// Return a `BindWrapper` object that is bound to the specified
3290 /// invocable object `func`, which can be invoked with seven parameters,
3291 /// using the specified `allocator` to supply memory, or the currently
3292 /// installed default allocator if `allocator == 0`.
3293 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3294 class P6, class P7>
3295 static
3296 BindWrapper<bslmf::Nil,
3297 t_FUNC,
3298 Bind_BoundTuple7<typename Storage_Type<P1>::type,
3299 typename Storage_Type<P2>::type,
3300 typename Storage_Type<P3>::type,
3301 typename Storage_Type<P4>::type,
3302 typename Storage_Type<P5>::type,
3303 typename Storage_Type<P6>::type,
3304 typename Storage_Type<P7>::type> >
3305 bindS(bslma::Allocator *allocator,
3306 t_FUNC func,
3307 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3308 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3309 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3310 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3311 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3312 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3313 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
3314 {
3315 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
3316 typename Storage_Type<P2>::type,
3317 typename Storage_Type<P3>::type,
3318 typename Storage_Type<P4>::type,
3319 typename Storage_Type<P5>::type,
3320 typename Storage_Type<P6>::type,
3321 typename Storage_Type<P7>::type> BoundList;
3322
3323 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3324 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3325 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3326 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3327 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3328 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3329 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3330 allocator);
3331
3332 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3333 (func, MoveUtil::move(list), allocator);
3334 }
3335
3336 /// Return a `BindWrapper` object that is bound to the specified
3337 /// invocable object `func`, which can be invoked with eight parameters,
3338 /// using the specified `allocator` to supply memory, or the currently
3339 /// installed default allocator if `allocator == 0`.
3340 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3341 class P6, class P7, class P8>
3342 static
3343 BindWrapper<bslmf::Nil,
3344 t_FUNC,
3345 Bind_BoundTuple8<typename Storage_Type<P1>::type,
3346 typename Storage_Type<P2>::type,
3347 typename Storage_Type<P3>::type,
3348 typename Storage_Type<P4>::type,
3349 typename Storage_Type<P5>::type,
3350 typename Storage_Type<P6>::type,
3351 typename Storage_Type<P7>::type,
3352 typename Storage_Type<P8>::type> >
3353 bindS(bslma::Allocator *allocator,
3354 t_FUNC func,
3355 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3356 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3357 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3358 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3359 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3360 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3361 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3362 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
3363 {
3364 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
3365 typename Storage_Type<P2>::type,
3366 typename Storage_Type<P3>::type,
3367 typename Storage_Type<P4>::type,
3368 typename Storage_Type<P5>::type,
3369 typename Storage_Type<P6>::type,
3370 typename Storage_Type<P7>::type,
3371 typename Storage_Type<P8>::type> BoundList;
3372
3373 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3374 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3375 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3376 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3377 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3378 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3379 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3380 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3381 allocator);
3382
3383 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3384 (func, MoveUtil::move(list), allocator);
3385 }
3386
3387 /// Return a `BindWrapper` object that is bound to the specified
3388 /// invocable object `func`, which can be invoked with nine parameters,
3389 /// using the specified `allocator` to supply memory, or the currently
3390 /// installed default allocator if `allocator == 0`.
3391 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3392 class P6, class P7, class P8, class P9>
3393 static
3394 BindWrapper<bslmf::Nil,
3395 t_FUNC,
3396 Bind_BoundTuple9<typename Storage_Type<P1>::type,
3397 typename Storage_Type<P2>::type,
3398 typename Storage_Type<P3>::type,
3399 typename Storage_Type<P4>::type,
3400 typename Storage_Type<P5>::type,
3401 typename Storage_Type<P6>::type,
3402 typename Storage_Type<P7>::type,
3403 typename Storage_Type<P8>::type,
3404 typename Storage_Type<P9>::type> >
3405 bindS(bslma::Allocator *allocator,
3406 t_FUNC func,
3407 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3408 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3409 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3410 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3411 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3412 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3413 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3414 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3415 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
3416 {
3417 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
3418 typename Storage_Type<P2>::type,
3419 typename Storage_Type<P3>::type,
3420 typename Storage_Type<P4>::type,
3421 typename Storage_Type<P5>::type,
3422 typename Storage_Type<P6>::type,
3423 typename Storage_Type<P7>::type,
3424 typename Storage_Type<P8>::type,
3425 typename Storage_Type<P9>::type> BoundList;
3426
3427 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3428 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3429 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3430 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3431 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3432 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3433 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3434 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3435 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3436 allocator);
3437
3438 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3439 (func, MoveUtil::move(list), allocator);
3440 }
3441
3442 /// Return a `BindWrapper` object that is bound to the specified
3443 /// invocable object `func`, which can be invoked with ten parameters,
3444 /// using the specified `allocator` to supply memory, or the currently
3445 /// installed default allocator if `allocator == 0`.
3446 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3447 class P6, class P7, class P8, class P9, class P10>
3448 static
3449 BindWrapper<bslmf::Nil,
3450 t_FUNC,
3451 Bind_BoundTuple10<typename Storage_Type<P1>::type,
3452 typename Storage_Type<P2>::type,
3453 typename Storage_Type<P3>::type,
3454 typename Storage_Type<P4>::type,
3455 typename Storage_Type<P5>::type,
3456 typename Storage_Type<P6>::type,
3457 typename Storage_Type<P7>::type,
3458 typename Storage_Type<P8>::type,
3459 typename Storage_Type<P9>::type,
3460 typename Storage_Type<P10>::type> >
3461 bindS(bslma::Allocator *allocator,
3462 t_FUNC func,
3463 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3464 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3465 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3466 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3467 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3468 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3469 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3470 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3471 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3472 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
3473 {
3474 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
3475 typename Storage_Type<P2>::type,
3476 typename Storage_Type<P3>::type,
3477 typename Storage_Type<P4>::type,
3478 typename Storage_Type<P5>::type,
3479 typename Storage_Type<P6>::type,
3480 typename Storage_Type<P7>::type,
3481 typename Storage_Type<P8>::type,
3482 typename Storage_Type<P9>::type,
3483 typename Storage_Type<P10>::type> BoundList;
3484
3485 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3486 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3487 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3488 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3489 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3490 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3491 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3492 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3493 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3494 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3495 allocator);
3496
3497 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3498 (func, MoveUtil::move(list), allocator);
3499 }
3500
3501 /// Return a `BindWrapper` object that is bound to the specified
3502 /// invocable object `func`, which can be invoked with eleven
3503 /// parameters, using the specified `allocator` to supply memory, or the
3504 /// currently installed default allocator if `allocator == 0`.
3505 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3506 class P6, class P7, class P8, class P9, class P10, class P11>
3507 static
3508 BindWrapper<bslmf::Nil,
3509 t_FUNC,
3510 Bind_BoundTuple11<typename Storage_Type<P1>::type,
3511 typename Storage_Type<P2>::type,
3512 typename Storage_Type<P3>::type,
3513 typename Storage_Type<P4>::type,
3514 typename Storage_Type<P5>::type,
3515 typename Storage_Type<P6>::type,
3516 typename Storage_Type<P7>::type,
3517 typename Storage_Type<P8>::type,
3518 typename Storage_Type<P9>::type,
3519 typename Storage_Type<P10>::type,
3520 typename Storage_Type<P11>::type> >
3521 bindS(bslma::Allocator *allocator,
3522 t_FUNC func,
3523 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3524 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3525 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3526 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3527 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3528 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3529 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3530 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3531 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3532 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3533 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
3534 {
3535 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
3536 typename Storage_Type<P2>::type,
3537 typename Storage_Type<P3>::type,
3538 typename Storage_Type<P4>::type,
3539 typename Storage_Type<P5>::type,
3540 typename Storage_Type<P6>::type,
3541 typename Storage_Type<P7>::type,
3542 typename Storage_Type<P8>::type,
3543 typename Storage_Type<P9>::type,
3544 typename Storage_Type<P10>::type,
3545 typename Storage_Type<P11>::type> BoundList;
3546
3547 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3548 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3549 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3550 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3551 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3552 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3553 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3554 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3555 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3556 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3557 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3558 allocator);
3559
3560 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3561 (func, MoveUtil::move(list), allocator);
3562 }
3563
3564 /// Return a `BindWrapper` object that is bound to the specified
3565 /// invocable object `func`, which can be invoked with twelve
3566 /// parameters, using the specified `allocator` to supply memory, or the
3567 /// currently installed default allocator if `allocator == 0`.
3568 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3569 class P6, class P7, class P8, class P9, class P10, class P11,
3570 class P12>
3571 static
3572 BindWrapper<bslmf::Nil,
3573 t_FUNC,
3574 Bind_BoundTuple12<typename Storage_Type<P1>::type,
3575 typename Storage_Type<P2>::type,
3576 typename Storage_Type<P3>::type,
3577 typename Storage_Type<P4>::type,
3578 typename Storage_Type<P5>::type,
3579 typename Storage_Type<P6>::type,
3580 typename Storage_Type<P7>::type,
3581 typename Storage_Type<P8>::type,
3582 typename Storage_Type<P9>::type,
3583 typename Storage_Type<P10>::type,
3584 typename Storage_Type<P11>::type,
3585 typename Storage_Type<P12>::type> >
3586 bindS(bslma::Allocator *allocator,
3587 t_FUNC func,
3588 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3589 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3590 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3591 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3592 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3593 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3594 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3595 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3596 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3597 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3598 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3599 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
3600 {
3601 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
3602 typename Storage_Type<P2>::type,
3603 typename Storage_Type<P3>::type,
3604 typename Storage_Type<P4>::type,
3605 typename Storage_Type<P5>::type,
3606 typename Storage_Type<P6>::type,
3607 typename Storage_Type<P7>::type,
3608 typename Storage_Type<P8>::type,
3609 typename Storage_Type<P9>::type,
3610 typename Storage_Type<P10>::type,
3611 typename Storage_Type<P11>::type,
3612 typename Storage_Type<P12>::type> BoundList;
3613
3614 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3615 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3616 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3617 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3618 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3619 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3620 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3621 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3622 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3623 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3624 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3625 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3626 allocator);
3627
3628 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3629 (func, MoveUtil::move(list), allocator);
3630 }
3631
3632 /// Return a `BindWrapper` object that is bound to the specified
3633 /// invocable object `func`, which can be invoked with thirteen
3634 /// parameters, using the specified `allocator` to supply memory, or the
3635 /// currently installed default allocator if `allocator == 0`.
3636 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3637 class P6, class P7, class P8, class P9, class P10, class P11,
3638 class P12, class P13>
3639 static
3640 BindWrapper<bslmf::Nil,
3641 t_FUNC,
3642 Bind_BoundTuple13<typename Storage_Type<P1>::type,
3643 typename Storage_Type<P2>::type,
3644 typename Storage_Type<P3>::type,
3645 typename Storage_Type<P4>::type,
3646 typename Storage_Type<P5>::type,
3647 typename Storage_Type<P6>::type,
3648 typename Storage_Type<P7>::type,
3649 typename Storage_Type<P8>::type,
3650 typename Storage_Type<P9>::type,
3651 typename Storage_Type<P10>::type,
3652 typename Storage_Type<P11>::type,
3653 typename Storage_Type<P12>::type,
3654 typename Storage_Type<P13>::type> >
3655 bindS(bslma::Allocator *allocator,
3656 t_FUNC func,
3657 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3658 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3659 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3660 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3661 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3662 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3663 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3664 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3665 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3666 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3667 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3668 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3669 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
3670 {
3671 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
3672 typename Storage_Type<P2>::type,
3673 typename Storage_Type<P3>::type,
3674 typename Storage_Type<P4>::type,
3675 typename Storage_Type<P5>::type,
3676 typename Storage_Type<P6>::type,
3677 typename Storage_Type<P7>::type,
3678 typename Storage_Type<P8>::type,
3679 typename Storage_Type<P9>::type,
3680 typename Storage_Type<P10>::type,
3681 typename Storage_Type<P11>::type,
3682 typename Storage_Type<P12>::type,
3683 typename Storage_Type<P13>::type> BoundList;
3684
3685 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3686 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3687 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3688 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3689 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3690 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3691 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3692 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3693 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3694 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3695 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3696 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3697 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3698 allocator);
3699
3700 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3701 (func, MoveUtil::move(list), allocator);
3702 }
3703
3704 /// Return a `BindWrapper` object that is bound to the specified
3705 /// invocable object `func`, which can be invoked with fourteen
3706 /// parameters, using the specified `allocator` to supply memory, or the
3707 /// currently installed default allocator if `allocator == 0`.
3708 template <class t_FUNC, class P1, class P2, class P3, class P4, class P5,
3709 class P6, class P7, class P8, class P9, class P10, class P11,
3710 class P12, class P13, class P14>
3711 static
3712 BindWrapper<bslmf::Nil,
3713 t_FUNC,
3714 Bind_BoundTuple14<typename Storage_Type<P1>::type,
3715 typename Storage_Type<P2>::type,
3716 typename Storage_Type<P3>::type,
3717 typename Storage_Type<P4>::type,
3718 typename Storage_Type<P5>::type,
3719 typename Storage_Type<P6>::type,
3720 typename Storage_Type<P7>::type,
3721 typename Storage_Type<P8>::type,
3722 typename Storage_Type<P9>::type,
3723 typename Storage_Type<P10>::type,
3724 typename Storage_Type<P11>::type,
3725 typename Storage_Type<P12>::type,
3726 typename Storage_Type<P13>::type,
3727 typename Storage_Type<P14>::type> >
3728 bindS(bslma::Allocator *allocator,
3729 t_FUNC func,
3730 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3731 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3732 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3733 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3734 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3735 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
3736 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
3737 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
3738 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
3739 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
3740 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
3741 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
3742 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
3743 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
3744 {
3745 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
3746 typename Storage_Type<P2>::type,
3747 typename Storage_Type<P3>::type,
3748 typename Storage_Type<P4>::type,
3749 typename Storage_Type<P5>::type,
3750 typename Storage_Type<P6>::type,
3751 typename Storage_Type<P7>::type,
3752 typename Storage_Type<P8>::type,
3753 typename Storage_Type<P9>::type,
3754 typename Storage_Type<P10>::type,
3755 typename Storage_Type<P11>::type,
3756 typename Storage_Type<P12>::type,
3757 typename Storage_Type<P13>::type,
3758 typename Storage_Type<P14>::type> BoundList;
3759
3760 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3761 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3762 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3763 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3764 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3765 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3766 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
3767 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
3768 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
3769 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
3770 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
3771 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
3772 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
3773 BSLS_COMPILERFEATURES_FORWARD(P14, p14),
3774 allocator);
3775
3776 return BindWrapper<bslmf::Nil, t_FUNC, BoundList>
3777 (func, MoveUtil::move(list), allocator);
3778 }
3779
3780 // - - - - 'bindSR' methods - - - -
3781
3782 /// Return a `BindWrapper` object that is bound to the specified
3783 /// invocable object `func`, which can be invoked with no parameters and
3784 /// returns a value of type `t_RET`, using the specified `allocator` to
3785 /// supply memory, or the currently installed default allocator if
3786 /// `allocator == 0`.
3787 template <class t_RET, class t_FUNC>
3788 static
3789 BindWrapper<t_RET, t_FUNC, bdlf::Bind_BoundTuple0 >
3790 bindSR(bslma::Allocator *allocator, t_FUNC func)
3791 {
3792 return BindWrapper<t_RET, t_FUNC, bdlf::Bind_BoundTuple0>
3793 (func, bdlf::Bind_BoundTuple0(), allocator);
3794 }
3795
3796 /// Return a `BindWrapper` object that is bound to the specified
3797 /// invocable object `func`, which can be invoked with one parameter and
3798 /// returns a value of type `t_RET`, using the specified `allocator` to
3799 /// supply memory, or the currently installed default allocator if
3800 /// `allocator == 0`.
3801 template <class t_RET, class t_FUNC, class P1>
3802 static
3803 BindWrapper<t_RET,
3804 t_FUNC,
3805 Bind_BoundTuple1<typename Storage_Type<P1>::type> >
3806 bindSR(bslma::Allocator *allocator,
3807 t_FUNC func,
3808 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1)
3809 {
3810 typedef Bind_BoundTuple1<typename Storage_Type<P1>::type> BoundList;
3811 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1), allocator);
3812
3813 return BindWrapper<t_RET, t_FUNC, BoundList>
3814 (func, MoveUtil::move(list), allocator);
3815 }
3816
3817 /// Return a `BindWrapper` object that is bound to the specified
3818 /// invocable object `func`, which can be invoked with two parameters
3819 /// and returns a value of type `t_RET`, using the specified `allocator`
3820 /// to supply memory, or the currently installed default allocator if
3821 /// `allocator == 0`.
3822 template <class t_RET, class t_FUNC, class P1, class P2>
3823 static
3824 BindWrapper<t_RET,
3825 t_FUNC,
3826 Bind_BoundTuple2<typename Storage_Type<P1>::type,
3827 typename Storage_Type<P2>::type> >
3828 bindSR(bslma::Allocator *allocator,
3829 t_FUNC func,
3830 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3831 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2)
3832 {
3833 typedef Bind_BoundTuple2<typename Storage_Type<P1>::type,
3834 typename Storage_Type<P2>::type> BoundList;
3835
3836 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3837 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3838 allocator);
3839
3840 return BindWrapper<t_RET, t_FUNC, BoundList>
3841 (func, MoveUtil::move(list), allocator);
3842 }
3843
3844 /// Return a `BindWrapper` object that is bound to the specified
3845 /// invocable object `func`, which can be invoked with three parameters
3846 /// and returns a value of type `t_RET`, using the specified `allocator`
3847 /// to supply memory, or the currently installed default allocator if
3848 /// `allocator == 0`.
3849 template <class t_RET, class t_FUNC, class P1, class P2, class P3>
3850 static
3851 BindWrapper<t_RET,
3852 t_FUNC,
3853 Bind_BoundTuple3<typename Storage_Type<P1>::type,
3854 typename Storage_Type<P2>::type,
3855 typename Storage_Type<P3>::type> >
3856 bindSR(bslma::Allocator *allocator,
3857 t_FUNC func,
3858 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3859 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3860 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3)
3861 {
3862 typedef Bind_BoundTuple3<typename Storage_Type<P1>::type,
3863 typename Storage_Type<P2>::type,
3864 typename Storage_Type<P3>::type> BoundList;
3865
3866 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3867 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3868 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3869 allocator);
3870
3871 return BindWrapper<t_RET, t_FUNC, BoundList>
3872 (func, MoveUtil::move(list), allocator);
3873 }
3874
3875 /// Return a `BindWrapper` object that is bound to the specified
3876 /// invocable object `func`, which can be invoked with four parameters
3877 /// and returns a value of type `t_RET`, using the specified `allocator`
3878 /// to supply memory, or the currently installed default allocator if
3879 /// `allocator == 0`.
3880 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3881 class P4>
3882 static
3883 BindWrapper<t_RET,
3884 t_FUNC,
3885 Bind_BoundTuple4<typename Storage_Type<P1>::type,
3886 typename Storage_Type<P2>::type,
3887 typename Storage_Type<P3>::type,
3888 typename Storage_Type<P4>::type> >
3889 bindSR(bslma::Allocator *allocator,
3890 t_FUNC func,
3891 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3892 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3893 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3894 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4)
3895 {
3896 typedef Bind_BoundTuple4<typename Storage_Type<P1>::type,
3897 typename Storage_Type<P2>::type,
3898 typename Storage_Type<P3>::type,
3899 typename Storage_Type<P4>::type> BoundList;
3900
3901 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3902 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3903 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3904 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3905 allocator);
3906
3907 return BindWrapper<t_RET, t_FUNC, BoundList>
3908 (func, MoveUtil::move(list), allocator);
3909 }
3910
3911 /// Return a `BindWrapper` object that is bound to the specified
3912 /// invocable object `func`, which can be invoked with five parameters
3913 /// and returns a value of type `t_RET`, using the specified `allocator`
3914 /// to supply memory, or the currently installed default allocator if
3915 /// `allocator == 0`.
3916 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3917 class P4, class P5>
3918 static
3919 BindWrapper<t_RET,
3920 t_FUNC,
3921 Bind_BoundTuple5<typename Storage_Type<P1>::type,
3922 typename Storage_Type<P2>::type,
3923 typename Storage_Type<P3>::type,
3924 typename Storage_Type<P4>::type,
3925 typename Storage_Type<P5>::type> >
3926 bindSR(bslma::Allocator *allocator,
3927 t_FUNC func,
3928 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3929 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3930 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3931 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3932 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5)
3933 {
3934 typedef Bind_BoundTuple5<typename Storage_Type<P1>::type,
3935 typename Storage_Type<P2>::type,
3936 typename Storage_Type<P3>::type,
3937 typename Storage_Type<P4>::type,
3938 typename Storage_Type<P5>::type> BoundList;
3939
3940 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3941 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3942 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3943 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3944 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3945 allocator);
3946
3947 return BindWrapper<t_RET, t_FUNC, BoundList>
3948 (func, MoveUtil::move(list), allocator);
3949 }
3950
3951 /// Return a `BindWrapper` object that is bound to the specified
3952 /// invocable object `func`, which can be invoked with six parameters
3953 /// and returns a value of type `t_RET`, using the specified `allocator`
3954 /// to supply memory, or the currently installed default allocator if
3955 /// `allocator == 0`.
3956 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
3957 class P4, class P5, class P6>
3958 static
3959 BindWrapper<t_RET,
3960 t_FUNC,
3961 Bind_BoundTuple6<typename Storage_Type<P1>::type,
3962 typename Storage_Type<P2>::type,
3963 typename Storage_Type<P3>::type,
3964 typename Storage_Type<P4>::type,
3965 typename Storage_Type<P5>::type,
3966 typename Storage_Type<P6>::type> >
3967 bindSR(bslma::Allocator *allocator,
3968 t_FUNC func,
3969 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
3970 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
3971 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
3972 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
3973 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
3974 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6)
3975 {
3976 typedef Bind_BoundTuple6<typename Storage_Type<P1>::type,
3977 typename Storage_Type<P2>::type,
3978 typename Storage_Type<P3>::type,
3979 typename Storage_Type<P4>::type,
3980 typename Storage_Type<P5>::type,
3981 typename Storage_Type<P6>::type> BoundList;
3982
3983 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
3984 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
3985 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
3986 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
3987 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
3988 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
3989 allocator);
3990
3991 return BindWrapper<t_RET, t_FUNC, BoundList>
3992 (func, MoveUtil::move(list), allocator);
3993 }
3994
3995 /// Return a `BindWrapper` object that is bound to the specified
3996 /// invocable object `func`, which can be invoked with seven parameters
3997 /// and returns a value of type `t_RET`, using the specified `allocator`
3998 /// to supply memory, or the currently installed default allocator if
3999 /// `allocator == 0`.
4000 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4001 class P4, class P5, class P6,
4002 class P7>
4003 static
4004 BindWrapper<t_RET,
4005 t_FUNC,
4006 Bind_BoundTuple7<typename Storage_Type<P1>::type,
4007 typename Storage_Type<P2>::type,
4008 typename Storage_Type<P3>::type,
4009 typename Storage_Type<P4>::type,
4010 typename Storage_Type<P5>::type,
4011 typename Storage_Type<P6>::type,
4012 typename Storage_Type<P7>::type> >
4013 bindSR(bslma::Allocator *allocator,
4014 t_FUNC func,
4015 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4016 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4017 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4018 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4019 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4020 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4021 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7)
4022 {
4023 typedef Bind_BoundTuple7<typename Storage_Type<P1>::type,
4024 typename Storage_Type<P2>::type,
4025 typename Storage_Type<P3>::type,
4026 typename Storage_Type<P4>::type,
4027 typename Storage_Type<P5>::type,
4028 typename Storage_Type<P6>::type,
4029 typename Storage_Type<P7>::type> BoundList;
4030
4031 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4032 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4033 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4034 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4035 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4036 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4037 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4038 allocator);
4039
4040 return BindWrapper<t_RET, t_FUNC, BoundList>
4041 (func, MoveUtil::move(list), allocator);
4042 }
4043
4044 /// Return a `BindWrapper` object that is bound to the specified
4045 /// invocable object `func`, which can be invoked with eight parameters
4046 /// and returns a value of type `t_RET`, using the specified `allocator`
4047 /// to supply memory, or the currently installed default allocator if
4048 /// `allocator == 0`.
4049 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4050 class P4, class P5, class P6,
4051 class P7, class P8>
4052 static
4053 BindWrapper<t_RET,
4054 t_FUNC,
4055 Bind_BoundTuple8<typename Storage_Type<P1>::type,
4056 typename Storage_Type<P2>::type,
4057 typename Storage_Type<P3>::type,
4058 typename Storage_Type<P4>::type,
4059 typename Storage_Type<P5>::type,
4060 typename Storage_Type<P6>::type,
4061 typename Storage_Type<P7>::type,
4062 typename Storage_Type<P8>::type> >
4063 bindSR(bslma::Allocator *allocator,
4064 t_FUNC func,
4065 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4066 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4067 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4068 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4069 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4070 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4071 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4072 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8)
4073 {
4074 typedef Bind_BoundTuple8<typename Storage_Type<P1>::type,
4075 typename Storage_Type<P2>::type,
4076 typename Storage_Type<P3>::type,
4077 typename Storage_Type<P4>::type,
4078 typename Storage_Type<P5>::type,
4079 typename Storage_Type<P6>::type,
4080 typename Storage_Type<P7>::type,
4081 typename Storage_Type<P8>::type> BoundList;
4082
4083 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4084 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4085 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4086 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4087 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4088 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4089 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4090 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4091 allocator);
4092
4093 return BindWrapper<t_RET, t_FUNC, BoundList>
4094 (func, MoveUtil::move(list), allocator);
4095 }
4096
4097 /// Return a `BindWrapper` object that is bound to the specified
4098 /// invocable object `func`, which can be invoked with nine parameters
4099 /// and returns a value of type `t_RET`, using the specified `allocator`
4100 /// to supply memory, or the currently installed default allocator if
4101 /// `allocator == 0`.
4102 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4103 class P4, class P5, class P6,
4104 class P7, class P8, class P9>
4105 static
4106 BindWrapper<t_RET,
4107 t_FUNC,
4108 Bind_BoundTuple9<typename Storage_Type<P1>::type,
4109 typename Storage_Type<P2>::type,
4110 typename Storage_Type<P3>::type,
4111 typename Storage_Type<P4>::type,
4112 typename Storage_Type<P5>::type,
4113 typename Storage_Type<P6>::type,
4114 typename Storage_Type<P7>::type,
4115 typename Storage_Type<P8>::type,
4116 typename Storage_Type<P9>::type> >
4117 bindSR(bslma::Allocator *allocator,
4118 t_FUNC func,
4119 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4120 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4121 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4122 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4123 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4124 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4125 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4126 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4127 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9)
4128 {
4129 typedef Bind_BoundTuple9<typename Storage_Type<P1>::type,
4130 typename Storage_Type<P2>::type,
4131 typename Storage_Type<P3>::type,
4132 typename Storage_Type<P4>::type,
4133 typename Storage_Type<P5>::type,
4134 typename Storage_Type<P6>::type,
4135 typename Storage_Type<P7>::type,
4136 typename Storage_Type<P8>::type,
4137 typename Storage_Type<P9>::type> BoundList;
4138
4139 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4140 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4141 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4142 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4143 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4144 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4145 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4146 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4147 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4148 allocator);
4149
4150 return BindWrapper<t_RET, t_FUNC, BoundList>
4151 (func, MoveUtil::move(list), allocator);
4152 }
4153
4154 /// Return a `BindWrapper` object that is bound to the specified
4155 /// invocable object `func`, which can be invoked with ten parameters
4156 /// and returns a value of type `t_RET`, using the specified `allocator`
4157 /// to supply memory, or the currently installed default allocator if
4158 /// `allocator == 0`.
4159 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4160 class P4, class P5, class P6,
4161 class P7, class P8, class P9,
4162 class P10>
4163 static
4164 BindWrapper<t_RET,
4165 t_FUNC,
4166 Bind_BoundTuple10<typename Storage_Type<P1>::type,
4167 typename Storage_Type<P2>::type,
4168 typename Storage_Type<P3>::type,
4169 typename Storage_Type<P4>::type,
4170 typename Storage_Type<P5>::type,
4171 typename Storage_Type<P6>::type,
4172 typename Storage_Type<P7>::type,
4173 typename Storage_Type<P8>::type,
4174 typename Storage_Type<P9>::type,
4175 typename Storage_Type<P10>::type> >
4176 bindSR(bslma::Allocator *allocator,
4177 t_FUNC func,
4178 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4179 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4180 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4181 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4182 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4183 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4184 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4185 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4186 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4187 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10)
4188 {
4189 typedef Bind_BoundTuple10<typename Storage_Type<P1>::type,
4190 typename Storage_Type<P2>::type,
4191 typename Storage_Type<P3>::type,
4192 typename Storage_Type<P4>::type,
4193 typename Storage_Type<P5>::type,
4194 typename Storage_Type<P6>::type,
4195 typename Storage_Type<P7>::type,
4196 typename Storage_Type<P8>::type,
4197 typename Storage_Type<P9>::type,
4198 typename Storage_Type<P10>::type> BoundList;
4199
4200 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4201 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4202 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4203 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4204 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4205 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4206 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4207 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4208 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4209 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4210 allocator);
4211
4212 return BindWrapper<t_RET, t_FUNC, BoundList>
4213 (func, MoveUtil::move(list), allocator);
4214 }
4215
4216 /// Return a `BindWrapper` object that is bound to the specified
4217 /// invocable object `func`, which can be invoked with eleven parameters
4218 /// and returns a value of type `t_RET`, using the specified `allocator`
4219 /// to supply memory, or the currently installed default allocator if
4220 /// `allocator == 0`.
4221 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4222 class P4, class P5, class P6,
4223 class P7, class P8, class P9,
4224 class P10, class P11>
4225 static
4226 BindWrapper<t_RET,
4227 t_FUNC,
4228 Bind_BoundTuple11<typename Storage_Type<P1>::type,
4229 typename Storage_Type<P2>::type,
4230 typename Storage_Type<P3>::type,
4231 typename Storage_Type<P4>::type,
4232 typename Storage_Type<P5>::type,
4233 typename Storage_Type<P6>::type,
4234 typename Storage_Type<P7>::type,
4235 typename Storage_Type<P8>::type,
4236 typename Storage_Type<P9>::type,
4237 typename Storage_Type<P10>::type,
4238 typename Storage_Type<P11>::type> >
4239 bindSR(bslma::Allocator *allocator,
4240 t_FUNC func,
4241 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4242 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4243 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4244 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4245 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4246 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4247 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4248 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4249 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4250 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4251 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11)
4252 {
4253 typedef Bind_BoundTuple11<typename Storage_Type<P1>::type,
4254 typename Storage_Type<P2>::type,
4255 typename Storage_Type<P3>::type,
4256 typename Storage_Type<P4>::type,
4257 typename Storage_Type<P5>::type,
4258 typename Storage_Type<P6>::type,
4259 typename Storage_Type<P7>::type,
4260 typename Storage_Type<P8>::type,
4261 typename Storage_Type<P9>::type,
4262 typename Storage_Type<P10>::type,
4263 typename Storage_Type<P11>::type> BoundList;
4264
4265 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4266 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4267 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4268 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4269 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4270 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4271 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4272 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4273 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4274 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4275 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4276 allocator);
4277
4278 return BindWrapper<t_RET, t_FUNC, BoundList>
4279 (func, MoveUtil::move(list), allocator);
4280 }
4281
4282 /// Return a `BindWrapper` object that is bound to the specified
4283 /// invocable object `func`, which can be invoked with twelve parameters
4284 /// and returns a value of type `t_RET`, using the specified `allocator`
4285 /// to supply memory, or the currently installed default allocator if
4286 /// `allocator == 0`.
4287 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4288 class P4, class P5, class P6,
4289 class P7, class P8, class P9,
4290 class P10, class P11, class P12>
4291 static
4292 BindWrapper<t_RET,
4293 t_FUNC,
4294 Bind_BoundTuple12<typename Storage_Type<P1>::type,
4295 typename Storage_Type<P2>::type,
4296 typename Storage_Type<P3>::type,
4297 typename Storage_Type<P4>::type,
4298 typename Storage_Type<P5>::type,
4299 typename Storage_Type<P6>::type,
4300 typename Storage_Type<P7>::type,
4301 typename Storage_Type<P8>::type,
4302 typename Storage_Type<P9>::type,
4303 typename Storage_Type<P10>::type,
4304 typename Storage_Type<P11>::type,
4305 typename Storage_Type<P12>::type> >
4306 bindSR(bslma::Allocator *allocator,
4307 t_FUNC func,
4308 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4309 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4310 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4311 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4312 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4313 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4314 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4315 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4316 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4317 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4318 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4319 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12)
4320 {
4321 typedef Bind_BoundTuple12<typename Storage_Type<P1>::type,
4322 typename Storage_Type<P2>::type,
4323 typename Storage_Type<P3>::type,
4324 typename Storage_Type<P4>::type,
4325 typename Storage_Type<P5>::type,
4326 typename Storage_Type<P6>::type,
4327 typename Storage_Type<P7>::type,
4328 typename Storage_Type<P8>::type,
4329 typename Storage_Type<P9>::type,
4330 typename Storage_Type<P10>::type,
4331 typename Storage_Type<P11>::type,
4332 typename Storage_Type<P12>::type> BoundList;
4333
4334 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4335 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4336 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4337 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4338 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4339 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4340 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4341 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4342 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4343 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4344 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4345 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4346 allocator);
4347
4348 return BindWrapper<t_RET, t_FUNC, BoundList>
4349 (func, MoveUtil::move(list), allocator);
4350 }
4351
4352 /// Return a `BindWrapper` object that is bound to the specified
4353 /// invocable object `func`, which can be invoked with thirteen
4354 /// parameters and returns a value of type `t_RET`, using the specified
4355 /// `allocator` to supply memory, or the currently installed default
4356 /// allocator if `allocator == 0`.
4357 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4358 class P4, class P5, class P6,
4359 class P7, class P8, class P9,
4360 class P10, class P11, class P12,
4361 class P13>
4362 static
4363 BindWrapper<t_RET,
4364 t_FUNC,
4365 Bind_BoundTuple13<typename Storage_Type<P1>::type,
4366 typename Storage_Type<P2>::type,
4367 typename Storage_Type<P3>::type,
4368 typename Storage_Type<P4>::type,
4369 typename Storage_Type<P5>::type,
4370 typename Storage_Type<P6>::type,
4371 typename Storage_Type<P7>::type,
4372 typename Storage_Type<P8>::type,
4373 typename Storage_Type<P9>::type,
4374 typename Storage_Type<P10>::type,
4375 typename Storage_Type<P11>::type,
4376 typename Storage_Type<P12>::type,
4377 typename Storage_Type<P13>::type> >
4378 bindSR(bslma::Allocator *allocator,
4379 t_FUNC func,
4380 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4381 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4382 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4383 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4384 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4385 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4386 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4387 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4388 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4389 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4390 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4391 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
4392 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13)
4393 {
4394 typedef Bind_BoundTuple13<typename Storage_Type<P1>::type,
4395 typename Storage_Type<P2>::type,
4396 typename Storage_Type<P3>::type,
4397 typename Storage_Type<P4>::type,
4398 typename Storage_Type<P5>::type,
4399 typename Storage_Type<P6>::type,
4400 typename Storage_Type<P7>::type,
4401 typename Storage_Type<P8>::type,
4402 typename Storage_Type<P9>::type,
4403 typename Storage_Type<P10>::type,
4404 typename Storage_Type<P11>::type,
4405 typename Storage_Type<P12>::type,
4406 typename Storage_Type<P13>::type> BoundList;
4407
4408 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4409 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4410 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4411 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4412 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4413 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4414 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4415 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4416 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4417 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4418 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4419 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4420 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
4421 allocator);
4422
4423 return BindWrapper<t_RET, t_FUNC, BoundList>
4424 (func, MoveUtil::move(list), allocator);
4425 }
4426
4427 /// Return a `BindWrapper` object that is bound to the specified
4428 /// invocable object `func`, which can be invoked with fourteen
4429 /// parameters and returns a value of type `t_RET`, using the specified
4430 /// `allocator` to supply memory, or the currently installed default
4431 /// allocator if `allocator == 0`.
4432 template <class t_RET, class t_FUNC, class P1, class P2, class P3,
4433 class P4, class P5, class P6,
4434 class P7, class P8, class P9,
4435 class P10, class P11, class P12,
4436 class P13, class P14>
4437 static
4438 BindWrapper<t_RET,
4439 t_FUNC,
4440 Bind_BoundTuple14<typename Storage_Type<P1>::type,
4441 typename Storage_Type<P2>::type,
4442 typename Storage_Type<P3>::type,
4443 typename Storage_Type<P4>::type,
4444 typename Storage_Type<P5>::type,
4445 typename Storage_Type<P6>::type,
4446 typename Storage_Type<P7>::type,
4447 typename Storage_Type<P8>::type,
4448 typename Storage_Type<P9>::type,
4449 typename Storage_Type<P10>::type,
4450 typename Storage_Type<P11>::type,
4451 typename Storage_Type<P12>::type,
4452 typename Storage_Type<P13>::type,
4453 typename Storage_Type<P14>::type> >
4454 bindSR(bslma::Allocator *allocator,
4455 t_FUNC func,
4456 BSLS_COMPILERFEATURES_FORWARD_REF(P1) p1,
4457 BSLS_COMPILERFEATURES_FORWARD_REF(P2) p2,
4458 BSLS_COMPILERFEATURES_FORWARD_REF(P3) p3,
4459 BSLS_COMPILERFEATURES_FORWARD_REF(P4) p4,
4460 BSLS_COMPILERFEATURES_FORWARD_REF(P5) p5,
4461 BSLS_COMPILERFEATURES_FORWARD_REF(P6) p6,
4462 BSLS_COMPILERFEATURES_FORWARD_REF(P7) p7,
4463 BSLS_COMPILERFEATURES_FORWARD_REF(P8) p8,
4464 BSLS_COMPILERFEATURES_FORWARD_REF(P9) p9,
4465 BSLS_COMPILERFEATURES_FORWARD_REF(P10) p10,
4466 BSLS_COMPILERFEATURES_FORWARD_REF(P11) p11,
4467 BSLS_COMPILERFEATURES_FORWARD_REF(P12) p12,
4468 BSLS_COMPILERFEATURES_FORWARD_REF(P13) p13,
4469 BSLS_COMPILERFEATURES_FORWARD_REF(P14) p14)
4470 {
4471 typedef Bind_BoundTuple14<typename Storage_Type<P1>::type,
4472 typename Storage_Type<P2>::type,
4473 typename Storage_Type<P3>::type,
4474 typename Storage_Type<P4>::type,
4475 typename Storage_Type<P5>::type,
4476 typename Storage_Type<P6>::type,
4477 typename Storage_Type<P7>::type,
4478 typename Storage_Type<P8>::type,
4479 typename Storage_Type<P9>::type,
4480 typename Storage_Type<P10>::type,
4481 typename Storage_Type<P11>::type,
4482 typename Storage_Type<P12>::type,
4483 typename Storage_Type<P13>::type,
4484 typename Storage_Type<P14>::type> BoundList;
4485
4486 BoundList list(BSLS_COMPILERFEATURES_FORWARD(P1, p1),
4487 BSLS_COMPILERFEATURES_FORWARD(P2, p2),
4488 BSLS_COMPILERFEATURES_FORWARD(P3, p3),
4489 BSLS_COMPILERFEATURES_FORWARD(P4, p4),
4490 BSLS_COMPILERFEATURES_FORWARD(P5, p5),
4491 BSLS_COMPILERFEATURES_FORWARD(P6, p6),
4492 BSLS_COMPILERFEATURES_FORWARD(P7, p7),
4493 BSLS_COMPILERFEATURES_FORWARD(P8, p8),
4494 BSLS_COMPILERFEATURES_FORWARD(P9, p9),
4495 BSLS_COMPILERFEATURES_FORWARD(P10, p10),
4496 BSLS_COMPILERFEATURES_FORWARD(P11, p11),
4497 BSLS_COMPILERFEATURES_FORWARD(P12, p12),
4498 BSLS_COMPILERFEATURES_FORWARD(P13, p13),
4499 BSLS_COMPILERFEATURES_FORWARD(P14, p14),
4500 allocator);
4501
4502 return BindWrapper<t_RET, t_FUNC, BoundList>
4503 (func, MoveUtil::move(list), allocator);
4504 }
4505
4506};
4507
4508// ---- Anything below this line is implementation specific. Do not use. ----
4509
4510 // ========================
4511 // class Bind_ArgTupleValue
4512 // ========================
4513
4514/// This local class provides storage for a value of the specified `TYPE`
4515/// suitable for storing an argument value in one of the
4516/// `Bind_ArgTuple[0-14]` local classes. `TYPE` must already be a
4517/// `bslmf::ForwardingType`, meaning no extra copies will be made (unless
4518/// the type is a fundamental type, which is meant to be copied for
4519/// efficiency).
4520///
4521/// See @ref bdlf_bind
4522template <class TYPE>
4523class Bind_ArgTupleValue {
4524
4525 // PRIVATE TYPES
4526 typedef typename bslmf::ArrayToConstPointer<TYPE>::Type STORAGE_TYPE;
4527
4528 // PRIVATE INSTANCE DATA
4529 STORAGE_TYPE d_value;
4530
4531 public:
4532 // CREATORS
4533
4534 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4535 /// `original` value.
4536 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE>& original)
4537 : d_value(original.d_value)
4538 {
4539 }
4540
4541 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4542 /// `value`.
4543 Bind_ArgTupleValue(TYPE value) // IMPLICIT
4544 : d_value(value)
4545 {
4546 }
4547
4548 // MANIPULATORS
4549
4550 /// Return a reference to the modifiable object held by this proxy.
4551 STORAGE_TYPE& value() { return d_value; }
4552
4553 // ACCESSORS
4554
4555 /// Return a reference to the non-modifiable object held by this proxy.
4556 const STORAGE_TYPE& value() const { return d_value; }
4557};
4558
4559/// This local class provides storage for a value of the specified `TYPE`
4560/// suitable for storing an argument value in one of the `Bind_ArgTuple*`
4561/// local classes. This full specialization for reference types simply
4562/// stores the address of the argument value.
4563template <class TYPE>
4564class Bind_ArgTupleValue<TYPE&> {
4565
4566 // PRIVATE INSTANCE DATA
4567 TYPE *d_value;
4568
4569 public:
4570 // CREATORS
4571
4572 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4573 /// `original` reference.
4574 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE&>& original)
4575 : d_value(original.d_value)
4576 {
4577 }
4578
4579 /// Create a `Bind_ArgTupleValue` object holding the address of the
4580 /// specified `value`.
4581 Bind_ArgTupleValue(TYPE& value) // IMPLICIT
4582 : d_value(&value)
4583 {
4584 }
4585
4586 // MANIPULATORS
4587
4588 /// Return a reference to the modifiable object held by this proxy.
4589 TYPE& value() { return *d_value; }
4590
4591 // ACCESSORS
4592
4593 /// Return a reference to the non-modifiable object held by this proxy.
4594 const TYPE& value() const { return *d_value; }
4595};
4596
4597/// This local class provides storage for a value of the specified `TYPE`
4598/// suitable for storing an argument value in one of the `Bind_ArgTuple*`
4599/// local classes. This full specialization for const reference types
4600/// simply stores the address of the argument value.
4601template <class TYPE>
4602class Bind_ArgTupleValue<TYPE const&> {
4603
4604 // PRIVATE INSTANCE DATA
4605 const TYPE *d_value;
4606
4607 public:
4608 // CREATORS
4609
4610 /// Create a `Bind_ArgTupleValue` object holding a copy of the specified
4611 /// `original` reference.
4612 Bind_ArgTupleValue(const Bind_ArgTupleValue<TYPE const&>& original)
4613 : d_value(original.d_value)
4614 {
4615 }
4616
4617 /// Create a `Bind_ArgTupleValue` object holding the address of the
4618 /// specified `value`.
4619 Bind_ArgTupleValue(const TYPE& value) // IMPLICIT
4620 : d_value(&value)
4621 {
4622 }
4623
4624 // MANIPULATORS
4625
4626 /// Return a reference to the non-modifiable object held by this proxy.
4627 const TYPE& value() { return *d_value; }
4628
4629 // ACCESSORS
4630
4631 /// Return a reference to the non-modifiable object held by this proxy.
4632 const TYPE& value() const { return *d_value; }
4633};
4634
4635 // ====================
4636 // class Bind_ArgTuple*
4637 // ====================
4638
4639/// This `struct` provides the creators for a list of zero arguments.
4640struct Bind_ArgTuple0 : bslmf::TypeList0
4641{
4642
4643 // CREATORS
4646
4647 Bind_ArgTuple0(const Bind_ArgTuple0&)
4648 {
4649 }
4650};
4651
4652/// This `struct` stores a list of one argument.
4653template <class A1>
4654struct Bind_ArgTuple1 : bslmf::TypeList1<A1>
4655{
4656
4657 // TYPES
4658 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4659
4660 // INSTANCE DATA
4661 Bind_ArgTupleValue<FA1> d_a1;
4662
4663 // CREATORS
4664 Bind_ArgTuple1(const Bind_ArgTuple1<A1>& orig)
4665 : d_a1(orig.d_a1)
4666 {
4667 }
4668
4669 explicit Bind_ArgTuple1(FA1 a1)
4670 : d_a1(a1)
4671 {
4672 }
4673};
4674
4675/// This `struct` stores a list of two arguments.
4676template <class A1, class A2>
4677struct Bind_ArgTuple2 : bslmf::TypeList2<A1,A2>
4678{
4679
4680 // TYPES
4681 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4682 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4683
4684 // INSTANCE DATA
4685 Bind_ArgTupleValue<FA1> d_a1;
4686 Bind_ArgTupleValue<FA2> d_a2;
4687
4688 // CREATORS
4689 Bind_ArgTuple2(const Bind_ArgTuple2<A1,A2>& orig)
4690 : d_a1(orig.d_a1)
4691 , d_a2(orig.d_a2)
4692 {
4693 }
4694
4695 Bind_ArgTuple2(FA1 a1, FA2 a2)
4696 : d_a1(a1)
4697 , d_a2(a2)
4698 {
4699 }
4700};
4701
4702/// This `struct` stores a list of three arguments.
4703template <class A1, class A2, class A3>
4704struct Bind_ArgTuple3 : bslmf::TypeList3<A1,A2,A3>
4705{
4706
4707 // TYPES
4708 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4709 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4710 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4711
4712 // INSTANCE DATA
4713 Bind_ArgTupleValue<FA1> d_a1;
4714 Bind_ArgTupleValue<FA2> d_a2;
4715 Bind_ArgTupleValue<FA3> d_a3;
4716
4717 // CREATORS
4718 Bind_ArgTuple3(const Bind_ArgTuple3<A1,A2,A3>& orig)
4719 : d_a1(orig.d_a1)
4720 , d_a2(orig.d_a2)
4721 , d_a3(orig.d_a3)
4722 {
4723 }
4724
4725 Bind_ArgTuple3(FA1 a1, FA2 a2, FA3 a3)
4726 : d_a1(a1)
4727 , d_a2(a2)
4728 , d_a3(a3)
4729 {
4730 }
4731};
4732
4733/// This `struct` stores a list of four arguments.
4734template <class A1, class A2, class A3, class A4>
4735struct Bind_ArgTuple4 : bslmf::TypeList4<A1,A2,A3,A4>
4736{
4737
4738 // TYPES
4739 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4740 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4741 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4742 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4743
4744 // INSTANCE DATA
4745 Bind_ArgTupleValue<FA1> d_a1;
4746 Bind_ArgTupleValue<FA2> d_a2;
4747 Bind_ArgTupleValue<FA3> d_a3;
4748 Bind_ArgTupleValue<FA4> d_a4;
4749
4750 // CREATORS
4751 Bind_ArgTuple4(const Bind_ArgTuple4<A1,A2,A3,A4>& orig)
4752 : d_a1(orig.d_a1)
4753 , d_a2(orig.d_a2)
4754 , d_a3(orig.d_a3)
4755 , d_a4(orig.d_a4)
4756 {
4757 }
4758
4759 Bind_ArgTuple4(FA1 a1, FA2 a2, FA3 a3, FA4 a4)
4760 : d_a1(a1)
4761 , d_a2(a2)
4762 , d_a3(a3)
4763 , d_a4(a4)
4764 {
4765 }
4766};
4767
4768/// This `struct` stores a list of five arguments.
4769template <class A1, class A2, class A3, class A4, class A5>
4770struct Bind_ArgTuple5 : bslmf::TypeList5<A1,A2,A3,A4,A5>
4771{
4772
4773 // TYPES
4774 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4775 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4776 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4777 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4778 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4779
4780 // INSTANCE DATA
4781 Bind_ArgTupleValue<FA1> d_a1;
4782 Bind_ArgTupleValue<FA2> d_a2;
4783 Bind_ArgTupleValue<FA3> d_a3;
4784 Bind_ArgTupleValue<FA4> d_a4;
4785 Bind_ArgTupleValue<FA5> d_a5;
4786
4787 // CREATORS
4788 Bind_ArgTuple5(const Bind_ArgTuple5<A1,A2,A3,A4,A5>& orig)
4789 : d_a1(orig.d_a1)
4790 , d_a2(orig.d_a2)
4791 , d_a3(orig.d_a3)
4792 , d_a4(orig.d_a4)
4793 , d_a5(orig.d_a5)
4794 {
4795 }
4796
4797 Bind_ArgTuple5(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5)
4798 : d_a1(a1)
4799 , d_a2(a2)
4800 , d_a3(a3)
4801 , d_a4(a4)
4802 , d_a5(a5)
4803 {
4804 }
4805};
4806
4807/// This `struct` stores a list of six arguments.
4808template <class A1, class A2, class A3, class A4, class A5, class A6>
4809struct Bind_ArgTuple6 : bslmf::TypeList6<A1,A2,A3,A4,A5,A6>
4810{
4811
4812 // TYPES
4813 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4814 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4815 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4816 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4817 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4818 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4819
4820 // INSTANCE DATA
4821 Bind_ArgTupleValue<FA1> d_a1;
4822 Bind_ArgTupleValue<FA2> d_a2;
4823 Bind_ArgTupleValue<FA3> d_a3;
4824 Bind_ArgTupleValue<FA4> d_a4;
4825 Bind_ArgTupleValue<FA5> d_a5;
4826 Bind_ArgTupleValue<FA6> d_a6;
4827
4828 // CREATORS
4829 Bind_ArgTuple6(const Bind_ArgTuple6<A1,A2,A3,A4,A5,A6>& orig)
4830 : d_a1(orig.d_a1)
4831 , d_a2(orig.d_a2)
4832 , d_a3(orig.d_a3)
4833 , d_a4(orig.d_a4)
4834 , d_a5(orig.d_a5)
4835 , d_a6(orig.d_a6)
4836 {
4837 }
4838
4839 Bind_ArgTuple6(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6)
4840 : d_a1(a1)
4841 , d_a2(a2)
4842 , d_a3(a3)
4843 , d_a4(a4)
4844 , d_a5(a5)
4845 , d_a6(a6)
4846 {
4847 }
4848};
4849
4850/// This `struct` stores a list of seven arguments.
4851template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
4852struct Bind_ArgTuple7 : bslmf::TypeList7<A1,A2,A3,A4,A5,A6,A7>
4853{
4854
4855 // TYPES
4856 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4857 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4858 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4859 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4860 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4861 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4862 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4863
4864 // INSTANCE DATA
4865 Bind_ArgTupleValue<FA1> d_a1;
4866 Bind_ArgTupleValue<FA2> d_a2;
4867 Bind_ArgTupleValue<FA3> d_a3;
4868 Bind_ArgTupleValue<FA4> d_a4;
4869 Bind_ArgTupleValue<FA5> d_a5;
4870 Bind_ArgTupleValue<FA6> d_a6;
4871 Bind_ArgTupleValue<FA7> d_a7;
4872
4873 // CREATORS
4874 inline
4875 Bind_ArgTuple7(const Bind_ArgTuple7<A1,A2,A3,A4,A5,A6,A7>& orig)
4876 : d_a1(orig.d_a1)
4877 , d_a2(orig.d_a2)
4878 , d_a3(orig.d_a3)
4879 , d_a4(orig.d_a4)
4880 , d_a5(orig.d_a5)
4881 , d_a6(orig.d_a6)
4882 , d_a7(orig.d_a7)
4883 {
4884 }
4885
4886 Bind_ArgTuple7(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7)
4887 : d_a1(a1)
4888 , d_a2(a2)
4889 , d_a3(a3)
4890 , d_a4(a4)
4891 , d_a5(a5)
4892 , d_a6(a6)
4893 , d_a7(a7)
4894 {
4895 }
4896};
4897
4898/// This `struct` stores a list of eight arguments.
4899template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
4900 class A8>
4901struct Bind_ArgTuple8 : bslmf::TypeList8<A1,A2,A3,A4,A5,A6,A7,A8>
4902{
4903
4904 // TYPES
4905 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4906 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4907 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4908 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4909 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4910 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4911 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4912 typedef typename bslmf::ForwardingType<A8>::Type FA8;
4913
4914 // INSTANCE DATA
4915 Bind_ArgTupleValue<FA1> d_a1;
4916 Bind_ArgTupleValue<FA2> d_a2;
4917 Bind_ArgTupleValue<FA3> d_a3;
4918 Bind_ArgTupleValue<FA4> d_a4;
4919 Bind_ArgTupleValue<FA5> d_a5;
4920 Bind_ArgTupleValue<FA6> d_a6;
4921 Bind_ArgTupleValue<FA7> d_a7;
4922 Bind_ArgTupleValue<FA8> d_a8;
4923
4924 // CREATORS
4925 inline
4926 Bind_ArgTuple8(const Bind_ArgTuple8<A1,A2,A3,A4,A5,A6,A7,A8>& orig)
4927 : d_a1(orig.d_a1)
4928 , d_a2(orig.d_a2)
4929 , d_a3(orig.d_a3)
4930 , d_a4(orig.d_a4)
4931 , d_a5(orig.d_a5)
4932 , d_a6(orig.d_a6)
4933 , d_a7(orig.d_a7)
4934 , d_a8(orig.d_a8)
4935 {
4936 }
4937
4938 Bind_ArgTuple8(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
4939 FA7 a7, FA8 a8)
4940 : d_a1(a1)
4941 , d_a2(a2)
4942 , d_a3(a3)
4943 , d_a4(a4)
4944 , d_a5(a5)
4945 , d_a6(a6)
4946 , d_a7(a7)
4947 , d_a8(a8)
4948 {
4949 }
4950};
4951
4952/// This `struct` stores a list of nine arguments.
4953template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
4954 class A8, class A9>
4955struct Bind_ArgTuple9 : bslmf::TypeList9<A1,A2,A3,A4,A5,A6,A7,A8,A9>
4956{
4957
4958 // TYPES
4959 typedef typename bslmf::ForwardingType<A1>::Type FA1;
4960 typedef typename bslmf::ForwardingType<A2>::Type FA2;
4961 typedef typename bslmf::ForwardingType<A3>::Type FA3;
4962 typedef typename bslmf::ForwardingType<A4>::Type FA4;
4963 typedef typename bslmf::ForwardingType<A5>::Type FA5;
4964 typedef typename bslmf::ForwardingType<A6>::Type FA6;
4965 typedef typename bslmf::ForwardingType<A7>::Type FA7;
4966 typedef typename bslmf::ForwardingType<A8>::Type FA8;
4967 typedef typename bslmf::ForwardingType<A9>::Type FA9;
4968
4969 // INSTANCE DATA
4970 Bind_ArgTupleValue<FA1> d_a1;
4971 Bind_ArgTupleValue<FA2> d_a2;
4972 Bind_ArgTupleValue<FA3> d_a3;
4973 Bind_ArgTupleValue<FA4> d_a4;
4974 Bind_ArgTupleValue<FA5> d_a5;
4975 Bind_ArgTupleValue<FA6> d_a6;
4976 Bind_ArgTupleValue<FA7> d_a7;
4977 Bind_ArgTupleValue<FA8> d_a8;
4978 Bind_ArgTupleValue<FA9> d_a9;
4979
4980 // CREATORS
4981 inline
4982 Bind_ArgTuple9(const Bind_ArgTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>& orig)
4983 : d_a1(orig.d_a1)
4984 , d_a2(orig.d_a2)
4985 , d_a3(orig.d_a3)
4986 , d_a4(orig.d_a4)
4987 , d_a5(orig.d_a5)
4988 , d_a6(orig.d_a6)
4989 , d_a7(orig.d_a7)
4990 , d_a8(orig.d_a8)
4991 , d_a9(orig.d_a9)
4992 {
4993 }
4994
4995 Bind_ArgTuple9(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
4996 FA7 a7, FA8 a8, FA9 a9)
4997 : d_a1(a1)
4998 , d_a2(a2)
4999 , d_a3(a3)
5000 , d_a4(a4)
5001 , d_a5(a5)
5002 , d_a6(a6)
5003 , d_a7(a7)
5004 , d_a8(a8)
5005 , d_a9(a9)
5006 {
5007 }
5008};
5009
5010/// This `struct` stores a list of ten arguments.
5011template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5012 class A8, class A9, class A10>
5013struct Bind_ArgTuple10 : bslmf::TypeList10<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5014 A10>
5015{
5016
5017 // TYPES
5018 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5019 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5020 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5021 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5022 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5023 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5024 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5025 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5026 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5027 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5028
5029 // INSTANCE DATA
5030 Bind_ArgTupleValue<FA1> d_a1;
5031 Bind_ArgTupleValue<FA2> d_a2;
5032 Bind_ArgTupleValue<FA3> d_a3;
5033 Bind_ArgTupleValue<FA4> d_a4;
5034 Bind_ArgTupleValue<FA5> d_a5;
5035 Bind_ArgTupleValue<FA6> d_a6;
5036 Bind_ArgTupleValue<FA7> d_a7;
5037 Bind_ArgTupleValue<FA8> d_a8;
5038 Bind_ArgTupleValue<FA9> d_a9;
5039 Bind_ArgTupleValue<FA10> d_a10;
5040
5041 // CREATORS
5042 Bind_ArgTuple10(const Bind_ArgTuple10<A1,A2,A3,A4,
5043 A5,A6,A7,A8,A9,A10>& orig)
5044 : d_a1(orig.d_a1)
5045 , d_a2(orig.d_a2)
5046 , d_a3(orig.d_a3)
5047 , d_a4(orig.d_a4)
5048 , d_a5(orig.d_a5)
5049 , d_a6(orig.d_a6)
5050 , d_a7(orig.d_a7)
5051 , d_a8(orig.d_a8)
5052 , d_a9(orig.d_a9)
5053 , d_a10(orig.d_a10)
5054 {
5055 }
5056
5057 Bind_ArgTuple10(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5058 FA7 a7, FA8 a8, FA9 a9, FA10 a10)
5059 : d_a1(a1)
5060 , d_a2(a2)
5061 , d_a3(a3)
5062 , d_a4(a4)
5063 , d_a5(a5)
5064 , d_a6(a6)
5065 , d_a7(a7)
5066 , d_a8(a8)
5067 , d_a9(a9)
5068 , d_a10(a10)
5069 {
5070 }
5071};
5072
5073/// This `struct` stores a list of eleven arguments.
5074template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5075 class A8, class A9, class A10, class A11>
5076struct Bind_ArgTuple11 : bslmf::TypeList11<A1,A2,A3,A4,A5,A6,A7,A8,A9, A10,A11>
5077{
5078
5079 // TYPES
5080 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5081 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5082 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5083 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5084 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5085 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5086 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5087 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5088 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5089 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5090 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5091
5092 // INSTANCE DATA
5093 Bind_ArgTupleValue<FA1> d_a1;
5094 Bind_ArgTupleValue<FA2> d_a2;
5095 Bind_ArgTupleValue<FA3> d_a3;
5096 Bind_ArgTupleValue<FA4> d_a4;
5097 Bind_ArgTupleValue<FA5> d_a5;
5098 Bind_ArgTupleValue<FA6> d_a6;
5099 Bind_ArgTupleValue<FA7> d_a7;
5100 Bind_ArgTupleValue<FA8> d_a8;
5101 Bind_ArgTupleValue<FA9> d_a9;
5102 Bind_ArgTupleValue<FA10> d_a10;
5103 Bind_ArgTupleValue<FA11> d_a11;
5104
5105 // CREATORS
5106 Bind_ArgTuple11(const Bind_ArgTuple11<A1,A2,A3,A4,A5,A6,
5107 A7,A8,A9,A10,A11>& orig)
5108 : d_a1(orig.d_a1)
5109 , d_a2(orig.d_a2)
5110 , d_a3(orig.d_a3)
5111 , d_a4(orig.d_a4)
5112 , d_a5(orig.d_a5)
5113 , d_a6(orig.d_a6)
5114 , d_a7(orig.d_a7)
5115 , d_a8(orig.d_a8)
5116 , d_a9(orig.d_a9)
5117 , d_a10(orig.d_a10)
5118 , d_a11(orig.d_a11)
5119 {
5120 }
5121
5122 Bind_ArgTuple11(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5123 FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11)
5124 : d_a1(a1)
5125 , d_a2(a2)
5126 , d_a3(a3)
5127 , d_a4(a4)
5128 , d_a5(a5)
5129 , d_a6(a6)
5130 , d_a7(a7)
5131 , d_a8(a8)
5132 , d_a9(a9)
5133 , d_a10(a10)
5134 , d_a11(a11)
5135 {
5136 }
5137};
5138
5139/// This `struct` stores a list of twelve arguments.
5140template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5141 class A8, class A9, class A10, class A11, class A12>
5142struct Bind_ArgTuple12 : bslmf::TypeList12<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5143 A10,A11,A12>
5144{
5145
5146 // TYPES
5147 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5148 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5149 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5150 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5151 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5152 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5153 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5154 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5155 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5156 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5157 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5158 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5159
5160 // INSTANCE DATA
5161 Bind_ArgTupleValue<FA1> d_a1;
5162 Bind_ArgTupleValue<FA2> d_a2;
5163 Bind_ArgTupleValue<FA3> d_a3;
5164 Bind_ArgTupleValue<FA4> d_a4;
5165 Bind_ArgTupleValue<FA5> d_a5;
5166 Bind_ArgTupleValue<FA6> d_a6;
5167 Bind_ArgTupleValue<FA7> d_a7;
5168 Bind_ArgTupleValue<FA8> d_a8;
5169 Bind_ArgTupleValue<FA9> d_a9;
5170 Bind_ArgTupleValue<FA10> d_a10;
5171 Bind_ArgTupleValue<FA11> d_a11;
5172 Bind_ArgTupleValue<FA12> d_a12;
5173
5174 // CREATORS
5175 Bind_ArgTuple12(const Bind_ArgTuple12<A1,A2,A3,A4,A5,A6,
5176 A7,A8,A9,A10,A11,A12>& orig)
5177 : d_a1(orig.d_a1)
5178 , d_a2(orig.d_a2)
5179 , d_a3(orig.d_a3)
5180 , d_a4(orig.d_a4)
5181 , d_a5(orig.d_a5)
5182 , d_a6(orig.d_a6)
5183 , d_a7(orig.d_a7)
5184 , d_a8(orig.d_a8)
5185 , d_a9(orig.d_a9)
5186 , d_a10(orig.d_a10)
5187 , d_a11(orig.d_a11)
5188 , d_a12(orig.d_a12)
5189 {
5190 }
5191
5192 Bind_ArgTuple12(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7,
5193 FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12)
5194 : d_a1(a1)
5195 , d_a2(a2)
5196 , d_a3(a3)
5197 , d_a4(a4)
5198 , d_a5(a5)
5199 , d_a6(a6)
5200 , d_a7(a7)
5201 , d_a8(a8)
5202 , d_a9(a9)
5203 , d_a10(a10)
5204 , d_a11(a11)
5205 , d_a12(a12)
5206 {
5207 }
5208};
5209
5210/// This `struct` stores a list of thirteen arguments.
5211template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5212 class A8, class A9, class A10, class A11, class A12, class A13>
5213struct Bind_ArgTuple13 : bslmf::TypeList13<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5214 A10,A11,A12,A13>
5215{
5216
5217 // TYPES
5218 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5219 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5220 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5221 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5222 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5223 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5224 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5225 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5226 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5227 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5228 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5229 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5230 typedef typename bslmf::ForwardingType<A13>::Type FA13;
5231
5232 // INSTANCE DATA
5233 Bind_ArgTupleValue<FA1> d_a1;
5234 Bind_ArgTupleValue<FA2> d_a2;
5235 Bind_ArgTupleValue<FA3> d_a3;
5236 Bind_ArgTupleValue<FA4> d_a4;
5237 Bind_ArgTupleValue<FA5> d_a5;
5238 Bind_ArgTupleValue<FA6> d_a6;
5239 Bind_ArgTupleValue<FA7> d_a7;
5240 Bind_ArgTupleValue<FA8> d_a8;
5241 Bind_ArgTupleValue<FA9> d_a9;
5242 Bind_ArgTupleValue<FA10> d_a10;
5243 Bind_ArgTupleValue<FA11> d_a11;
5244 Bind_ArgTupleValue<FA12> d_a12;
5245 Bind_ArgTupleValue<FA13> d_a13;
5246
5247 // CREATORS
5248 Bind_ArgTuple13(const Bind_ArgTuple13<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5249 A10,A11,A12,A13>& orig)
5250 : d_a1(orig.d_a1)
5251 , d_a2(orig.d_a2)
5252 , d_a3(orig.d_a3)
5253 , d_a4(orig.d_a4)
5254 , d_a5(orig.d_a5)
5255 , d_a6(orig.d_a6)
5256 , d_a7(orig.d_a7)
5257 , d_a8(orig.d_a8)
5258 , d_a9(orig.d_a9)
5259 , d_a10(orig.d_a10)
5260 , d_a11(orig.d_a11)
5261 , d_a12(orig.d_a12)
5262 , d_a13(orig.d_a13)
5263 {
5264 }
5265
5266 Bind_ArgTuple13(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6, FA7 a7,
5267 FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12, FA13 a13)
5268 : d_a1(a1)
5269 , d_a2(a2)
5270 , d_a3(a3)
5271 , d_a4(a4)
5272 , d_a5(a5)
5273 , d_a6(a6)
5274 , d_a7(a7)
5275 , d_a8(a8)
5276 , d_a9(a9)
5277 , d_a10(a10)
5278 , d_a11(a11)
5279 , d_a12(a12)
5280 , d_a13(a13)
5281 {
5282 }
5283};
5284
5285/// This `struct` stores a list of fourteen arguments.
5286template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
5287 class A8, class A9, class A10, class A11, class A12, class A13,
5288 class A14>
5289struct Bind_ArgTuple14 : bslmf::TypeList14<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5290 A10,A11,A12,A13,A14>
5291{
5292
5293 // TYPES
5294 typedef typename bslmf::ForwardingType<A1>::Type FA1;
5295 typedef typename bslmf::ForwardingType<A2>::Type FA2;
5296 typedef typename bslmf::ForwardingType<A3>::Type FA3;
5297 typedef typename bslmf::ForwardingType<A4>::Type FA4;
5298 typedef typename bslmf::ForwardingType<A5>::Type FA5;
5299 typedef typename bslmf::ForwardingType<A6>::Type FA6;
5300 typedef typename bslmf::ForwardingType<A7>::Type FA7;
5301 typedef typename bslmf::ForwardingType<A8>::Type FA8;
5302 typedef typename bslmf::ForwardingType<A9>::Type FA9;
5303 typedef typename bslmf::ForwardingType<A10>::Type FA10;
5304 typedef typename bslmf::ForwardingType<A11>::Type FA11;
5305 typedef typename bslmf::ForwardingType<A12>::Type FA12;
5306 typedef typename bslmf::ForwardingType<A13>::Type FA13;
5307 typedef typename bslmf::ForwardingType<A14>::Type FA14;
5308
5309 // INSTANCE DATA
5310 Bind_ArgTupleValue<FA1> d_a1;
5311 Bind_ArgTupleValue<FA2> d_a2;
5312 Bind_ArgTupleValue<FA3> d_a3;
5313 Bind_ArgTupleValue<FA4> d_a4;
5314 Bind_ArgTupleValue<FA5> d_a5;
5315 Bind_ArgTupleValue<FA6> d_a6;
5316 Bind_ArgTupleValue<FA7> d_a7;
5317 Bind_ArgTupleValue<FA8> d_a8;
5318 Bind_ArgTupleValue<FA9> d_a9;
5319 Bind_ArgTupleValue<FA10> d_a10;
5320 Bind_ArgTupleValue<FA11> d_a11;
5321 Bind_ArgTupleValue<FA12> d_a12;
5322 Bind_ArgTupleValue<FA13> d_a13;
5323 Bind_ArgTupleValue<FA14> d_a14;
5324
5325 // CREATORS
5326 Bind_ArgTuple14(const Bind_ArgTuple14<A1,A2,A3,A4,A5,A6,A7,A8,A9,
5327 A10,A11,A12,A13,A14>& orig)
5328 : d_a1(orig.d_a1)
5329 , d_a2(orig.d_a2)
5330 , d_a3(orig.d_a3)
5331 , d_a4(orig.d_a4)
5332 , d_a5(orig.d_a5)
5333 , d_a6(orig.d_a6)
5334 , d_a7(orig.d_a7)
5335 , d_a8(orig.d_a8)
5336 , d_a9(orig.d_a9)
5337 , d_a10(orig.d_a10)
5338 , d_a11(orig.d_a11)
5339 , d_a12(orig.d_a12)
5340 , d_a13(orig.d_a13)
5341 , d_a14(orig.d_a14)
5342 {
5343 }
5344
5345 Bind_ArgTuple14(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6,
5346 FA7 a7, FA8 a8, FA9 a9, FA10 a10, FA11 a11, FA12 a12,
5347 FA13 a13, FA14 a14)
5348 : d_a1(a1)
5349 , d_a2(a2)
5350 , d_a3(a3)
5351 , d_a4(a4)
5352 , d_a5(a5)
5353 , d_a6(a6)
5354 , d_a7(a7)
5355 , d_a8(a8)
5356 , d_a9(a9)
5357 , d_a10(a10)
5358 , d_a11(a11)
5359 , d_a12(a12)
5360 , d_a13(a13)
5361 , d_a14(a14)
5362 {
5363 }
5364};
5365
5366 // ===============
5367 // class Bind_Impl
5368 // ===============
5369
5370/// Either this `class` or `Bind_ImplExplicit` is used as the base `class`
5371/// of `Bind`, where `Bind_ImplExplicit` is used only if certain conditions
5372/// on the template parameters are met, and this `class` is more resilient
5373/// and used in the more general case. This `class` is not to be directly
5374/// used outside this component. This `class` implements the storage and
5375/// functionality required for a binder that invokes an object of type
5376/// `t_FUNC` with a list of invocation parameters of type `t_BOUND_TUPLE`.
5377/// The return type of the invocation is determined by a combination of type `t_RET` and `t_FUNC`.
5378///
5379/// \note Note that this class is a generic binder
5380/// implementation; this component provides more type safe implementation
5381/// `Bind_ImplExplicit` that will be used under certain conditions.
5382///
5383/// See @ref bdlf_bind
5384template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
5385class Bind_Impl {
5386
5387 // PRIVATE TYPES
5388
5389 /// The return type of this binder object.
5390 typedef Bind_FuncTraits<t_RET, t_FUNC> Traits;
5391
5392 public:
5393 // PUBLIC TYPES
5394 typedef typename Traits::ResultType ResultType;
5395
5396 private:
5397 // PRIVATE TYPES
5398 typedef bslmf::Tag<Traits::k_HAS_POINTER_SEMANTICS> HasPointerSemantics;
5399 typedef Bind_Invoker<ResultType, t_BOUND_TUPLE::LENGTH>
5400 Invoker;
5401 typedef typename Traits::Type FuncType;
5402
5403 // PRIVATE INSTANCE DATA
5404 bslalg::ConstructorProxy<typename Traits::WrapperType> d_func;
5405 t_BOUND_TUPLE d_list;
5406
5407 public:
5408 // TRAITS
5409 BSLMF_NESTED_TRAIT_DECLARATION(Bind_Impl, bslma::UsesBslmaAllocator);
5410
5411 private:
5412 // PRIVATE ACCESSORS
5413
5414 /// Invoke the bound functor using the invocation parameters provided at
5415 /// construction of this `Bind` object. Substituting place-holders for
5416 /// their respective values in the specified `arguments`. The
5417 /// `bslmf::Tag` is only used for overloading resolution - indicating
5418 /// whether `d_func` has pointer semantics or not.
5419 template <class t_ARG_TUPLE>
5420 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<0>) const
5421 {
5422 Invoker invoker;
5423 return invoker.invoke(&d_func.object(), &d_list, arguments);
5424 }
5425
5426 /// Invoke the bound functor using the invocation parameters provided at
5427 /// construction of this `Bind` object. Substituting place-holders for
5428 /// their respective values in the specified `arguments`. The
5429 /// `bslmf::Tag` is only used for overloading resolution - indicating
5430 /// whether `d_func` has pointer semantics or not.
5431 template <class t_ARG_TUPLE>
5432 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<1>) const
5433 {
5434 Invoker invoker;
5435 return invoker.invoke(&(*d_func.object()), &d_list, arguments);
5436 }
5437
5438 public:
5439 // CREATORS
5440
5441 /// Construct a `Bind_Impl` object bound to the specified invocable
5442 /// object `func` using the invocation parameters specified in `list`.
5443 /// Optionally specify a `basicAllocator` used to supply memory. If
5444 /// `basicAllocator` is 0, the currently installed default allocator is
5445 /// used.
5446 Bind_Impl(typename bslmf::ForwardingType<t_FUNC>::Type func,
5447 t_BOUND_TUPLE const& list,
5448 bslma::Allocator *basicAllocator = 0)
5449 : d_func(func, basicAllocator)
5450 , d_list(list, basicAllocator)
5451 {
5452 }
5453
5454 Bind_Impl(typename bslmf::ForwardingType<t_FUNC>::Type func,
5455 bslmf::MovableRef<t_BOUND_TUPLE> list,
5456 bslma::Allocator *basicAllocator = 0)
5457 // Construct a 'Bind_Impl' object bound to the specified invocable
5458 // object 'func' using the moved invocation parameters specified in 'list'.
5459 // Optionally specify a 'basicAllocator' used to supply memory. If
5460 // 'basicAllocator' is 0, the currently installed default allocator is
5461 // used.
5462 : d_func(func, basicAllocator)
5463 , d_list(bslmf::MovableRefUtil::move(list), basicAllocator)
5464 {
5465 }
5466
5467 /// Construct a `Bind_Impl` object bound to the same invocable object
5468 /// `func` and using the same invocation parameters as the specified
5469 /// `other` object. Optionally specify a `basicAllocator` used to
5470 /// supply memory. If `basicAllocator` is 0, the currently installed
5471 /// default allocator is used.
5472 Bind_Impl(const Bind_Impl& other, bslma::Allocator *basicAllocator = 0)
5473 : d_func(other.d_func, basicAllocator)
5474 , d_list(other.d_list, basicAllocator)
5475 {
5476 }
5477
5478 /// Construct a `Bind_Impl` object bound to the same invocable object
5479 /// `func` and using the invocation parameters moved from the specified
5480 /// `other` object. Optionally specify a `basicAllocator` used to
5481 /// supply memory. If `basicAllocator` is 0, the currently installed
5482 /// default allocator is used.
5483 Bind_Impl(bslmf::MovableRef<Bind_Impl> other,
5484 bslma::Allocator *basicAllocator = 0)
5485 : d_func(bslmf::MovableRefUtil::move(
5486 bslmf::MovableRefUtil::access(other.d_func)),
5487 basicAllocator)
5488 , d_list(bslmf::MovableRefUtil::move(
5489 bslmf::MovableRefUtil::access(other.d_list)),
5490 basicAllocator)
5491 {
5492 }
5493
5494 // ACCESSORS
5495
5496 /// Invoke the bound functor using the invocation parameters provided at
5497 /// construction of this `Bind` object, substituting place-holders for
5498 /// their respective values in the specified `arguments`.
5499 template <class t_ARG_TUPLE>
5500 ResultType invoke(t_ARG_TUPLE& arguments) const
5501 {
5502 return invokeImpl(arguments, HasPointerSemantics());
5503 }
5504
5505 /// Invoke the bound functor using only the invocation parameters
5506 /// provided at construction of this `Bind` object and return the
5507 /// result.
5508 ResultType operator()() const
5509 {
5510 typedef Bind_ArgTuple0 ArgList;
5511 ArgList argList;
5512 return invoke(argList);
5513 }
5514
5515 /// Invoke the bound functor using the invocation template provided at
5516 /// construction of this `Bind` object, substituting place-holders for
5517 /// argument 1 with the value of the specified argument `p1`. Return
5518 /// the result.
5519 template <class P1>
5520 ResultType operator()(P1& p1) const
5521 {
5522 typedef Bind_ArgTuple1<P1&> ArgList;
5523 ArgList argList(p1);
5524 return invoke(argList);
5525 }
5526
5527 /// Invoke the bound functor using the invocation template provided at
5528 /// construction of this `Bind` object, substituting place-holders for
5529 /// argument 1 with the value of the specified argument `p1`. Return
5530 /// the result.
5531 template <class P1>
5532 ResultType operator()(P1 const& p1) const
5533 {
5534 typedef Bind_ArgTuple1<P1 const&> ArgList;
5535 ArgList argList(p1);
5536 return invoke(argList);
5537 }
5538
5539 /// Invoke the bound functor using the invocation template provided at
5540 /// construction of this `Bind` object, substituting place-holders for
5541 /// arguments 1 and 2 with the value of the specified arguments `p1`,
5542 /// and `p2` respectively. Return the result.
5543 template <class P1, class P2>
5544 ResultType operator()(P1& p1, P2& p2) const
5545 {
5546 typedef Bind_ArgTuple2<P1&, P2&> ArgList;
5547 ArgList argList(p1, p2);
5548 return invoke(argList);
5549 }
5550
5551 /// Invoke the bound functor using the invocation template provided at
5552 /// construction of this `Bind` object, substituting place-holders for
5553 /// arguments 1 and 2 with the value of the specified arguments `p1`,
5554 /// and `p2` respectively. Return the result.
5555 template <class P1, class P2>
5556 ResultType operator()(P1 const& p1, P2 const& p2) const
5557 {
5558 typedef Bind_ArgTuple2<P1 const&, P2 const&> ArgList;
5559 ArgList argList(p1, p2);
5560 return invoke(argList);
5561 }
5562
5563 /// Invoke the bound functor using the invocation template provided at
5564 /// construction of this `Bind` object, substituting place-holders for
5565 /// arguments 1, 2, and 3 with the values of the specified arguments
5566 /// `p1`, `p2` and `p3` respectively. Return the result.
5567 template <class P1, class P2, class P3>
5568 ResultType operator()(P1& p1, P2& p2, P3& p3) const
5569 {
5570 typedef Bind_ArgTuple3<P1&, P2&, P3&> ArgList;
5571 ArgList argList(p1, p2, p3);
5572 return invoke(argList);
5573 }
5574
5575 /// Invoke the bound functor using the invocation template provided at
5576 /// construction of this `Bind` object, substituting place-holders for
5577 /// arguments 1, 2, and 3 with the values of the specified arguments
5578 /// `p1`, `p2` and `p3` respectively. Return the result.
5579 template <class P1, class P2, class P3>
5580 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3) const
5581 {
5582 typedef Bind_ArgTuple3<P1 const&, P2 const&, P3 const&> ArgList;
5583 ArgList argList(p1, p2, p3);
5584 return invoke(argList);
5585 }
5586
5587 /// Invoke the bound functor using the invocation template provided at
5588 /// construction of this `Bind` object, substituting place-holders for
5589 /// arguments 1 - 4 with the values of the specified arguments `p1` -
5590 /// `p4` respectively. Return the result.
5591 template <class P1, class P2, class P3, class P4>
5592 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4) const
5593 {
5594 typedef Bind_ArgTuple4<P1&, P2&, P3&, P4&> ArgList;
5595 ArgList argList(p1, p2, p3, p4);
5596 return invoke(argList);
5597 }
5598
5599 /// Invoke the bound functor using the invocation template provided at
5600 /// construction of this `Bind` object, substituting place-holders for
5601 /// arguments 1 - 4 with the values of the specified arguments `p1` -
5602 /// `p4` respectively. Return the result.
5603 template <class P1, class P2, class P3, class P4>
5604 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5605 P4 const& p4) const
5606 {
5607 typedef Bind_ArgTuple4<P1 const&, P2 const&, P3 const&, P4 const&>
5608 ArgList;
5609 ArgList argList(p1, p2, p3, p4);
5610 return invoke(argList);
5611 }
5612
5613 /// Invoke the bound functor using the invocation template provided at
5614 /// construction of this `Bind` object, substituting place-holders for
5615 /// arguments 1 - 5 with the values of the specified arguments `p1` -
5616 /// `p5` respectively. Return the result.
5617 template <class P1, class P2, class P3, class P4, class P5>
5618 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5) const
5619 {
5620 typedef Bind_ArgTuple5<P1&, P2&, P3&, P4&, P5&> ArgList;
5621 ArgList argList(p1, p2, p3, p4, p5);
5622 return invoke(argList);
5623 }
5624
5625 /// Invoke the bound functor using the invocation template provided at
5626 /// construction of this `Bind` object, substituting place-holders for
5627 /// arguments 1 - 5 with the values of the specified arguments `p1` -
5628 /// `p5` respectively. Return the result.
5629 template <class P1, class P2, class P3, class P4, class P5>
5630 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5631 P4 const& p4, P5 const& p5) const
5632 {
5633 typedef Bind_ArgTuple5<P1 const&, P2 const&, P3 const&, P4 const&,
5634 P5 const&> ArgList;
5635 ArgList argList(p1, p2, p3, p4, p5);
5636 return invoke(argList);
5637 }
5638
5639 /// Invoke the bound functor using the invocation template provided at
5640 /// construction of this `Bind` object, substituting place-holders for
5641 /// arguments 1 - 6 with the values of the specified arguments `p1` -
5642 /// `p7` respectively. Return the result.
5643 template <class P1, class P2, class P3, class P4, class P5, class P6>
5644 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5645 P6& p6) const
5646 {
5647 typedef Bind_ArgTuple6<P1&, P2&, P3&, P4&, P5&, P6&> ArgList;
5648 ArgList argList(p1, p2, p3, p4, p5, p6);
5649 return invoke(argList);
5650 }
5651
5652 /// Invoke the bound functor using the invocation template provided at
5653 /// construction of this `Bind` object, substituting place-holders for
5654 /// arguments 1 - 6 with the values of the specified arguments `p1` -
5655 /// `p7` respectively. Return the result.
5656 template <class P1, class P2, class P3, class P4, class P5, class P6>
5657 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5658 P4 const& p4, P5 const& p5, P6 const& p6) const
5659 {
5660 typedef Bind_ArgTuple6<P1 const&, P2 const&, P3 const&, P4 const&,
5661 P5 const&, P6 const&> ArgList;
5662 ArgList argList(p1, p2, p3, p4, p5, p6);
5663 return invoke(argList);
5664 }
5665
5666 /// Invoke the bound functor using the invocation template provided at
5667 /// construction of this `Bind` object, substituting place-holders for
5668 /// arguments 1 - 7 with the values of the specified arguments `p1` -
5669 /// `p7` respectively. Return the result.
5670 template <class P1, class P2, class P3, class P4, class P5, class P6,
5671 class P7>
5672 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5673 P6& p6, P7& p7) const
5674 {
5675 typedef Bind_ArgTuple7<P1&, P2&, P3&, P4&, P5&, P6&, P7&> ArgList;
5676 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
5677 return invoke(argList);
5678 }
5679
5680 /// Invoke the bound functor using the invocation template provided at
5681 /// construction of this `Bind` object, substituting place-holders for
5682 /// arguments 1 - 7 with the values of the specified arguments `p1` -
5683 /// `p7` respectively. Return the result.
5684 template <class P1, class P2, class P3, class P4, class P5, class P6,
5685 class P7>
5686 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5687 P4 const& p4, P5 const& p5, P6 const& p6,
5688 P7 const& p7) const
5689 {
5690 typedef Bind_ArgTuple7<P1 const&, P2 const&, P3 const&, P4 const&,
5691 P5 const&, P6 const&, P7 const&> ArgList;
5692 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
5693 return invoke(argList);
5694 }
5695
5696 /// Invoke the bound functor using the invocation template provided at
5697 /// construction of this `Bind` object, substituting place-holders for
5698 /// arguments 1 - 8 with the values of the specified arguments `p1` -
5699 /// `p8` respectively. Return the result.
5700 template <class P1, class P2, class P3, class P4, class P5, class P6,
5701 class P7, class P8>
5702 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5703 P6& p6, P7& p7, P8& p8) const
5704 {
5705 typedef Bind_ArgTuple8<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&> ArgList;
5706 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
5707 return invoke(argList);
5708 }
5709
5710 /// Invoke the bound functor using the invocation template provided at
5711 /// construction of this `Bind` object, substituting place-holders for
5712 /// arguments 1 - 8 with the values of the specified arguments `p1` -
5713 /// `p8` respectively. Return the result.
5714 template <class P1, class P2, class P3, class P4, class P5, class P6,
5715 class P7, class P8>
5716 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5717 P4 const& p4, P5 const& p5, P6 const& p6,
5718 P7 const& p7, P8 const& p8) const
5719 {
5720 typedef Bind_ArgTuple8<P1 const&, P2 const&, P3 const&, P4 const&,
5721 P5 const&, P6 const&, P7 const&, P8 const&> ArgList;
5722 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
5723 return invoke(argList);
5724 }
5725
5726 /// Invoke the bound functor using the invocation template provided at
5727 /// construction of this `Bind` object, substituting place-holders for
5728 /// arguments 1 - 9 with the values of the specified arguments `p1` -
5729 /// `p9` respectively. Return the result.
5730 template <class P1, class P2, class P3, class P4, class P5, class P6,
5731 class P7, class P8, class P9>
5732 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5733 P6& p6, P7& p7, P8& p8, P9& p9) const
5734 {
5735 typedef Bind_ArgTuple9<P1&, P2&, P3&, P4&, P5&,
5736 P6&, P7&, P8&, P9&> ArgList;
5737 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
5738 return invoke(argList);
5739 }
5740
5741 /// Invoke the bound functor using the invocation template provided at
5742 /// construction of this `Bind` object, substituting place-holders for
5743 /// arguments 1 - 9 with the values of the specified arguments `p1` -
5744 /// `p9` respectively. Return the result.
5745 template <class P1, class P2, class P3, class P4, class P5, class P6,
5746 class P7, class P8, class P9>
5747 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5748 P4 const& p4, P5 const& p5, P6 const& p6,
5749 P7 const& p7, P8 const& p8, P9 const& p9) const
5750 {
5751 typedef Bind_ArgTuple9<P1 const&, P2 const&, P3 const&, P4 const&,
5752 P5 const&, P6 const&, P7 const&, P8 const&,
5753 P9 const&> ArgList;
5754 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
5755 return invoke(argList);
5756 }
5757
5758 /// Invoke the bound functor using the invocation template provided at
5759 /// construction of this `Bind` object, substituting place-holders for
5760 /// arguments 1 - 10 with the values of the specified arguments `p1` -
5761 /// `p10` respectively. Return the result.
5762 template <class P1, class P2, class P3, class P4, class P5, class P6,
5763 class P7, class P8, class P9, class P10>
5764 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5765 P6& p6, P7& p7, P8& p8, P9& p9,
5766 P10& p10) const
5767 {
5768 typedef Bind_ArgTuple10<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5769 P9&, P10&> ArgList;
5770 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
5771 return invoke(argList);
5772 }
5773
5774 /// Invoke the bound functor using the invocation template provided at
5775 /// construction of this `Bind` object, substituting place-holders for
5776 /// arguments 1 - 10 with the values of the specified arguments `p1` -
5777 /// `p10` respectively. Return the result.
5778 template <class P1, class P2, class P3, class P4, class P5, class P6,
5779 class P7, class P8, class P9, class P10>
5780 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5781 P4 const& p4, P5 const& p5, P6 const& p6,
5782 P7 const& p7, P8 const& p8, P9 const& p9,
5783 P10 const& p10) const
5784 {
5785 typedef Bind_ArgTuple10<P1 const&, P2 const&, P3 const&, P4 const&,
5786 P5 const&, P6 const&, P7 const&, P8 const&,
5787 P9 const&, P10 const&> ArgList;
5788 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
5789 return invoke(argList);
5790 }
5791
5792 /// Invoke the bound functor using the invocation template provided at
5793 /// construction of this `Bind` object, substituting place-holders for
5794 /// arguments 1 - 11 with the values of the specified arguments `p1` -
5795 /// `p11` respectively. Return the result.
5796 template <class P1, class P2, class P3, class P4, class P5, class P6,
5797 class P7, class P8, class P9, class P10, class P11>
5798 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5799 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5800 P11& p11) const
5801 {
5802 typedef Bind_ArgTuple11<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5803 P9&, P10&, P11&> ArgList;
5804 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
5805 return invoke(argList);
5806 }
5807
5808 /// Invoke the bound functor using the invocation template provided at
5809 /// construction of this `Bind` object, substituting place-holders for
5810 /// arguments 1 - 11 with the values of the specified arguments `p1` -
5811 /// `p11` respectively. Return the result.
5812 template <class P1, class P2, class P3, class P4, class P5, class P6,
5813 class P7, class P8, class P9, class P10, class P11>
5814 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5815 P4 const& p4, P5 const& p5, P6 const& p6,
5816 P7 const& p7, P8 const& p8, P9 const& p9,
5817 P10 const& p10, P11 const& p11) const
5818 {
5819 typedef Bind_ArgTuple11<P1 const&, P2 const&, P3 const&, P4 const&,
5820 P5 const&, P6 const&, P7 const&, P8 const&,
5821 P9 const&, P10 const&, P11 const&> ArgList;
5822 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
5823 return invoke(argList);
5824 }
5825
5826 /// Invoke the bound functor using the invocation template provided at
5827 /// construction of this `Bind` object, substituting place-holders for
5828 /// arguments 1 - 12 with the values of the specified arguments `p1` -
5829 /// `p12` respectively. Return the result.
5830 template <class P1, class P2, class P3, class P4, class P5, class P6,
5831 class P7, class P8, class P9, class P10, class P11, class P12>
5832 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5833 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5834 P11& p11, P12& p12) const
5835 {
5836 typedef Bind_ArgTuple12<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5837 P9&, P10&, P11&, P12&> ArgList;
5838 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
5839 return invoke(argList);
5840 }
5841
5842 /// Invoke the bound functor using the invocation template provided at
5843 /// construction of this `Bind` object, substituting place-holders for
5844 /// arguments 1 - 12 with the values of the specified arguments `p1` -
5845 /// `p12` respectively. Return the result.
5846 template <class P1, class P2, class P3, class P4, class P5, class P6,
5847 class P7, class P8, class P9, class P10, class P11, class P12>
5848 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5849 P4 const& p4, P5 const& p5, P6 const& p6,
5850 P7 const& p7, P8 const& p8, P9 const& p9,
5851 P10 const& p10, P11 const& p11,
5852 P12 const& p12) const
5853 {
5854 typedef Bind_ArgTuple12<P1 const&, P2 const&, P3 const&, P4 const&,
5855 P5 const&, P6 const&, P7 const&, P8 const&,
5856 P9 const&, P10 const&, P11 const&,
5857 P12 const&> ArgList;
5858 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
5859 return invoke(argList);
5860 }
5861
5862 /// Invoke the bound functor using the invocation template provided at
5863 /// construction of this `Bind` object, substituting place-holders for
5864 /// arguments 1 - 13 with the values of the specified arguments `p1` -
5865 /// `p13` respectively. Return the result.
5866 template <class P1, class P2, class P3, class P4, class P5, class P6,
5867 class P7, class P8, class P9, class P10, class P11, class P12,
5868 class P13>
5869 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5870 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5871 P11& p11, P12& p12, P13& p13) const
5872 {
5873 typedef Bind_ArgTuple13<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5874 P9&, P10&, P11&, P12&, P13&> ArgList;
5875 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5876 p13);
5877 return invoke(argList);
5878 }
5879
5880 /// Invoke the bound functor using the invocation template provided at
5881 /// construction of this `Bind` object, substituting place-holders for
5882 /// arguments 1 - 13 with the values of the specified arguments `p1` -
5883 /// `p13` respectively. Return the result.
5884 template <class P1, class P2, class P3, class P4, class P5, class P6,
5885 class P7, class P8, class P9, class P10, class P11, class P12,
5886 class P13>
5887 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5888 P4 const& p4, P5 const& p5, P6 const& p6,
5889 P7 const& p7, P8 const& p8, P9 const& p9,
5890 P10 const& p10, P11 const& p11,
5891 P12 const& p12, P13 const& p13) const
5892 {
5893 typedef Bind_ArgTuple13<P1 const&, P2 const&, P3 const&, P4 const&,
5894 P5 const&, P6 const&, P7 const&, P8 const&,
5895 P9 const&, P10 const&, P11 const&,
5896 P12 const&, P13 const&> ArgList;
5897 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5898 p13);
5899 return invoke(argList);
5900 }
5901
5902 /// Invoke the bound functor using the invocation template provided at
5903 /// construction of this `Bind` object, substituting place-holders for
5904 /// arguments 1 - 14 with the values of the specified arguments `p1` -
5905 /// `p14` respectively. Return the result.
5906 template <class P1, class P2, class P3, class P4, class P5, class P6,
5907 class P7, class P8, class P9, class P10, class P11, class P12,
5908 class P13, class P14>
5909 ResultType operator()(P1& p1, P2& p2, P3& p3, P4& p4, P5& p5,
5910 P6& p6, P7& p7, P8& p8, P9& p9, P10& p10,
5911 P11& p11, P12& p12, P13& p13, P14& p14) const
5912 {
5913 typedef Bind_ArgTuple14<P1&, P2&, P3&, P4&, P5&, P6&, P7&, P8&,
5914 P9&, P10&, P11&, P12&, P13&, P14&> ArgList;
5915 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5916 p13, p14);
5917 return invoke(argList);
5918 }
5919
5920 /// Invoke the bound functor using the invocation template provided at
5921 /// construction of this `Bind` object, substituting place-holders for
5922 /// arguments 1 - 14 with the values of the specified arguments `p1` -
5923 /// `p14` respectively. Return the result.
5924 template <class P1, class P2, class P3, class P4, class P5, class P6,
5925 class P7, class P8, class P9, class P10, class P11, class P12,
5926 class P13, class P14>
5927 ResultType operator()(P1 const& p1, P2 const& p2, P3 const& p3,
5928 P4 const& p4, P5 const& p5, P6 const& p6,
5929 P7 const& p7, P8 const& p8, P9 const& p9,
5930 P10 const& p10, P11 const& p11,
5931 P12 const& p12, P13 const& p13,
5932 P14 const& p14) const
5933 {
5934 typedef Bind_ArgTuple14<P1 const&, P2 const&, P3 const&, P4 const&,
5935 P5 const&, P6 const&, P7 const&, P8 const&,
5936 P9 const&, P10 const&, P11 const&,
5937 P12 const&, P13 const&, P14 const&> ArgList;
5938 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
5939 p13, p14);
5940 return invoke(argList);
5941 }
5942};
5943
5944 // =======================
5945 // class Bind_ImplExplicit
5946 // =======================
5947
5948/// This class implements the storage and functionality required for a
5949/// binder that invokes an object of type `t_FUNC` with a list of invocation
5950/// parameters of type `t_BOUND_TUPLE`. The return type of the invocation
5951/// is determined by a combination of type `t_RET` and `t_FUNC`. This
5952/// implementation is preferred to the more generic `Bind_Impl` above,
5953/// because it allows to match the signature more closely. However, this
5954/// implementation can only be used when the type of binder is "explicit" (see below).
5955///
5956/// \note Note that it does not yet allow to cast the bound
5957/// arguments to their respective argument type at binding time; the bound
5958/// arguments are still converted to the signature at invocation time.
5959///
5960/// A binder is explicit if:
5961///
5962/// 1. The function signature can be determined completely (return and
5963/// argument types, e.g., free or member function pointers).
5964/// 2. There are no duplicate references to the same placeholder nor any
5965/// nested `Bind` objects in the bound arguments.
5966/// 3. There are no ellipsis argument in the signature of the function.
5967///
5968///
5969/// \note Note that this class is an implementation detail of `Bind`. Do not use
5970/// this class outside this component.
5971///
5972/// See @ref bdlf_bind
5973template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
5974class Bind_ImplExplicit {
5975
5976 // PRIVATE TYPES
5977 typedef Bind_FuncTraits<t_RET, t_FUNC> Traits;
5978
5979 public:
5980 // PUBLIC TYPES
5981
5982 /// The return type of this binder object.
5983 typedef typename Traits::ResultType ResultType;
5984
5985 private:
5986 // PRIVATE TYPES
5987 typedef typename Traits::Type FuncType;
5988 typedef Bind_Invoker<ResultType,
5989 t_BOUND_TUPLE::LENGTH> Invoker;
5990 typedef bslmf::Tag<Traits::k_HAS_POINTER_SEMANTICS> HasPointerSemantics;
5991 typedef typename Traits::FuncArgumentList FuncArgumentList;
5992 typedef Bind_CalcParameterMask<t_BOUND_TUPLE> ParamMask;
5993
5994 enum {
5995 k_IS_MEMBER_OFFSET =
5996 (int)Traits::k_IS_MEMBER_OFFSET // 1 for member functions, 0 else
5997 };
5998
5999 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6000 (int)ParamMask::k_PARAMINDEX1, k_IS_MEMBER_OFFSET>::Type P1;
6001 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6002 (int)ParamMask::k_PARAMINDEX2, k_IS_MEMBER_OFFSET>::Type P2;
6003 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6004 (int)ParamMask::k_PARAMINDEX3, k_IS_MEMBER_OFFSET>::Type P3;
6005 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6006 (int)ParamMask::k_PARAMINDEX4, k_IS_MEMBER_OFFSET>::Type P4;
6007 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6008 (int)ParamMask::k_PARAMINDEX5, k_IS_MEMBER_OFFSET>::Type P5;
6009 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6010 (int)ParamMask::k_PARAMINDEX6, k_IS_MEMBER_OFFSET>::Type P6;
6011 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6012 (int)ParamMask::k_PARAMINDEX7, k_IS_MEMBER_OFFSET>::Type P7;
6013 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6014 (int)ParamMask::k_PARAMINDEX8, k_IS_MEMBER_OFFSET>::Type P8;
6015 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6016 (int)ParamMask::k_PARAMINDEX9, k_IS_MEMBER_OFFSET>::Type P9;
6017 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6018 (int)ParamMask::k_PARAMINDEX10, k_IS_MEMBER_OFFSET>::Type P10;
6019 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6020 (int)ParamMask::k_PARAMINDEX11, k_IS_MEMBER_OFFSET>::Type P11;
6021 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6022 (int)ParamMask::k_PARAMINDEX12, k_IS_MEMBER_OFFSET>::Type P12;
6023 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6024 (int)ParamMask::k_PARAMINDEX13, k_IS_MEMBER_OFFSET>::Type P13;
6025 typedef typename Bind_MapParameter<t_FUNC, FuncArgumentList,
6026 (int)ParamMask::k_PARAMINDEX14, k_IS_MEMBER_OFFSET>::Type P14;
6027
6028 // PRIVATE INSTANCE DATA
6029 bslalg::ConstructorProxy<typename Traits::WrapperType> d_func;
6030 t_BOUND_TUPLE d_list;
6031
6032 public:
6033 // TRAITS
6034 BSLMF_NESTED_TRAIT_DECLARATION(Bind_ImplExplicit,
6035 bslma::UsesBslmaAllocator);
6036
6037 private:
6038 // PRIVATE ACCESSORS
6039
6040 /// Invoke the bound functor using the invocation parameters provided at
6041 /// construction of this `Bind` object. Substituting place-holders for
6042 /// their respective values in the specified `arguments`. The
6043 /// `bslmf::Tag` is only used for overloading resolution - indicating
6044 /// whether `d_func` has pointer semantics or not.
6045 template <class t_ARG_TUPLE>
6046 ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<0>) const
6047 {
6048 Invoker invoker;
6049 return invoker.invoke(&d_func.object(), &d_list, arguments);
6050 }
6051
6052 /// Invoke the bound functor using the invocation parameters provided at
6053 /// construction of this `Bind` object. Substituting place-holders for
6054 /// their respective values in the specified `arguments`. The
6055 /// `bslmf::Tag` is only used for overloading resolution - indicating
6056 /// whether `d_func` has pointer semantics or not.
6057 template <class t_ARG_TUPLE>
6058 inline ResultType invokeImpl(t_ARG_TUPLE& arguments, bslmf::Tag<1>) const
6059 {
6060 Invoker invoker;
6061 return invoker.invoke(&(*d_func.object()), &d_list, arguments);
6062 }
6063
6064 public:
6065 // CREATORS
6066
6067 /// Construct a `Bind_Impl` object bound to the specified invocable
6068 /// object `func` using the invocation parameters specified in `list`.
6069 Bind_ImplExplicit(typename bslmf::ForwardingType<t_FUNC>::Type func,
6070 t_BOUND_TUPLE const& list,
6071 bslma::Allocator *allocator)
6072 : d_func(func, allocator)
6073 , d_list(list, allocator)
6074 {
6075 }
6076
6077 /// Construct a `Bind_Impl` object bound to the specified invocable
6078 /// object `func` using the invocation parameters specified in `list`.
6079 Bind_ImplExplicit(typename bslmf::ForwardingType<t_FUNC>::Type func,
6080 bslmf::MovableRef<t_BOUND_TUPLE> list,
6081 bslma::Allocator *allocator)
6082 : d_func(func, allocator)
6083 , d_list(bslmf::MovableRefUtil::move(list), allocator)
6084 {
6085 }
6086
6087 Bind_ImplExplicit(const Bind_ImplExplicit& other,
6088 bslma::Allocator *allocator)
6089 : d_func(other.d_func, allocator)
6090 , d_list(other.d_list, allocator)
6091 {
6092 }
6093
6094 Bind_ImplExplicit(bslmf::MovableRef<Bind_ImplExplicit> other,
6095 bslma::Allocator *basicAllocator = 0)
6096 : d_func(bslmf::MovableRefUtil::move(
6097 bslmf::MovableRefUtil::access(other.d_func)),
6098 basicAllocator)
6099 , d_list(bslmf::MovableRefUtil::move(
6100 bslmf::MovableRefUtil::access(other.d_list)),
6101 basicAllocator)
6102 {
6103 }
6104
6105 // ACCESSORS
6106
6107 /// Invoke the bound functor using the invocation parameters provided at
6108 /// construction of this `Bind` object. Substituting place-holders for
6109 /// their respective values in the specified `arguments`.
6110 template <class t_ARG_TUPLE>
6111 ResultType invoke(t_ARG_TUPLE& arguments) const
6112 {
6113 return invokeImpl(arguments, HasPointerSemantics());
6114 }
6115
6116 /// Invoke the bound functor using only the invocation parameters
6117 /// provided at construction of this `Bind` object and return the
6118 /// result.
6119 ResultType operator()() const
6120 {
6121 typedef Bind_ArgTuple0 ArgList; ArgList argList;
6122 return invoke(argList);
6123 }
6124
6125 /// Invoke the bound functor using the invocation template provided at
6126 /// construction of this `Bind` object, substituting place-holders for
6127 /// argument 1 with the value of the specified argument `p1`. Return
6128 /// the result.
6129 ResultType operator()(P1 p1) const
6130 {
6131
6132 typedef Bind_ArgTuple1<P1> ArgList; ArgList argList(p1);
6133 return invoke(argList);
6134 }
6135
6136 /// Invoke the bound functor using the invocation template provided at
6137 /// construction of this `Bind` object, substituting place-holders for
6138 /// arguments 1 and 2 with the value of the specified arguments `p1`,
6139 /// and `p2` respectively. Return the result.
6140 ResultType operator()(P1 p1, P2 p2) const
6141 {
6142 typedef Bind_ArgTuple2<P1, P2> ArgList;
6143 ArgList argList(p1, p2);
6144 return invoke(argList);
6145 }
6146
6147 /// Invoke the bound functor using the invocation template provided at
6148 /// construction of this `Bind` object, substituting place-holders for
6149 /// arguments 1, 2, and 3 with the values of the specified arguments
6150 /// `p1`, `p2` and `p3` respectively. Return the result.
6151 ResultType operator()(P1 p1, P2 p2, P3 p3) const
6152 {
6153 typedef Bind_ArgTuple3<P1, P2, P3> ArgList;
6154 ArgList argList(p1, p2, p3);
6155 return invoke(argList);
6156 }
6157
6158 /// Invoke the bound functor using the invocation template provided at
6159 /// construction of this `Bind` object, substituting place-holders for
6160 /// arguments 1 - 4 with the values of the specified arguments `p1` -
6161 /// `p4` respectively. Return the result.
6162 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4) const
6163 {
6164 typedef Bind_ArgTuple4<P1, P2, P3, P4> ArgList;
6165 ArgList argList(p1, p2, p3, p4);
6166 return invoke(argList);
6167 }
6168
6169 /// Invoke the bound functor using the invocation template provided at
6170 /// construction of this `Bind` object, substituting place-holders for
6171 /// arguments 1 - 5 with the values of the specified arguments `p1` -
6172 /// `p5` respectively. Return the result.
6173 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) const
6174 {
6175 typedef Bind_ArgTuple5<P1, P2, P3, P4, P5> ArgList;
6176 ArgList argList(p1, p2, p3, p4, p5);
6177 return invoke(argList);
6178 }
6179
6180 /// Invoke the bound functor using the invocation template provided at
6181 /// construction of this `Bind` object, substituting place-holders for
6182 /// arguments 1 - 6 with the values of the specified arguments `p1` -
6183 /// `p7` respectively. Return the result.
6184 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
6185 {
6186 typedef Bind_ArgTuple6<P1, P2, P3, P4, P5, P6> ArgList;
6187 ArgList argList(p1, p2, p3, p4, p5, p6);
6188 return invoke(argList);
6189 }
6190
6191 /// Invoke the bound functor using the invocation template provided at
6192 /// construction of this `Bind` object, substituting place-holders for
6193 /// arguments 1 - 7 with the values of the specified arguments `p1` -
6194 /// `p7` respectively. Return the result.
6195 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6196 P7 p7) const
6197 {
6198 typedef Bind_ArgTuple7<P1, P2, P3, P4, P5, P6, P7> ArgList;
6199 ArgList argList(p1, p2, p3, p4, p5, p6, p7);
6200 return invoke(argList);
6201 }
6202
6203 /// Invoke the bound functor using the invocation template provided at
6204 /// construction of this `Bind` object, substituting place-holders for
6205 /// arguments 1 - 8 with the values of the specified arguments `p1` -
6206 /// `p8` respectively. Return the result.
6207 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6208 P7 p7, P8 p8) const
6209 {
6210 typedef Bind_ArgTuple8<P1, P2, P3, P4, P5, P6, P7, P8> ArgList;
6211 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8);
6212 return invoke(argList);
6213 }
6214
6215 /// Invoke the bound functor using the invocation template provided at
6216 /// construction of this `Bind` object, substituting place-holders for
6217 /// arguments 1 - 9 with the values of the specified arguments `p1` -
6218 /// `p9` respectively. Return the result.
6219 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6220 P7 p7, P8 p8, P9 p9) const
6221 {
6222 typedef Bind_ArgTuple9<P1, P2, P3, P4, P5, P6, P7, P8, P9> ArgList;
6223 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9);
6224 return invoke(argList);
6225 }
6226
6227 /// Invoke the bound functor using the invocation template provided at
6228 /// construction of this `Bind` object, substituting place-holders for
6229 /// arguments 1 - 10 with the values of the specified arguments `p1` -
6230 /// `p10` respectively. Return the result.
6231 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6232 P7 p7, P8 p8, P9 p9, P10 p10) const
6233 {
6234 typedef Bind_ArgTuple10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>
6235 ArgList;
6236 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
6237 return invoke(argList);
6238 }
6239
6240 /// invoke the bound functor using the invocation template provided at
6241 /// construction of this @ref bdlf_bind object, substituting place-holders
6242 /// for arguments 1 - 11 with the values of the specified arguments `p1`
6243 /// - `p11` respectively. Return the result.
6244 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6245 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) const
6246 {
6247 typedef Bind_ArgTuple11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6248 P11> ArgList;
6249 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
6250 return invoke(argList);
6251 }
6252
6253 /// Invoke the bound functor using the invocation template provided at
6254 /// construction of this `Bind` object, substituting place-holders for
6255 /// arguments 1 - 12 with the values of the specified arguments `p1` -
6256 /// `p12` respectively. Return the result.
6257 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6258 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6259 P12 p12) const
6260 {
6261 typedef Bind_ArgTuple12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6262 P11, P12> ArgList;
6263 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
6264 return invoke(argList);
6265 }
6266
6267 /// Invoke the bound functor using the invocation template provided at
6268 /// construction of this `Bind` object, substituting place-holders for
6269 /// arguments 1 - 13 with the values of the specified arguments `p1` -
6270 /// `p13` respectively. Return the result.
6271 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6272 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6273 P12 p12, P13 p13) const
6274 {
6275 typedef Bind_ArgTuple13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10,
6276 P11, P12, P13> ArgList;
6277 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
6278 p13);
6279 return invoke(argList);
6280 }
6281
6282 /// Invoke the bound functor using the invocation template provided at
6283 /// construction of this `Bind` object, substituting place-holders for
6284 /// arguments 1 - 14 with the values of the specified arguments `p1` -
6285 /// `p14` respectively. Return the result.
6286 ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6,
6287 P7 p7, P8 p8, P9 p9, P10 p10, P11 p11,
6288 P12 p12, P13 p13, P14 p14) const
6289 {
6290 typedef Bind_ArgTuple14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11,
6291 P12, P13, P14> ArgList;
6292 ArgList argList(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12,
6293 p13, p14);
6294 return invoke(argList);
6295 }
6296};
6297
6298 // =======================
6299 // class Bind_ImplSelector
6300 // =======================
6301
6302/// This utility is used to select the best bind implementation for the
6303/// given function and invocation template. `Bind_ImplExplicit` is selected
6304/// if the binder is explicit, else `Bind_Impl` is selected. A binder is
6305/// explicit when:
6306///
6307/// 1. The function signature can be determined completely (return and
6308/// argument types, e.g., free or member function pointers).
6309/// 2. There are no duplicate references to the same placeholder nor any
6310/// nested `Bind` objects in the bound arguments.
6311/// 3. There are no ellipsis argument in the signature of the function.
6312///
6313/// See @ref bdlf_bind
6314template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6328
6329// Implementation note: The following three classes, 'Bind_FuncTraits',
6330// 'Bind_FuncTraitsImp', and 'Bind_FuncTraitsHasNoEllipsis' are presented in
6331// the reverse order to eliminate an AIX failure due to the order of templates,
6332// even if those have been forward-declared.
6333
6334 // ==================================
6335 // class Bind_FuncTraitsHasNoEllipsis
6336 // ==================================
6337
6338/// Determines whether a function type has the ellipsis as an argument.
6339/// This is needed for making the binder non-explicit in case of a function
6340/// pointer, reference, or member function pointer. By default, a function
6341/// does not take an ellipsis unless specialized below. This traits class is used in the `Bind_FuncTraitsImp` below.
6342///
6343/// \note Note that this meta function
6344/// is not supported on sun studio 8.
6345///
6346/// See @ref bdlf_bind
6347template <class t_FUNC>
6348struct Bind_FuncTraitsHasNoEllipsis {
6349
6350 enum {
6351 k_VAL = 1
6352 };
6353};
6354
6355// PARTIAL SPECIALIZATIONS
6356
6357/// Specialization for function pointers that return `t_RET` and accept one
6358/// argument which is an ellipsis.
6359template <class t_RET>
6360struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(...)> {
6361 enum { k_VAL = 0 };
6362};
6363
6364/// Specialization for function pointers that return `t_RET` and accept one
6365/// argument and an ellipsis.
6366template <class t_RET, class A1>
6367struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,...)> {
6368 enum { k_VAL = 0 };
6369};
6370
6371/// Specialization for function pointers that return `t_RET` and accept two
6372/// arguments and an ellipsis.
6373template <class t_RET, class A1, class A2>
6374struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,...)> {
6375 enum { k_VAL = 0 };
6376};
6377
6378/// Specialization for function pointers that return `t_RET` and accept
6379/// three arguments and an ellipsis.
6380template <class t_RET, class A1, class A2, class A3>
6381struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,...)> {
6382 enum { k_VAL = 0 };
6383};
6384
6385/// Specialization for function pointers that return `t_RET` and accept four
6386/// arguments and an ellipsis.
6387template <class t_RET, class A1, class A2, class A3, class A4>
6388struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,...)> {
6389 enum { k_VAL = 0 };
6390};
6391
6392/// Specialization for function pointers that return `t_RET` and accept five
6393/// arguments and an ellipsis.
6394template <class t_RET, class A1, class A2, class A3, class A4, class A5>
6395struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,...)> {
6396 enum { k_VAL = 0 };
6397};
6398
6399/// Specialization for function pointers that return `t_RET` and accept six
6400/// arguments and an ellipsis.
6401template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6402 class A6>
6403struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6,...)> {
6404 enum { k_VAL = 0 };
6405};
6406
6407/// Specialization for function pointers that return `t_RET` and accept
6408/// seven arguments and an ellipsis.
6409template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6410 class A6, class A7>
6411struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6, A7,...)> {
6412 enum { k_VAL = 0 };
6413};
6414
6415/// Specialization for function pointers that return `t_RET` and accept
6416/// eight arguments and an ellipsis.
6417template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6418 class A6, class A7, class A8>
6419struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(A1,A2,A3,A4,A5,A6,A7,A8,...)> {
6420 enum { k_VAL = 0 };
6421};
6422
6423/// Specialization for function pointers that return `t_RET` and accept nine
6424/// arguments and an ellipsis.
6425template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6426 class A6, class A7, class A8, class A9>
6427struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6428 A1,A2,A3,A4,A5,A6,A7,A8,A9,...)> {
6429 enum { k_VAL = 0 };
6430};
6431
6432/// Specialization for function pointers that return `t_RET` and accept ten
6433/// arguments and an ellipsis.
6434template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6435 class A6, class A7, class A8, class A9, class A10>
6436struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6437 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,...)> {
6438 enum { k_VAL = 0 };
6439};
6440
6441/// Specialization for function pointers that return `t_RET` and accept
6442/// eleven arguments and an ellipsis.
6443template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6444 class A6, class A7, class A8, class A9, class A10, class A11>
6445struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6446 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,...)> {
6447 enum { k_VAL = 0 };
6448};
6449
6450/// Specialization for function pointers that return `t_RET` and accept
6451/// twelve arguments and an ellipsis.
6452template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6453 class A6, class A7, class A8, class A9, class A10, class A11,
6454 class A12>
6455struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6456 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,...)> {
6457 enum { k_VAL = 0 };
6458};
6459
6460/// Specialization for function pointers that return `t_RET` and accept
6461/// thirteen arguments and an ellipsis.
6462template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6463 class A6, class A7, class A8, class A9, class A10, class A11,
6464 class A12, class A13>
6465struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6466 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,...)> {
6467 enum { k_VAL = 0 };
6468};
6469
6470/// Specialization for function pointers that return `t_RET` and accept
6471/// fourteen arguments and an ellipsis.
6472template <class t_RET, class A1, class A2, class A3, class A4, class A5,
6473 class A6, class A7, class A8, class A9, class A10, class A11,
6474 class A12, class A13, class A14>
6475struct Bind_FuncTraitsHasNoEllipsis<t_RET (*)(
6476 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14...)> {
6477 enum { k_VAL = 0 };
6478};
6479
6480 // ================================================
6481 // struct Bind_FuncTraitsImp_OneResultTypeOrAnother
6482 // ================================================
6483
6484/// Define the type variable `type` to be `t_FUNC::result_type` if that
6485/// exists and `t_FUNC::ResultType` otherwise. Additionally, for C++11 and
6486/// above, if `t_FUNC` has an `operator()` member (such as lambda
6487/// functions), define `type` to be the return type of that operator.
6488///
6489/// This `struct` is used by some, but not most, of the definitions of
6490/// `Bind_FuncTraitsImp`.
6491///
6492/// See @ref bdlf_bind
6493template <class t_FUNC>
6494struct Bind_FuncTraitsImp_OneResultTypeOrAnother {
6495
6496 private:
6497 // PRIVATE TYPES
6498
6499 /// This class declares a `type` member to be the same as the one
6500 /// `bslmf::ResultType` produces.
6501 ///
6502 /// See @ref bdlf_bind
6503 template <class T, class = void>
6504 struct Result {
6505
6506 // PUBLIC TYPES
6507 typedef typename bslmf::ResultType<T>::type type;
6508 };
6509
6510#ifdef BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE
6511#ifdef BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES
6512
6513 /// The general version of this class inherits from its specialization.
6514 ///
6515 /// See @ref bdlf_bind
6516 template <class T>
6517 struct Return : public Return<decltype(&T::operator())> {
6518 };
6519
6520 /// The non-`const` specialized form of the `Return` class defines a
6521 /// `type` member as the return type of the member function parameter.
6522 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6523 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6524
6525 // PUBLIC TYPES
6526 typedef t_RET type;
6527 };
6528
6529 /// The `const` specialized form of the `Return` class inherits from
6530 /// the non-`const` specialization (above).
6531 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6532 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) const> :
6533 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6534 };
6535
6536#if defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES)
6537
6538 /// The non-`const` noexcept specialized form of the `Return` class
6539 /// inherits from the non-`const` non-`noexcept` specialization (above).
6540 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6541 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) noexcept> :
6542 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6543 };
6544
6545 /// The `const` noexcept specialized form of the `Return` class inherits
6546 /// from the non-`const` non-`noexcept` specialization (above).
6547 template <class t_CLASS, class t_RET, class... t_FUNC_ARGS>
6548 struct Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...) const noexcept> :
6549 public Return<t_RET (t_CLASS::*)(t_FUNC_ARGS...)> {
6550 };
6551
6552#endif // BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT_TYPES
6553
6554 /// This is a specialization of `Result` above. If the `T` parameter
6555 /// has a single unique `operator()` member, then `Result<T, void>`
6556 /// prefers this specialization over the general template. This class
6557 /// declares a `type` member as the return type of `T::operator()`.
6558 template <class T>
6559 struct Result<T, bsl::void_t<decltype(&T::operator())>> {
6560
6561 // PUBLIC TYPES
6562 typedef typename Return<T>::type type;
6563 };
6564
6565#endif // BSLS_COMPILERFEATURES_SUPPORT_VARIADIC_TEMPLATES
6566#endif // BSLS_COMPILERFEATURES_SUPPORT_DECLTYPE
6567
6568 public:
6569 // TYPES
6570 typedef typename Result<t_FUNC>::type type;
6571};
6572
6573 // ===================
6574 // class FuncTraitsImp
6575 // ===================
6576
6577/// This `struct` provides a mechanism for inferring various traits of the
6578/// function object type `t_FUNC`. The return type is given by `t_RET`
6579/// unless it is `bslmf::Nil` in which case it is inferred from `t_FUNC`.
6580/// The last three parameters `IS_FUNCTION`, `IS_FUNCTION_POINTER` and
6581/// `IS_MEMBER_FUNCTION_POINTER` specify whether `t_FUNC` is a free function
6582/// type (either a reference-to-function or plain function type), a pointer
6583/// to function type, or a pointer to member function type, respectively.
6584///
6585/// Only specializations of this class should be used (given below). All
6586/// specializations define the types and enumerations documented in the
6587/// `Bind_FuncTraits` below.
6588template <class t_RET,
6589 class t_FUNC,
6590 int IS_FUNCTION,
6591 int IS_FUNCTION_POINTER,
6592 int IS_MEMBER_FUNCTION_POINTER>
6593struct Bind_FuncTraitsImp;
6594
6595// PARTIAL SPECIALIZATIONS
6596
6597/// Function traits for non-member function types (references or not, but
6598/// not pointers to function), with explicit return type specification.
6599template <class t_RET, class t_FUNC>
6600struct Bind_FuncTraitsImp<t_RET, t_FUNC, 1, 0, 0> {
6601
6602 // ENUMERATIONS
6603 enum {
6604 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC*>::k_VAL
6605 , k_IS_MEMBER_OFFSET = 0
6606 , k_HAS_POINTER_SEMANTICS = 0
6607 };
6608
6609 // PUBLIC TYPES
6610 typedef t_FUNC *Type;
6611 typedef t_FUNC *WrapperType;
6612 typedef t_RET ResultType;
6613 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ArgumentList
6614 FuncArgumentList;
6615};
6616
6617/// Function traits for non-member function pointers, with explicit return
6618/// type specification.
6619template <class t_RET, class t_FUNC>
6620struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 1, 0> {
6621
6622 // ENUMERATIONS
6623 enum {
6624 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC>::k_VAL
6625 , k_IS_MEMBER_OFFSET = 0
6626 , k_HAS_POINTER_SEMANTICS = 0
6627 };
6628
6629 // PUBLIC TYPES
6630 typedef t_FUNC Type;
6631 typedef t_FUNC WrapperType;
6632 typedef t_RET ResultType;
6633 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ArgumentList
6634 FuncArgumentList;
6635};
6636
6637/// Function traits for member function pointers, with explicit return type
6638/// specification.
6639template <class t_RET, class t_FUNC>
6640struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 0, 1> {
6641
6642 // ENUMERATIONS
6643 enum {
6644 k_IS_EXPLICIT = 1 // we do not support the ellipsis
6645 , k_IS_MEMBER_OFFSET = 1
6646 , k_HAS_POINTER_SEMANTICS = 0
6647 };
6648
6649 // PUBLIC TYPES
6650 typedef t_FUNC Type;
6651 typedef MemFn<t_FUNC> WrapperType;
6652 typedef t_RET ResultType;
6653 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ArgumentList
6654 FuncArgumentList;
6655};
6656
6657/// Function traits for function objects that are passed by value with
6658/// explicit return type specification.
6659template <class t_RET, class t_FUNC>
6660struct Bind_FuncTraitsImp<t_RET, t_FUNC, 0, 0, 0> {
6661
6662 // ENUMERATIONS
6663 enum {
6664 k_IS_EXPLICIT = 0
6665 , k_HAS_POINTER_SEMANTICS = bslmf::HasPointerSemantics<t_FUNC>::value
6666 };
6667
6668 // PUBLIC TYPES
6669 typedef t_FUNC Type;
6670 typedef t_FUNC WrapperType;
6671 typedef t_RET ResultType;
6672};
6673
6674/// Function traits for objects passed by pointer with explicit return type.
6675template <class t_RET, class t_FUNC>
6676struct Bind_FuncTraitsImp<t_RET, t_FUNC *, 0, 0, 0> {
6677
6678 // ENUMERATIONS
6679 enum {
6680 k_IS_EXPLICIT = 0
6681 , k_HAS_POINTER_SEMANTICS = 1
6682 };
6683
6684 // PUBLIC TYPES
6685 typedef t_FUNC Type;
6686 typedef t_FUNC *WrapperType;
6687 typedef t_RET ResultType;
6688};
6689
6690/// Function traits for non-member function types (references or not, but
6691/// not pointers to function). The result type is determined from the
6692/// function pointer traits.
6693template <class t_FUNC>
6694struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 1, 0, 0> {
6695
6696 // ENUMERATIONS
6697 enum {
6698 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC*>::k_VAL
6699 , k_IS_MEMBER_OFFSET = 0
6700 , k_HAS_POINTER_SEMANTICS = 0
6701 };
6702
6703 // PUBLIC TYPES
6704 typedef t_FUNC Type;
6705 typedef t_FUNC *WrapperType;
6706 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ResultType
6707 ResultType;
6708 typedef typename bslmf::FunctionPointerTraits<t_FUNC *>::ArgumentList
6709 FuncArgumentList;
6710};
6711
6712/// Function traits for non-member function pointers. The result type is
6713/// determined from the function pointer traits.
6714template <class t_FUNC>
6715struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 1, 0> {
6716
6717 // ENUMERATIONS
6718 enum {
6719 k_IS_EXPLICIT = Bind_FuncTraitsHasNoEllipsis<t_FUNC>::k_VAL
6720 , k_IS_MEMBER_OFFSET = 0
6721 , k_HAS_POINTER_SEMANTICS = 0
6722 };
6723
6724 // PUBLIC TYPES
6725 typedef t_FUNC Type;
6726 typedef t_FUNC WrapperType;
6727 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ResultType
6728 ResultType;
6729 typedef typename bslmf::FunctionPointerTraits<t_FUNC>::ArgumentList
6730 FuncArgumentList;
6731};
6732
6733/// Function traits for member function pointers. The result type is
6734/// determined from the function pointer traits.
6735template <class t_FUNC>
6736struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 0, 1> {
6737
6738 // ENUMERATIONS
6739 enum {
6740 k_IS_EXPLICIT = 1 // we do not support the ellipsis
6741 , k_IS_MEMBER_OFFSET = 1
6742 , k_HAS_POINTER_SEMANTICS = 0
6743 };
6744
6745 // PUBLIC TYPES
6746 typedef t_FUNC Type;
6747 typedef MemFn<t_FUNC> WrapperType;
6748 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ResultType
6749 ResultType;
6750 typedef typename bslmf::MemberFunctionPointerTraits<t_FUNC>::ArgumentList
6751 FuncArgumentList;
6752};
6753
6754/// Function traits for function objects that are passed by value without
6755/// explicit result type specification. The result type is determined by
6756/// either `typename t_FUNC::result_type` or `typename t_FUNC::ResultType`,
6757/// with the former taking precedence if both are defined.
6758template <class t_FUNC>
6759struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC, 0, 0, 0> {
6760
6761 // ENUMERATIONS
6762 enum {
6763 k_IS_EXPLICIT = 0
6764 , k_HAS_POINTER_SEMANTICS = bslmf::HasPointerSemantics<t_FUNC>::value
6765 };
6766
6767 // PUBLIC TYPES
6768 typedef t_FUNC Type;
6769 typedef t_FUNC WrapperType;
6770 typedef typename Bind_FuncTraitsImp_OneResultTypeOrAnother<t_FUNC>::type
6771 ResultType;
6772};
6773
6774/// Function traits for bsl::function objects that are passed by value. The
6775/// result type is determined by `bsl::function<PROTO>::result_type`.
6776template <class PROTO>
6777struct Bind_FuncTraitsImp<bslmf::Nil,bsl::function<PROTO>,0,0,0> {
6778
6779 // ENUMERATIONS
6780 enum {
6781 k_IS_EXPLICIT = 0
6782 , k_HAS_POINTER_SEMANTICS = 0
6783 };
6784
6785 // PUBLIC TYPES
6786 typedef bsl::function<PROTO> Type;
6787 typedef bsl::function<PROTO> WrapperType;
6788 typedef typename bsl::function<PROTO>::result_type ResultType;
6789};
6790
6791/// Function traits for objects passed by pointer with no explicit return
6792/// type. The object is assumed to have a `result_type` or `ResultType`
6793/// type definition, with the former taking precedence if both are defined.
6794template <class t_FUNC>
6795struct Bind_FuncTraitsImp<bslmf::Nil, t_FUNC *, 0, 0, 0> {
6796
6797 // ENUMERATIONS
6798 enum {
6799 k_IS_EXPLICIT = 0
6800 , k_HAS_POINTER_SEMANTICS = 1
6801 };
6802
6803 // PUBLIC TYPES
6804 typedef t_FUNC Type;
6805 typedef t_FUNC *WrapperType;
6806 typedef typename Bind_FuncTraitsImp_OneResultTypeOrAnother<t_FUNC>::type
6807 ResultType;
6808};
6809
6810/// Function traits for objects passed by pointer with no explicit return
6811/// type. The object is assumed to have a `ResultType` type definition.
6812template <class PROTO>
6813struct Bind_FuncTraitsImp<bslmf::Nil,bsl::function<PROTO>*,0,0,0> {
6814
6815 // ENUMERATIONS
6816 enum {
6817 k_IS_EXPLICIT = 0
6818 , k_HAS_POINTER_SEMANTICS = 1
6819 };
6820
6821 // PUBLIC TYPES
6822 typedef bsl::function<PROTO> Type;
6823 typedef bsl::function<PROTO>* WrapperType;
6824 typedef typename bsl::function<PROTO>::result_type ResultType;
6825};
6826
6827 // ================
6828 // class FuncTraits
6829 // ================
6830
6831/// This `struct` provides various traits of the functor type `t_FUNC`
6832/// documented below. If `t_RET` is `bslmf::Nil`, then the return type is
6833/// inferred by using either `bslmf::FunctionPointerTraits`,
6834/// `bslmf::MemberFunctionPointerTraits`, or `typename t_FUNC::result_type`
6835/// as appropriate.
6836/// @code
6837/// // ENUMERATIONS
6838/// enum {
6839/// k_IS_EXPLICIT // An invocable object is explicit if ...
6840/// // (see 'Bind_ImplExplicit')
6841///
6842/// , k_IS_MEMBER_OFFSET // Offset for calculating evaluation of
6843/// // placeholder values at invocation. Will
6844/// // be 1 for member function pointers, and 0
6845/// // otherwise.
6846///
6847/// , k_HAS_POINTER_SEMANTICS // Whether the bound functor should be
6848/// // invoked by address or by value.
6849/// };
6850///
6851/// // PUBLIC TYPES
6852/// typedef ... Type; // type of the bound function object
6853/// typedef ... WrapperType; // type of the bound object wrapper
6854/// typedef ... ResultType; // return type of the bound function
6855/// // object
6856/// typedef ... FuncArgumentList; // signature of the bound function object,
6857/// // a 'bslmf::TypeList'
6858/// @endcode
6859/// The table below gives a summary of the values set by the specializations
6860/// of `Bind_FuncTraitsImp`, where `X` represents a class type and `T`
6861/// represents the return type (given explicitly by `t_RET`, or deduced by
6862/// the nested `ResultType` of `X` or of the appropriate traits when `t_RET`
6863/// is specified as `bslmf::Nil`).
6864///
6865/// t_RET t_FUNC IS _FN IS_FNP IS_MEM IS_EXPLICIT OFFSET PTR_SEM
6866/// --------- ------- ------ ------ ------ ----------- ------ -------
6867/// T T(...) 1 0 0 1^ 0 0
6868/// T T(*)(...) 0 1 0 1^ 0 0
6869/// T T(X::*)(...) 0 0 1 1 1 0
6870/// T X 0 0 0 0 A B
6871/// T X* 0 0 0 0 A 1
6872/// bslmf::Nil T(...) 1 0 0 1^ 0 0
6873/// bslmf::Nil T(*)(..) 0 1 0 1^ 0 0
6874/// bslmf::Nil T(X::*)(...) 0 0 1 1 1 0
6875/// bslmf::Nil X 0 0 0 0 A B
6876/// bslmf::Nil X* 0 0 0 0 A 1
6877///
6878/// A: undefined, since unused by `Bin_Impl`, which is used for
6879/// non-explicit binders.
6880/// B: as determined by the value of
6881/// `bslalg_TypeTraits<X, bslalg::TypeTraitHasPointerSemantics>`.
6882/// ^: in the (rare) case where the `t_FUNC` type has an ellipsis argument, the k_IS_EXPLICIT will be set to 0.
6883///
6884/// \note Note that we *only* support the
6885/// ellipsis in non-member functions.
6886template <class t_RET, class t_FUNC>
6887struct Bind_FuncTraits
6888 : Bind_FuncTraitsImp<t_RET,
6889 t_FUNC,
6890 (int)bslmf::IsFunctionPointer<t_FUNC*>::value,
6891 (int)bslmf::IsFunctionPointer<t_FUNC>::value,
6892 (int)bslmf::IsMemberFunctionPointer<t_FUNC>::value>
6893{
6894};
6895
6896 // ==========================
6897 // class Bind_PlaceHolderMask
6898 // ==========================
6899
6900/// This template, passed the type of one of the bound arguments to a
6901/// function object, yields:
6902/// * If the specified `t_BOUND_TYPE` is a place holder, a mask with the
6903/// bit at the index of the place holder set.
6904/// * If the specified `t_BOUND_TYPE` is a `Bind` or `BindWrapper`, a mask
6905/// with bit 24 set.
6906/// * Zero otherwise.
6907template <class t_BOUND_TYPE>
6908struct Bind_PlaceHolderMask;
6909
6910template <class t_BOUND_TYPE>
6911struct Bind_PlaceHolderMask {
6912 static const int k_VAL = 0;
6913};
6914
6915template <int INDEX>
6916struct Bind_PlaceHolderMask<PlaceHolder<INDEX> > {
6917 static const int k_VAL = 1 << INDEX;
6918};
6919
6920/// This specialization of `Bind_PlaceHolderMask` defines a mask for a
6921/// `Bind` object passed recursively as a bound argument. The value is not important, as long as it is out of range.
6922///
6923/// \note Note that `1 << 30` would be
6924/// equally valid, but can lead to an overflow in constant expression with
6925/// `Bind_CalcParameterMask::k_PARAM_MASK2` below (obtained by adding the
6926/// masks of the bound arguments together) when there are more than 3 nested
6927/// binders (this is unfortunately an error with the GNU compiler).
6928template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6929struct Bind_PlaceHolderMask<Bind<t_RET, t_FUNC, t_BOUND_TUPLE> > {
6930
6931 static const int k_VAL = 1 << 24;
6932};
6933
6934/// This specialization of `Bind_PlaceHolderMask` defines a mask for a
6935/// `BindWrapper` object passed recursively as a bound argument. The value
6936/// is not important, as long as it is out of range. This makes sure that a
6937/// binder with a nested `BindWrapper` object is treated as non-explicit, in
6938/// the same way as if the nested binder was of type `Bind`.
6939template <class t_RET, class t_FUNC, class t_BOUND_TUPLE>
6940struct Bind_PlaceHolderMask<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE> > {
6941
6942 static const int k_VAL = 1 << 24;
6943};
6944
6945
6946 // ===========================
6947 // class Bind_PlaceHolderIndex
6948 // ===========================
6949
6950/// This template, passed the type of one of the bound arguments to a
6951/// function object, yields:
6952/// * if the specified `t_BOUND_TYPE` is a place holder, the index of the
6953/// place holder object
6954/// * zero otherwise
6955template <class t_BOUND_TYPE>
6956struct Bind_PlaceHolderIndex;
6957
6958/// This template is used to calculate a compound numeric value of which
6959/// parameters must be forwarded to a bound functor. The general definition
6960/// defines a numeric value of zero.
6961///
6962/// See @ref bdlf_bind
6963template <class t_BOUND_TYPE>
6964struct Bind_PlaceHolderIndex {
6965
6966 enum {
6967 k_VAL = 0
6968 };
6969};
6970
6971/// This specialization of `Bind_PlaceHolderIndex` defines a numeric value
6972/// for the place-holder at the specified `INDEX` of the bound arguments.
6973template <int INDEX>
6974struct Bind_PlaceHolderIndex<PlaceHolder<INDEX> > {
6975
6976 enum {
6977 k_VAL = INDEX
6978 };
6979};
6980
6981 // =============================
6982 // class Bind_MemFnObjectWrapper
6983 // =============================
6984
6985/// This local class is used to wrap an object used to invoke a member
6986/// functions bound to a `Bind` binder. In explicit binding, the argument
6987/// types of operator() are determined during `Bind` instantiation. If a
6988/// member function is bound to the binder, and the object to invoke the
6989/// member function on is passed as an invocation argument (instead of a
6990/// bound argument), the exact type of the object - whether it is a pointer
6991/// or reference - cannot be determined based on the method signature. This
6992/// wrapper serve as an intermediate type to wrap around the object pointer
6993/// or reference. This class is declared to have pointer semantics, such
6994/// that `MemFn` will properly dereference the object to invoke the member
6995/// function.
6996///
6997/// See @ref bdlf_bind
6998template <class t_TYPE>
6999class Bind_MemFnObjectWrapper {
7000
7001 // DATA
7002 t_TYPE *d_object_p; // held, not owned
7003
7004 // PRIVATE CLASS METHODS
7005
7006 // The second unnamed argument is a boolean that is 'true' if 't_ARG_TYPE'
7007 // has pointer sematics. If it does, return '&*pointerLink' implicitly
7008 // cast to 't_TYPE'. Note that if 't_ARG_TYPE' is a smart pointer type,
7009 // the '&*' operation will convert it to a raw pointer. If 't_ARG_TYPE'
7010 // does not have pointer semantics, implicitly cast a raw pointer to it to
7011 // 't_TYPE *'. Note that 't_ARG_TYPE' and/or 't_TYPE' may be 'const',
7012 // though a compilation error will occur if 't_ARG_TYPE' is 'const' and
7013 // 't_TYPE' is not.
7014 template <class t_ARG_TYPE>
7015 static
7016 t_TYPE *getObjectPtr(t_ARG_TYPE& pointerLike,
7017 bsl::true_type ) // has pointer semantics
7018 {
7019 return &*pointerLike;
7020 }
7021 template <class t_ARG_TYPE>
7022 static
7023 t_TYPE *getObjectPtr(t_ARG_TYPE& notPointerLike,
7024 bsl::false_type ) // doesn't have pointer semantics
7025 {
7026 return &notPointerLike;
7027 }
7028
7029 public:
7030 // TRAITS
7031 BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper,
7032 bslmf::HasPointerSemantics);
7033 BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper,
7034 bslmf::IsBitwiseMoveable);
7035
7036 // CREATORS
7037
7038 /// If the c'tor argument has pointer sematics to 't_TYPE', perform '&*' on
7039 /// it to initialize 'd_object_p', otherwise take its address to initialize 'd_object_p'.
7040 ///
7041 /// \note Note that 't_TYPE' and/or 't_ARG_TYPE' may be 'const',
7042 /// though a compilation error will result if 't_ARG_TYPE' is 'const' and
7043 /// 't_TYPE' is not.
7044 template <class t_ARG_TYPE>
7045 Bind_MemFnObjectWrapper(t_ARG_TYPE& object)
7046 // IMPLICIT
7047 : d_object_p(getObjectPtr(object,
7048 bslmf::HasPointerSemantics<
7049 typename bsl::remove_cv<t_ARG_TYPE>::type>()))
7050 {}
7051 template <class t_ARG_TYPE>
7052 Bind_MemFnObjectWrapper(BSLMF_MOVABLEREF_DEDUCE(t_ARG_TYPE) object)
7053 // IMPLICIT
7054 : d_object_p(getObjectPtr(static_cast<t_ARG_TYPE&>(object),
7055 bslmf::HasPointerSemantics<
7056 typename bsl::remove_cv<t_ARG_TYPE>::type>()))
7057 {}
7058
7059 // ACCESSORS
7060
7061 /// Returns a reference to the object (of parameterized `TYPE`) pointed
7062 /// to by this `Bind_MemFnObjectWrapper`.
7063 t_TYPE& operator*() const { return *d_object_p; }
7064
7065};
7066
7067 // =======================
7068 // class Bind_MapParameter
7069 // =======================
7070
7071/// This meta-function is used to select the type at `t_OFFSET` positions of
7072/// the `t_INDEX` position in an argument list type `t_FUNC_ARGS`, which is
7073/// of type `bslmf::TypeList` denoting the arguments of `t_FUNC`.
7074///
7075/// \note Note that this class is used by `Bind_ImplExplicit`.
7076///
7077/// See @ref bdlf_bind
7078template <class t_FUNC, class t_FUNC_ARGS, int t_INDEX, int t_IS_MEMBER_OFFSET>
7079struct Bind_MapParameter {
7080
7081 // PUBLIC TYPES
7082 typedef typename
7083 bslmf::ForwardingType<typename bslmf::TypeListTypeOf<
7084 t_INDEX - t_IS_MEMBER_OFFSET,
7085 t_FUNC_ARGS,
7086 const bslmf::MatchAnyType&>::TypeOrDefault>::Type Type;
7087};
7088
7089/// This partial specialization of `Bind_MapParameter` is intended for use
7090/// with member functions. The `Bind_MemFnObjectWrapper` will properly wrap
7091/// around the class object reference or pointer, such that either can be
7092/// used to invoke the member function.
7093template <class t_FUNC, class t_FUNC_ARGS>
7094struct Bind_MapParameter<t_FUNC, t_FUNC_ARGS, 1, 1> {
7095
7096 // PUBLIC TYPES
7097 typedef bslmf::MemberFunctionPointerTraits<t_FUNC> Traits;
7098 typedef typename Traits::ClassType ObjectType;
7099 typedef typename bslmf::ForwardingType<
7100 const Bind_MemFnObjectWrapper<ObjectType>& >::Type Type;
7101};
7102
7103/// This partial specialization of `Bind_MapParameter` does not specify any
7104/// type in the `t_FUNC_ARGS` list. It is used for parameters that should
7105/// be ignored.
7106template <class t_FUNC, class t_FUNC_ARGS, int t_IS_MEMBER_OFFSET>
7107struct Bind_MapParameter<t_FUNC, t_FUNC_ARGS, 0, t_IS_MEMBER_OFFSET> {
7108
7109 // PUBLIC TYPES
7110 typedef const bslmf::MatchAnyType& Type;
7111};
7112} // close package namespace
7113
7114 // ==================================
7115 // class bdlf::Bind_CalcParameterMask
7116 // ==================================
7117
7118// The following macro is used to compute the index of place holders within a
7119// parameter list and its corresponding mapping to the place holder values.
7120// For example:
7121//..
7122// bdlf::BindUtil::bind(&foo, _1, "abc", _2, _5);
7123//..
7124// Will have the following values:
7125//..
7126// bind time index invocation time index
7127// --------------- ---------------------
7128// k_PARAM1 1
7129// k_PARAM2 0
7130// k_PARAM3 2
7131// k_PARAM4 5
7132//..
7133// The 'BDLF_BIND_PARAMINDEX' macro will compute the following:
7134//..
7135// BDLF_BIND_PARAMINDEX(1) = 1
7136// BDLF_BIND_PARAMINDEX(2) = 3
7137// BDLF_BIND_PARAMINDEX(3) = 0
7138// BDLF_BIND_PARAMINDEX(4) = 0
7139// BDLF_BIND_PARAMINDEX(5) = 4
7140//..
7141// The index is used to deduce the appropriate invocation argument type for the
7142// explicit binder.
7143
7144#define BDLF_BIND_PARAMINDEX(N) ( \
7145(k_PARAM1 == N ? 1 : 0) + \
7146(k_PARAM2 == N ? 2 : 0) + \
7147(k_PARAM3 == N ? 3 : 0) + \
7148(k_PARAM4 == N ? 4 : 0) + \
7149(k_PARAM5 == N ? 5 : 0) + \
7150(k_PARAM6 == N ? 6 : 0) + \
7151(k_PARAM7 == N ? 7 : 0) + \
7152(k_PARAM8 == N ? 8 : 0) + \
7153(k_PARAM9 == N ? 9 : 0) + \
7154(k_PARAM10 == N ? 10 : 0) + \
7155(k_PARAM11 == N ? 11 : 0) + \
7156(k_PARAM12 == N ? 12 : 0) + \
7157(k_PARAM13 == N ? 13 : 0) + \
7158(k_PARAM14 == N ? 14 : 0))
7159
7160namespace bdlf {
7161/// This meta-function is used to calculate a mask that indicates which
7162/// parameters in `t_BOUND_TUPLE` are place-holders and which ones are
7163/// literal values. It is used by `Bind_ImplExplicit`.
7164///
7165/// See @ref bdlf_bind
7166template <class t_BOUND_TUPLE>
7167struct Bind_CalcParameterMask {
7168
7169 typedef typename t_BOUND_TUPLE::template TypeOf< 1>::TypeOrDefault Type1;
7170 typedef typename t_BOUND_TUPLE::template TypeOf< 2>::TypeOrDefault Type2;
7171 typedef typename t_BOUND_TUPLE::template TypeOf< 3>::TypeOrDefault Type3;
7172 typedef typename t_BOUND_TUPLE::template TypeOf< 4>::TypeOrDefault Type4;
7173 typedef typename t_BOUND_TUPLE::template TypeOf< 5>::TypeOrDefault Type5;
7174 typedef typename t_BOUND_TUPLE::template TypeOf< 6>::TypeOrDefault Type6;
7175 typedef typename t_BOUND_TUPLE::template TypeOf< 7>::TypeOrDefault Type7;
7176 typedef typename t_BOUND_TUPLE::template TypeOf< 8>::TypeOrDefault Type8;
7177 typedef typename t_BOUND_TUPLE::template TypeOf< 9>::TypeOrDefault Type9;
7178 typedef typename t_BOUND_TUPLE::template TypeOf<10>::TypeOrDefault Type10;
7179 typedef typename t_BOUND_TUPLE::template TypeOf<11>::TypeOrDefault Type11;
7180 typedef typename t_BOUND_TUPLE::template TypeOf<12>::TypeOrDefault Type12;
7181 typedef typename t_BOUND_TUPLE::template TypeOf<13>::TypeOrDefault Type13;
7182 typedef typename t_BOUND_TUPLE::template TypeOf<14>::TypeOrDefault Type14;
7183
7184 enum {
7185 k_PARAM1 = Bind_PlaceHolderIndex<Type1 >::k_VAL
7186 , k_PARAM2 = Bind_PlaceHolderIndex<Type2 >::k_VAL
7187 , k_PARAM3 = Bind_PlaceHolderIndex<Type3 >::k_VAL
7188 , k_PARAM4 = Bind_PlaceHolderIndex<Type4 >::k_VAL
7189 , k_PARAM5 = Bind_PlaceHolderIndex<Type5 >::k_VAL
7190 , k_PARAM6 = Bind_PlaceHolderIndex<Type6 >::k_VAL
7191 , k_PARAM7 = Bind_PlaceHolderIndex<Type7 >::k_VAL
7192 , k_PARAM8 = Bind_PlaceHolderIndex<Type8 >::k_VAL
7193 , k_PARAM9 = Bind_PlaceHolderIndex<Type9 >::k_VAL
7194 , k_PARAM10 = Bind_PlaceHolderIndex<Type10>::k_VAL
7195 , k_PARAM11 = Bind_PlaceHolderIndex<Type11>::k_VAL
7196 , k_PARAM12 = Bind_PlaceHolderIndex<Type12>::k_VAL
7197 , k_PARAM13 = Bind_PlaceHolderIndex<Type13>::k_VAL
7198 , k_PARAM14 = Bind_PlaceHolderIndex<Type14>::k_VAL
7199 // Individual place-holder indices. For each type that is a valid
7200 // place-holder, 'PARAM<N>' will be set to the index of the
7201 // corresponding argument. For non-place-holder types, 'PARAM<N>' will
7202 // be 0. For nested 'Bind' types, the out-of-range value 31 will be
7203 // used.
7204
7205 , k_PARAM_MASK = +Bind_PlaceHolderMask<Type1 >::k_VAL |
7206 +Bind_PlaceHolderMask<Type2 >::k_VAL |
7207 +Bind_PlaceHolderMask<Type3 >::k_VAL |
7208 +Bind_PlaceHolderMask<Type4 >::k_VAL |
7209 +Bind_PlaceHolderMask<Type5 >::k_VAL |
7210 +Bind_PlaceHolderMask<Type6 >::k_VAL |
7211 +Bind_PlaceHolderMask<Type7 >::k_VAL |
7212 +Bind_PlaceHolderMask<Type8 >::k_VAL |
7213 +Bind_PlaceHolderMask<Type9 >::k_VAL |
7214 +Bind_PlaceHolderMask<Type10>::k_VAL |
7215 +Bind_PlaceHolderMask<Type11>::k_VAL |
7216 +Bind_PlaceHolderMask<Type12>::k_VAL |
7217 +Bind_PlaceHolderMask<Type13>::k_VAL |
7218 +Bind_PlaceHolderMask<Type14>::k_VAL
7219 // Mask of which parameters are place-holders.
7220
7221 , k_PARAM_MASK2 = +Bind_PlaceHolderMask<Type1 >::k_VAL +
7222 +Bind_PlaceHolderMask<Type2 >::k_VAL +
7223 +Bind_PlaceHolderMask<Type3 >::k_VAL +
7224 +Bind_PlaceHolderMask<Type4 >::k_VAL +
7225 +Bind_PlaceHolderMask<Type5 >::k_VAL +
7226 +Bind_PlaceHolderMask<Type6 >::k_VAL +
7227 +Bind_PlaceHolderMask<Type7 >::k_VAL +
7228 +Bind_PlaceHolderMask<Type8 >::k_VAL +
7229 +Bind_PlaceHolderMask<Type9 >::k_VAL +
7230 +Bind_PlaceHolderMask<Type10>::k_VAL +
7231 +Bind_PlaceHolderMask<Type11>::k_VAL +
7232 +Bind_PlaceHolderMask<Type12>::k_VAL +
7233 +Bind_PlaceHolderMask<Type13>::k_VAL +
7234 +Bind_PlaceHolderMask<Type14>::k_VAL
7235 // Mask of which parameters are place-holder calculated by addition
7236 // rather the by ORing. If the given place-holder is used for multiple
7237 // arguments, the result of mask will be different from the ORed value
7238 // above.
7239
7240 , k_IS_EXPLICIT = (k_PARAM_MASK == k_PARAM_MASK2 ?
7241 (k_PARAM_MASK < (1<<15) ? 1 : 0) : 0)
7242 // Indicates if the types defined in 't_BOUND_TUPLE' are explicit. The
7243 // t_BOUND_TUPLE is said to be explicit if there are no duplicate
7244 // references to the same place-holder, and if there is no nested
7245 // 'Bind' objects. Note that even if 't_BOUND_TUPLE' is explicit, the
7246 // binding may still not be explicit (e.g., for function objects that
7247 // could have multiple signatures, or for functions that take an
7248 // ellipsis). See the documentation for this component for more
7249 // information.
7250
7251 , k_PARAMINDEX1 = BDLF_BIND_PARAMINDEX( 1)
7252 , k_PARAMINDEX2 = BDLF_BIND_PARAMINDEX( 2)
7253 , k_PARAMINDEX3 = BDLF_BIND_PARAMINDEX( 3)
7254 , k_PARAMINDEX4 = BDLF_BIND_PARAMINDEX( 4)
7255 , k_PARAMINDEX5 = BDLF_BIND_PARAMINDEX( 5)
7256 , k_PARAMINDEX6 = BDLF_BIND_PARAMINDEX( 6)
7257 , k_PARAMINDEX7 = BDLF_BIND_PARAMINDEX( 7)
7258 , k_PARAMINDEX8 = BDLF_BIND_PARAMINDEX( 8)
7259 , k_PARAMINDEX9 = BDLF_BIND_PARAMINDEX( 9)
7260 , k_PARAMINDEX10 = BDLF_BIND_PARAMINDEX(10)
7261 , k_PARAMINDEX11 = BDLF_BIND_PARAMINDEX(11)
7262 , k_PARAMINDEX12 = BDLF_BIND_PARAMINDEX(12)
7263 , k_PARAMINDEX13 = BDLF_BIND_PARAMINDEX(13)
7264 , k_PARAMINDEX14 = BDLF_BIND_PARAMINDEX(14)
7265 };
7266};
7267} // close package namespace
7268
7269#undef BDLF_BIND_PARAMINDEX
7270
7271namespace bdlf {
7272
7273 // ======================
7274 // class Bind_BoundTuple*
7275 // ======================
7276
7277/// This `struct` stores a list of two arguments. It does *not* use the
7278/// const-forwarding type of its argument, unlike `Bind_ArgTuple2` which
7279/// applies that optimization to avoid unnecessary copying.
7280template <class A1, class A2>
7281struct Bind_BoundTuple2 : bslmf::TypeList2<A1,A2>
7282{
7283
7284 // TRAITS
7285 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7286 Bind_BoundTuple2, bslmf::IsBitwiseMoveable,
7287 bslmf::IsBitwiseMoveable<A1>::value &&
7288 bslmf::IsBitwiseMoveable<A2>::value);
7289
7290 // INSTANCE DATA
7291 Bind_BoundTupleValue<A1> d_a1;
7292 Bind_BoundTupleValue<A2> d_a2;
7293
7294 // CREATORS
7295 Bind_BoundTuple2(const Bind_BoundTuple2<A1,A2>& orig,
7296 bslma::Allocator *allocator = 0)
7297 : d_a1(orig.d_a1, allocator)
7298 , d_a2(orig.d_a2, allocator)
7299 {
7300 }
7301
7302 Bind_BoundTuple2(
7303 bslmf::MovableRef<Bind_BoundTuple2<A1,A2> > orig,
7304 bslma::Allocator *allocator = 0)
7305 : d_a1(bslmf::MovableRefUtil::move(
7306 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7307 , d_a2(bslmf::MovableRefUtil::move(
7308 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7309 {
7310 }
7311
7312 Bind_BoundTuple2(A1 const& a1,
7313 A2 const& a2,
7314 bslma::Allocator *allocator = 0)
7315 : d_a1(a1, allocator)
7316 , d_a2(a2, allocator)
7317 {
7318 }
7319
7320 Bind_BoundTuple2(bslmf::MovableRef<A1> a1,
7321 bslmf::MovableRef<A2> a2,
7322 bslma::Allocator *allocator = 0)
7323 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7324 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7325 {
7326 }
7327};
7328
7329/// This `struct` stores a list of three arguments. It does *not* use the
7330/// const-forwarding type of its arguments, unlike `Bind_ArgTuple3` which
7331/// applies that optimization to avoid unnecessary copying.
7332template <class A1, class A2, class A3>
7333struct Bind_BoundTuple3 : bslmf::TypeList3<A1,A2,A3>
7334{
7335
7336 // TRAITS
7337 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7338 Bind_BoundTuple3, bslmf::IsBitwiseMoveable,
7339 bslmf::IsBitwiseMoveable<A1>::value &&
7340 bslmf::IsBitwiseMoveable<A2>::value &&
7341 bslmf::IsBitwiseMoveable<A3>::value);
7342
7343 // INSTANCE DATA
7344 Bind_BoundTupleValue<A1> d_a1;
7345 Bind_BoundTupleValue<A2> d_a2;
7346 Bind_BoundTupleValue<A3> d_a3;
7347
7348 // CREATORS
7349 Bind_BoundTuple3(const Bind_BoundTuple3<A1,A2,A3>& orig,
7350 bslma::Allocator *allocator = 0)
7351 : d_a1(orig.d_a1,allocator)
7352 , d_a2(orig.d_a2,allocator)
7353 , d_a3(orig.d_a3,allocator)
7354 {
7355 }
7356
7357 Bind_BoundTuple3(
7358 bslmf::MovableRef<Bind_BoundTuple3<A1,A2,A3> > orig,
7359 bslma::Allocator *allocator = 0)
7360 : d_a1(bslmf::MovableRefUtil::move(
7361 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7362 , d_a2(bslmf::MovableRefUtil::move(
7363 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7364 , d_a3(bslmf::MovableRefUtil::move(
7365 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7366 {
7367 }
7368
7369 Bind_BoundTuple3(A1 const& a1,
7370 A2 const& a2,
7371 A3 const& a3,
7372 bslma::Allocator *allocator = 0)
7373 : d_a1(a1,allocator)
7374 , d_a2(a2,allocator)
7375 , d_a3(a3,allocator)
7376 {
7377 }
7378
7379 Bind_BoundTuple3(bslmf::MovableRef<A1> a1,
7380 bslmf::MovableRef<A2> a2,
7381 bslmf::MovableRef<A3> a3,
7382 bslma::Allocator *allocator = 0)
7383 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7384 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7385 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7386 {
7387 }
7388};
7389
7390/// This `struct` stores a list of four arguments. It does *not* use the
7391/// const-forwarding type of its arguments, unlike `Bind_ArgTuple4` which
7392/// applies that optimization to avoid unnecessary copying.
7393template <class A1, class A2, class A3, class A4>
7394struct Bind_BoundTuple4 : bslmf::TypeList4<A1,A2,A3,A4>
7395{
7396
7397 // TRAITS
7398 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7399 Bind_BoundTuple4, bslmf::IsBitwiseMoveable,
7400 bslmf::IsBitwiseMoveable<A1>::value &&
7401 bslmf::IsBitwiseMoveable<A2>::value &&
7402 bslmf::IsBitwiseMoveable<A3>::value &&
7403 bslmf::IsBitwiseMoveable<A4>::value);
7404
7405 // INSTANCE DATA
7406 Bind_BoundTupleValue<A1> d_a1;
7407 Bind_BoundTupleValue<A2> d_a2;
7408 Bind_BoundTupleValue<A3> d_a3;
7409 Bind_BoundTupleValue<A4> d_a4;
7410
7411 // CREATORS
7412 Bind_BoundTuple4(const Bind_BoundTuple4<A1,A2,A3,A4>& orig,
7413 bslma::Allocator *allocator = 0)
7414 : d_a1(orig.d_a1,allocator)
7415 , d_a2(orig.d_a2,allocator)
7416 , d_a3(orig.d_a3,allocator)
7417 , d_a4(orig.d_a4,allocator)
7418 {
7419 }
7420
7421 Bind_BoundTuple4(
7422 bslmf::MovableRef<Bind_BoundTuple4<A1,A2,A3,A4> > orig,
7423 bslma::Allocator *allocator = 0)
7424 : d_a1(bslmf::MovableRefUtil::move(
7425 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7426 , d_a2(bslmf::MovableRefUtil::move(
7427 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7428 , d_a3(bslmf::MovableRefUtil::move(
7429 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7430 , d_a4(bslmf::MovableRefUtil::move(
7431 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7432 {
7433 }
7434
7435 Bind_BoundTuple4(A1 const& a1,
7436 A2 const& a2,
7437 A3 const& a3,
7438 A4 const& a4,
7439 bslma::Allocator *allocator = 0)
7440 : d_a1(a1,allocator)
7441 , d_a2(a2,allocator)
7442 , d_a3(a3,allocator)
7443 , d_a4(a4,allocator)
7444 {
7445 }
7446
7447 Bind_BoundTuple4(bslmf::MovableRef<A1> a1,
7448 bslmf::MovableRef<A2> a2,
7449 bslmf::MovableRef<A3> a3,
7450 bslmf::MovableRef<A4> a4,
7451 bslma::Allocator *allocator = 0)
7452 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7453 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7454 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7455 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7456 {
7457 }
7458};
7459
7460/// This `struct` stores a list of five arguments. It does *not* use the
7461/// const-forwarding type of its arguments, unlike `Bind_ArgTuple5` which
7462/// applies that optimization to avoid unnecessary copying.
7463template <class A1, class A2, class A3, class A4, class A5>
7464struct Bind_BoundTuple5 : bslmf::TypeList5<A1,A2,A3,A4,A5>
7465{
7466
7467 // TRAITS
7468 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7469 Bind_BoundTuple5, bslmf::IsBitwiseMoveable,
7470 bslmf::IsBitwiseMoveable<A1>::value &&
7471 bslmf::IsBitwiseMoveable<A2>::value &&
7472 bslmf::IsBitwiseMoveable<A3>::value &&
7473 bslmf::IsBitwiseMoveable<A4>::value &&
7474 bslmf::IsBitwiseMoveable<A5>::value);
7475
7476 // INSTANCE DATA
7477 Bind_BoundTupleValue<A1> d_a1;
7478 Bind_BoundTupleValue<A2> d_a2;
7479 Bind_BoundTupleValue<A3> d_a3;
7480 Bind_BoundTupleValue<A4> d_a4;
7481 Bind_BoundTupleValue<A5> d_a5;
7482
7483 // CREATORS
7484 Bind_BoundTuple5(const Bind_BoundTuple5<A1,A2,A3,A4,A5>& orig,
7485 bslma::Allocator *allocator = 0)
7486 : d_a1(orig.d_a1,allocator)
7487 , d_a2(orig.d_a2,allocator)
7488 , d_a3(orig.d_a3,allocator)
7489 , d_a4(orig.d_a4,allocator)
7490 , d_a5(orig.d_a5,allocator)
7491 {
7492 }
7493
7494 Bind_BoundTuple5(
7495 bslmf::MovableRef<Bind_BoundTuple5<A1,A2,A3,A4,A5> > orig,
7496 bslma::Allocator *allocator = 0)
7497 : d_a1(bslmf::MovableRefUtil::move(
7498 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7499 , d_a2(bslmf::MovableRefUtil::move(
7500 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7501 , d_a3(bslmf::MovableRefUtil::move(
7502 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7503 , d_a4(bslmf::MovableRefUtil::move(
7504 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7505 , d_a5(bslmf::MovableRefUtil::move(
7506 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7507 {
7508 }
7509
7510 Bind_BoundTuple5(A1 const& a1,
7511 A2 const& a2,
7512 A3 const& a3,
7513 A4 const& a4,
7514 A5 const& a5,
7515 bslma::Allocator *allocator = 0)
7516 : d_a1(a1,allocator)
7517 , d_a2(a2,allocator)
7518 , d_a3(a3,allocator)
7519 , d_a4(a4,allocator)
7520 , d_a5(a5,allocator)
7521 {
7522 }
7523
7524 Bind_BoundTuple5(bslmf::MovableRef<A1> a1,
7525 bslmf::MovableRef<A2> a2,
7526 bslmf::MovableRef<A3> a3,
7527 bslmf::MovableRef<A4> a4,
7528 bslmf::MovableRef<A5> a5,
7529 bslma::Allocator *allocator = 0)
7530 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7531 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7532 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7533 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7534 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7535 {
7536 }
7537};
7538
7539/// This `struct` stores a list of six arguments. It does *not* use the
7540/// const-forwarding type of its arguments, unlike `Bind_ArgTuple6` which
7541/// applies that optimization to avoid unnecessary copying.
7542template <class A1, class A2, class A3, class A4, class A5, class A6>
7543struct Bind_BoundTuple6 : bslmf::TypeList6<A1,A2,A3,A4,A5,A6>
7544{
7545
7546 // TRAITS
7547 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7548 Bind_BoundTuple6, bslmf::IsBitwiseMoveable,
7549 bslmf::IsBitwiseMoveable<A1>::value &&
7550 bslmf::IsBitwiseMoveable<A2>::value &&
7551 bslmf::IsBitwiseMoveable<A3>::value &&
7552 bslmf::IsBitwiseMoveable<A4>::value &&
7553 bslmf::IsBitwiseMoveable<A5>::value &&
7554 bslmf::IsBitwiseMoveable<A6>::value);
7555
7556 // INSTANCE DATA
7557 Bind_BoundTupleValue<A1> d_a1;
7558 Bind_BoundTupleValue<A2> d_a2;
7559 Bind_BoundTupleValue<A3> d_a3;
7560 Bind_BoundTupleValue<A4> d_a4;
7561 Bind_BoundTupleValue<A5> d_a5;
7562 Bind_BoundTupleValue<A6> d_a6;
7563
7564 // CREATORS
7565 Bind_BoundTuple6(const Bind_BoundTuple6<A1,A2,A3,A4,A5,A6>& orig,
7566 bslma::Allocator *allocator = 0)
7567 : d_a1(orig.d_a1,allocator)
7568 , d_a2(orig.d_a2,allocator)
7569 , d_a3(orig.d_a3,allocator)
7570 , d_a4(orig.d_a4,allocator)
7571 , d_a5(orig.d_a5,allocator)
7572 , d_a6(orig.d_a6,allocator)
7573 {
7574 }
7575
7576 Bind_BoundTuple6(
7577 bslmf::MovableRef<
7578 Bind_BoundTuple6<A1,A2,A3,A4,A5,A6> > orig,
7579 bslma::Allocator *allocator = 0)
7580 : d_a1(bslmf::MovableRefUtil::move(
7581 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7582 , d_a2(bslmf::MovableRefUtil::move(
7583 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7584 , d_a3(bslmf::MovableRefUtil::move(
7585 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7586 , d_a4(bslmf::MovableRefUtil::move(
7587 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7588 , d_a5(bslmf::MovableRefUtil::move(
7589 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7590 , d_a6(bslmf::MovableRefUtil::move(
7591 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7592 {
7593 }
7594
7595 Bind_BoundTuple6(A1 const& a1,
7596 A2 const& a2,
7597 A3 const& a3,
7598 A4 const& a4,
7599 A5 const& a5,
7600 A6 const& a6,
7601 bslma::Allocator *allocator = 0)
7602 : d_a1(a1,allocator)
7603 , d_a2(a2,allocator)
7604 , d_a3(a3,allocator)
7605 , d_a4(a4,allocator)
7606 , d_a5(a5,allocator)
7607 , d_a6(a6,allocator)
7608 {
7609 }
7610
7611 Bind_BoundTuple6(bslmf::MovableRef<A1> a1,
7612 bslmf::MovableRef<A2> a2,
7613 bslmf::MovableRef<A3> a3,
7614 bslmf::MovableRef<A4> a4,
7615 bslmf::MovableRef<A5> a5,
7616 bslmf::MovableRef<A6> a6,
7617 bslma::Allocator *allocator = 0)
7618 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7619 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7620 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7621 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7622 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7623 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7624 {
7625 }
7626};
7627
7628/// This `struct` stores a list of seven arguments. It does *not* use the
7629/// const-forwarding type of its arguments, unlike `Bind_ArgTuple7` which
7630/// applies that optimization to avoid unnecessary copying.
7631template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
7632struct Bind_BoundTuple7 : bslmf::TypeList7<A1,A2,A3,A4,A5,A6,A7>
7633{
7634
7635 // TRAITS
7636 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7637 Bind_BoundTuple7, bslmf::IsBitwiseMoveable,
7638 bslmf::IsBitwiseMoveable<A1>::value &&
7639 bslmf::IsBitwiseMoveable<A2>::value &&
7640 bslmf::IsBitwiseMoveable<A3>::value &&
7641 bslmf::IsBitwiseMoveable<A4>::value &&
7642 bslmf::IsBitwiseMoveable<A5>::value &&
7643 bslmf::IsBitwiseMoveable<A6>::value &&
7644 bslmf::IsBitwiseMoveable<A7>::value);
7645
7646 // INSTANCE DATA
7647 Bind_BoundTupleValue<A1> d_a1;
7648 Bind_BoundTupleValue<A2> d_a2;
7649 Bind_BoundTupleValue<A3> d_a3;
7650 Bind_BoundTupleValue<A4> d_a4;
7651 Bind_BoundTupleValue<A5> d_a5;
7652 Bind_BoundTupleValue<A6> d_a6;
7653 Bind_BoundTupleValue<A7> d_a7;
7654
7655 // CREATORS
7656 Bind_BoundTuple7(
7657 const Bind_BoundTuple7<A1,A2,A3,A4,A5,A6,A7>& orig,
7658 bslma::Allocator *allocator = 0)
7659 : d_a1(orig.d_a1,allocator)
7660 , d_a2(orig.d_a2,allocator)
7661 , d_a3(orig.d_a3,allocator)
7662 , d_a4(orig.d_a4,allocator)
7663 , d_a5(orig.d_a5,allocator)
7664 , d_a6(orig.d_a6,allocator)
7665 , d_a7(orig.d_a7,allocator)
7666 {
7667 }
7668
7669 Bind_BoundTuple7(
7670 bslmf::MovableRef<
7671 Bind_BoundTuple7<A1,A2,A3,A4,A5,A6,A7> > orig,
7672 bslma::Allocator *allocator = 0)
7673 : d_a1(bslmf::MovableRefUtil::move(
7674 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7675 , d_a2(bslmf::MovableRefUtil::move(
7676 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7677 , d_a3(bslmf::MovableRefUtil::move(
7678 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7679 , d_a4(bslmf::MovableRefUtil::move(
7680 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7681 , d_a5(bslmf::MovableRefUtil::move(
7682 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7683 , d_a6(bslmf::MovableRefUtil::move(
7684 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7685 , d_a7(bslmf::MovableRefUtil::move(
7686 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7687 {
7688 }
7689
7690 Bind_BoundTuple7(A1 const& a1,
7691 A2 const& a2,
7692 A3 const& a3,
7693 A4 const& a4,
7694 A5 const& a5,
7695 A6 const& a6,
7696 A7 const& a7,
7697 bslma::Allocator *allocator = 0)
7698 : d_a1(a1,allocator)
7699 , d_a2(a2,allocator)
7700 , d_a3(a3,allocator)
7701 , d_a4(a4,allocator)
7702 , d_a5(a5,allocator)
7703 , d_a6(a6,allocator)
7704 , d_a7(a7,allocator)
7705 {
7706 }
7707
7708 Bind_BoundTuple7(bslmf::MovableRef<A1> a1,
7709 bslmf::MovableRef<A2> a2,
7710 bslmf::MovableRef<A3> a3,
7711 bslmf::MovableRef<A4> a4,
7712 bslmf::MovableRef<A5> a5,
7713 bslmf::MovableRef<A6> a6,
7714 bslmf::MovableRef<A7> a7,
7715 bslma::Allocator *allocator = 0)
7716 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7717 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7718 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7719 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7720 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7721 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7722 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7723 {
7724 }
7725};
7726
7727/// This `struct` stores a list of eight arguments. It does *not* use the
7728/// const-forwarding type of its arguments, unlike `Bind_ArgTuple8` which
7729/// applies that optimization to avoid unnecessary copying.
7730template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7731 class A8>
7732struct Bind_BoundTuple8 : bslmf::TypeList8<A1,A2,A3,A4,A5,A6,A7,A8>
7733{
7734
7735 // TRAITS
7736 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7737 Bind_BoundTuple8, bslmf::IsBitwiseMoveable,
7738 bslmf::IsBitwiseMoveable<A1>::value &&
7739 bslmf::IsBitwiseMoveable<A2>::value &&
7740 bslmf::IsBitwiseMoveable<A3>::value &&
7741 bslmf::IsBitwiseMoveable<A4>::value &&
7742 bslmf::IsBitwiseMoveable<A5>::value &&
7743 bslmf::IsBitwiseMoveable<A6>::value &&
7744 bslmf::IsBitwiseMoveable<A7>::value &&
7745 bslmf::IsBitwiseMoveable<A8>::value);
7746
7747 // INSTANCE DATA
7748 Bind_BoundTupleValue<A1> d_a1;
7749 Bind_BoundTupleValue<A2> d_a2;
7750 Bind_BoundTupleValue<A3> d_a3;
7751 Bind_BoundTupleValue<A4> d_a4;
7752 Bind_BoundTupleValue<A5> d_a5;
7753 Bind_BoundTupleValue<A6> d_a6;
7754 Bind_BoundTupleValue<A7> d_a7;
7755 Bind_BoundTupleValue<A8> d_a8;
7756
7757 // CREATORS
7758 Bind_BoundTuple8(
7759 const Bind_BoundTuple8<A1,A2,A3,A4,A5,A6,A7,A8>& orig,
7760 bslma::Allocator *allocator = 0)
7761 : d_a1(orig.d_a1,allocator)
7762 , d_a2(orig.d_a2,allocator)
7763 , d_a3(orig.d_a3,allocator)
7764 , d_a4(orig.d_a4,allocator)
7765 , d_a5(orig.d_a5,allocator)
7766 , d_a6(orig.d_a6,allocator)
7767 , d_a7(orig.d_a7,allocator)
7768 , d_a8(orig.d_a8,allocator)
7769 {
7770 }
7771
7772 Bind_BoundTuple8(
7773 bslmf::MovableRef<
7774 Bind_BoundTuple8<A1,A2,A3,A4,A5,A6,A7,A8> > orig,
7775 bslma::Allocator *allocator = 0)
7776 : d_a1(bslmf::MovableRefUtil::move(
7777 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7778 , d_a2(bslmf::MovableRefUtil::move(
7779 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7780 , d_a3(bslmf::MovableRefUtil::move(
7781 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7782 , d_a4(bslmf::MovableRefUtil::move(
7783 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7784 , d_a5(bslmf::MovableRefUtil::move(
7785 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7786 , d_a6(bslmf::MovableRefUtil::move(
7787 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7788 , d_a7(bslmf::MovableRefUtil::move(
7789 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7790 , d_a8(bslmf::MovableRefUtil::move(
7791 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
7792 {
7793 }
7794
7795 Bind_BoundTuple8(A1 const& a1,
7796 A2 const& a2,
7797 A3 const& a3,
7798 A4 const& a4,
7799 A5 const& a5,
7800 A6 const& a6,
7801 A7 const& a7,
7802 A8 const& a8,
7803 bslma::Allocator *allocator = 0)
7804 : d_a1(a1,allocator)
7805 , d_a2(a2,allocator)
7806 , d_a3(a3,allocator)
7807 , d_a4(a4,allocator)
7808 , d_a5(a5,allocator)
7809 , d_a6(a6,allocator)
7810 , d_a7(a7,allocator)
7811 , d_a8(a8,allocator)
7812 {
7813 }
7814
7815 Bind_BoundTuple8(bslmf::MovableRef<A1> a1,
7816 bslmf::MovableRef<A2> a2,
7817 bslmf::MovableRef<A3> a3,
7818 bslmf::MovableRef<A4> a4,
7819 bslmf::MovableRef<A5> a5,
7820 bslmf::MovableRef<A6> a6,
7821 bslmf::MovableRef<A7> a7,
7822 bslmf::MovableRef<A8> a8,
7823 bslma::Allocator *allocator = 0)
7824 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7825 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7826 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7827 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7828 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7829 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7830 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7831 , d_a8(bslmf::MovableRefUtil::move(a8), allocator)
7832 {
7833 }
7834};
7835
7836/// This `struct` stores a list of nine arguments. It does *not* use the
7837/// const-forwarding type of its arguments, unlike `Bind_ArgTuple9` which
7838/// applies that optimization to avoid unnecessary copying.
7839template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7840 class A8, class A9>
7841struct Bind_BoundTuple9 : bslmf::TypeList9<A1,A2,A3,A4,A5,A6,A7,A8,A9>
7842{
7843
7844 // TRAITS
7845 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7846 Bind_BoundTuple9, bslmf::IsBitwiseMoveable,
7847 bslmf::IsBitwiseMoveable<A1>::value &&
7848 bslmf::IsBitwiseMoveable<A2>::value &&
7849 bslmf::IsBitwiseMoveable<A3>::value &&
7850 bslmf::IsBitwiseMoveable<A4>::value &&
7851 bslmf::IsBitwiseMoveable<A5>::value &&
7852 bslmf::IsBitwiseMoveable<A6>::value &&
7853 bslmf::IsBitwiseMoveable<A7>::value &&
7854 bslmf::IsBitwiseMoveable<A8>::value &&
7855 bslmf::IsBitwiseMoveable<A9>::value);
7856
7857 // INSTANCE DATA
7858 Bind_BoundTupleValue<A1> d_a1;
7859 Bind_BoundTupleValue<A2> d_a2;
7860 Bind_BoundTupleValue<A3> d_a3;
7861 Bind_BoundTupleValue<A4> d_a4;
7862 Bind_BoundTupleValue<A5> d_a5;
7863 Bind_BoundTupleValue<A6> d_a6;
7864 Bind_BoundTupleValue<A7> d_a7;
7865 Bind_BoundTupleValue<A8> d_a8;
7866 Bind_BoundTupleValue<A9> d_a9;
7867
7868 // CREATORS
7869 Bind_BoundTuple9(
7870 const Bind_BoundTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9>& orig,
7871 bslma::Allocator *allocator = 0)
7872 : d_a1(orig.d_a1,allocator)
7873 , d_a2(orig.d_a2,allocator)
7874 , d_a3(orig.d_a3,allocator)
7875 , d_a4(orig.d_a4,allocator)
7876 , d_a5(orig.d_a5,allocator)
7877 , d_a6(orig.d_a6,allocator)
7878 , d_a7(orig.d_a7,allocator)
7879 , d_a8(orig.d_a8,allocator)
7880 , d_a9(orig.d_a9,allocator)
7881 {
7882 }
7883
7884 Bind_BoundTuple9(
7885 bslmf::MovableRef<
7886 Bind_BoundTuple9<A1,A2,A3,A4,A5,A6,A7,A8,A9> > orig,
7887 bslma::Allocator *allocator = 0)
7888 : d_a1(bslmf::MovableRefUtil::move(
7889 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
7890 , d_a2(bslmf::MovableRefUtil::move(
7891 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
7892 , d_a3(bslmf::MovableRefUtil::move(
7893 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
7894 , d_a4(bslmf::MovableRefUtil::move(
7895 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
7896 , d_a5(bslmf::MovableRefUtil::move(
7897 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
7898 , d_a6(bslmf::MovableRefUtil::move(
7899 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
7900 , d_a7(bslmf::MovableRefUtil::move(
7901 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
7902 , d_a8(bslmf::MovableRefUtil::move(
7903 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
7904 , d_a9(bslmf::MovableRefUtil::move(
7905 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
7906 {
7907 }
7908
7909 Bind_BoundTuple9(A1 const& a1,
7910 A2 const& a2,
7911 A3 const& a3,
7912 A4 const& a4,
7913 A5 const& a5,
7914 A6 const& a6,
7915 A7 const& a7,
7916 A8 const& a8,
7917 A9 const& a9,
7918 bslma::Allocator *allocator = 0)
7919 : d_a1(a1,allocator)
7920 , d_a2(a2,allocator)
7921 , d_a3(a3,allocator)
7922 , d_a4(a4,allocator)
7923 , d_a5(a5,allocator)
7924 , d_a6(a6,allocator)
7925 , d_a7(a7,allocator)
7926 , d_a8(a8,allocator)
7927 , d_a9(a9,allocator)
7928 {
7929 }
7930
7931 Bind_BoundTuple9(bslmf::MovableRef<A1> a1,
7932 bslmf::MovableRef<A2> a2,
7933 bslmf::MovableRef<A3> a3,
7934 bslmf::MovableRef<A4> a4,
7935 bslmf::MovableRef<A5> a5,
7936 bslmf::MovableRef<A6> a6,
7937 bslmf::MovableRef<A7> a7,
7938 bslmf::MovableRef<A8> a8,
7939 bslmf::MovableRef<A9> a9,
7940 bslma::Allocator *allocator = 0)
7941 : d_a1(bslmf::MovableRefUtil::move(a1), allocator)
7942 , d_a2(bslmf::MovableRefUtil::move(a2), allocator)
7943 , d_a3(bslmf::MovableRefUtil::move(a3), allocator)
7944 , d_a4(bslmf::MovableRefUtil::move(a4), allocator)
7945 , d_a5(bslmf::MovableRefUtil::move(a5), allocator)
7946 , d_a6(bslmf::MovableRefUtil::move(a6), allocator)
7947 , d_a7(bslmf::MovableRefUtil::move(a7), allocator)
7948 , d_a8(bslmf::MovableRefUtil::move(a8), allocator)
7949 , d_a9(bslmf::MovableRefUtil::move(a9), allocator)
7950 {
7951 }
7952};
7953
7954/// This `struct` stores a list of ten arguments. It does *not* use the
7955/// const-forwarding type of its arguments, unlike `Bind_ArgTuple10` which
7956/// applies that optimization to avoid unnecessary copying.
7957template <class A1, class A2, class A3, class A4, class A5, class A6, class A7,
7958 class A8, class A9, class A10>
7959struct Bind_BoundTuple10 : bslmf::TypeList10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>
7960{
7961
7962 // TRAITS
7963 BSLMF_NESTED_TRAIT_DECLARATION_IF(
7964 Bind_BoundTuple10, bslmf::IsBitwiseMoveable,
7965 bslmf::IsBitwiseMoveable<A1>::value &&
7966 bslmf::IsBitwiseMoveable<A2>::value &&
7967 bslmf::IsBitwiseMoveable<A3>::value &&
7968 bslmf::IsBitwiseMoveable<A4>::value &&
7969 bslmf::IsBitwiseMoveable<A5>::value &&
7970 bslmf::IsBitwiseMoveable<A6>::value &&
7971 bslmf::IsBitwiseMoveable<A7>::value &&
7972 bslmf::IsBitwiseMoveable<A8>::value &&
7973 bslmf::IsBitwiseMoveable<A9>::value &&
7974 bslmf::IsBitwiseMoveable<A10>::value);
7975
7976 // INSTANCE DATA
7977 Bind_BoundTupleValue<A1> d_a1;
7978 Bind_BoundTupleValue<A2> d_a2;
7979 Bind_BoundTupleValue<A3> d_a3;
7980 Bind_BoundTupleValue<A4> d_a4;
7981 Bind_BoundTupleValue<A5> d_a5;
7982 Bind_BoundTupleValue<A6> d_a6;
7983 Bind_BoundTupleValue<A7> d_a7;
7984 Bind_BoundTupleValue<A8> d_a8;
7985 Bind_BoundTupleValue<A9> d_a9;
7986 Bind_BoundTupleValue<A10> d_a10;
7987
7988 // CREATORS
7989 Bind_BoundTuple10(
7990 const Bind_BoundTuple10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10>& orig,
7991 bslma::Allocator *allocator = 0)
7992 : d_a1(orig.d_a1,allocator)
7993 , d_a2(orig.d_a2,allocator)
7994 , d_a3(orig.d_a3,allocator)
7995 , d_a4(orig.d_a4,allocator)
7996 , d_a5(orig.d_a5,allocator)
7997 , d_a6(orig.d_a6,allocator)
7998 , d_a7(orig.d_a7,allocator)
7999 , d_a8(orig.d_a8,allocator)
8000 , d_a9(orig.d_a9,allocator)
8001 , d_a10(orig.d_a10,allocator)
8002 {
8003 }
8004
8005 Bind_BoundTuple10(
8006 bslmf::MovableRef<
8007 Bind_BoundTuple10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> > orig,
8008 bslma::Allocator *allocator = 0)
8009 : d_a1(bslmf::MovableRefUtil::move(
8010 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8011 , d_a2(bslmf::MovableRefUtil::move(
8012 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8013 , d_a3(bslmf::MovableRefUtil::move(
8014 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8015 , d_a4(bslmf::MovableRefUtil::move(
8016 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8017 , d_a5(bslmf::MovableRefUtil::move(
8018 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8019 , d_a6(bslmf::MovableRefUtil::move(
8020 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8021 , d_a7(bslmf::MovableRefUtil::move(
8022 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8023 , d_a8(bslmf::MovableRefUtil::move(
8024 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8025 , d_a9(bslmf::MovableRefUtil::move(
8026 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8027 , d_a10(bslmf::MovableRefUtil::move(
8028 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8029 {
8030 }
8031
8032 Bind_BoundTuple10(A1 const& a1,
8033 A2 const& a2,
8034 A3 const& a3,
8035 A4 const& a4,
8036 A5 const& a5,
8037 A6 const& a6,
8038 A7 const& a7,
8039 A8 const& a8,
8040 A9 const& a9,
8041 A10 const& a10,
8042 bslma::Allocator *allocator = 0)
8043 : d_a1(a1,allocator)
8044 , d_a2(a2,allocator)
8045 , d_a3(a3,allocator)
8046 , d_a4(a4,allocator)
8047 , d_a5(a5,allocator)
8048 , d_a6(a6,allocator)
8049 , d_a7(a7,allocator)
8050 , d_a8(a8,allocator)
8051 , d_a9(a9,allocator)
8052 , d_a10(a10,allocator)
8053 {
8054 }
8055
8056 Bind_BoundTuple10(bslmf::MovableRef<A1> a1,
8057 bslmf::MovableRef<A2> a2,
8058 bslmf::MovableRef<A3> a3,
8059 bslmf::MovableRef<A4> a4,
8060 bslmf::MovableRef<A5> a5,
8061 bslmf::MovableRef<A6> a6,
8062 bslmf::MovableRef<A7> a7,
8063 bslmf::MovableRef<A8> a8,
8064 bslmf::MovableRef<A9> a9,
8065 bslmf::MovableRef<A10> a10,
8066 bslma::Allocator *allocator = 0)
8067 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8068 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8069 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8070 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8071 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8072 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8073 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8074 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8075 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8076 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8077 {
8078 }
8079};
8080
8081/// This `struct` stores a list of eleven arguments. It does *not* use the
8082/// const-forwarding type of its arguments, unlike `Bind_ArgTuple11` which
8083/// applies that optimization to avoid unnecessary copying.
8084template <class A1, class A2, class A3, class A4, class A5, class A6,
8085 class A7, class A8, class A9, class A10, class A11>
8086struct Bind_BoundTuple11
8087 : bslmf::TypeList11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> {
8088
8089 // TRAITS
8090 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8091 Bind_BoundTuple11, bslmf::IsBitwiseMoveable,
8092 bslmf::IsBitwiseMoveable<A1>::value &&
8093 bslmf::IsBitwiseMoveable<A2>::value &&
8094 bslmf::IsBitwiseMoveable<A3>::value &&
8095 bslmf::IsBitwiseMoveable<A4>::value &&
8096 bslmf::IsBitwiseMoveable<A5>::value &&
8097 bslmf::IsBitwiseMoveable<A6>::value &&
8098 bslmf::IsBitwiseMoveable<A7>::value &&
8099 bslmf::IsBitwiseMoveable<A8>::value &&
8100 bslmf::IsBitwiseMoveable<A9>::value &&
8101 bslmf::IsBitwiseMoveable<A10>::value &&
8102 bslmf::IsBitwiseMoveable<A11>::value);
8103
8104 // INSTANCE DATA
8105 Bind_BoundTupleValue<A1> d_a1;
8106 Bind_BoundTupleValue<A2> d_a2;
8107 Bind_BoundTupleValue<A3> d_a3;
8108 Bind_BoundTupleValue<A4> d_a4;
8109 Bind_BoundTupleValue<A5> d_a5;
8110 Bind_BoundTupleValue<A6> d_a6;
8111 Bind_BoundTupleValue<A7> d_a7;
8112 Bind_BoundTupleValue<A8> d_a8;
8113 Bind_BoundTupleValue<A9> d_a9;
8114 Bind_BoundTupleValue<A10> d_a10;
8115 Bind_BoundTupleValue<A11> d_a11;
8116
8117 // CREATORS
8118 Bind_BoundTuple11(const Bind_BoundTuple11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8119 A11>& orig,
8120 bslma::Allocator *allocator = 0)
8121 : d_a1(orig.d_a1,allocator)
8122 , d_a2(orig.d_a2,allocator)
8123 , d_a3(orig.d_a3,allocator)
8124 , d_a4(orig.d_a4,allocator)
8125 , d_a5(orig.d_a5,allocator)
8126 , d_a6(orig.d_a6,allocator)
8127 , d_a7(orig.d_a7,allocator)
8128 , d_a8(orig.d_a8,allocator)
8129 , d_a9(orig.d_a9,allocator)
8130 , d_a10(orig.d_a10,allocator)
8131 , d_a11(orig.d_a11,allocator)
8132 {
8133 }
8134
8135 Bind_BoundTuple11(
8136 bslmf::MovableRef<Bind_BoundTuple11<
8137 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> > orig,
8138 bslma::Allocator *allocator = 0)
8139 : d_a1(bslmf::MovableRefUtil::move(
8140 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8141 , d_a2(bslmf::MovableRefUtil::move(
8142 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8143 , d_a3(bslmf::MovableRefUtil::move(
8144 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8145 , d_a4(bslmf::MovableRefUtil::move(
8146 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8147 , d_a5(bslmf::MovableRefUtil::move(
8148 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8149 , d_a6(bslmf::MovableRefUtil::move(
8150 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8151 , d_a7(bslmf::MovableRefUtil::move(
8152 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8153 , d_a8(bslmf::MovableRefUtil::move(
8154 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8155 , d_a9(bslmf::MovableRefUtil::move(
8156 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8157 , d_a10(bslmf::MovableRefUtil::move(
8158 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8159 , d_a11(bslmf::MovableRefUtil::move(
8160 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8161 {
8162 }
8163
8164 Bind_BoundTuple11(A1 const& a1,
8165 A2 const& a2,
8166 A3 const& a3,
8167 A4 const& a4,
8168 A5 const& a5,
8169 A6 const& a6,
8170 A7 const& a7,
8171 A8 const& a8,
8172 A9 const& a9,
8173 A10 const& a10,
8174 A11 const& a11,
8175 bslma::Allocator *allocator = 0)
8176 : d_a1(a1,allocator)
8177 , d_a2(a2,allocator)
8178 , d_a3(a3,allocator)
8179 , d_a4(a4,allocator)
8180 , d_a5(a5,allocator)
8181 , d_a6(a6,allocator)
8182 , d_a7(a7,allocator)
8183 , d_a8(a8,allocator)
8184 , d_a9(a9,allocator)
8185 , d_a10(a10,allocator)
8186 , d_a11(a11,allocator)
8187 {
8188 }
8189
8190 Bind_BoundTuple11(bslmf::MovableRef<A1> a1,
8191 bslmf::MovableRef<A2> a2,
8192 bslmf::MovableRef<A3> a3,
8193 bslmf::MovableRef<A4> a4,
8194 bslmf::MovableRef<A5> a5,
8195 bslmf::MovableRef<A6> a6,
8196 bslmf::MovableRef<A7> a7,
8197 bslmf::MovableRef<A8> a8,
8198 bslmf::MovableRef<A9> a9,
8199 bslmf::MovableRef<A10> a10,
8200 bslmf::MovableRef<A11> a11,
8201 bslma::Allocator *allocator = 0)
8202 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8203 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8204 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8205 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8206 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8207 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8208 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8209 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8210 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8211 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8212 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8213 {
8214 }
8215};
8216
8217/// This `struct` stores a list of twelve arguments. It does *not* use the
8218/// const-forwarding type of its arguments, unlike `Bind_ArgTuple12` which
8219/// applies that optimization to avoid unnecessary copying.
8220template <class A1, class A2, class A3, class A4, class A5, class A6,
8221 class A7, class A8, class A9, class A10, class A11, class A12>
8222struct Bind_BoundTuple12
8223 : bslmf::TypeList12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> {
8224
8225 // TRAITS
8226 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8227 Bind_BoundTuple12, bslmf::IsBitwiseMoveable,
8228 bslmf::IsBitwiseMoveable<A1>::value &&
8229 bslmf::IsBitwiseMoveable<A2>::value &&
8230 bslmf::IsBitwiseMoveable<A3>::value &&
8231 bslmf::IsBitwiseMoveable<A4>::value &&
8232 bslmf::IsBitwiseMoveable<A5>::value &&
8233 bslmf::IsBitwiseMoveable<A6>::value &&
8234 bslmf::IsBitwiseMoveable<A7>::value &&
8235 bslmf::IsBitwiseMoveable<A8>::value &&
8236 bslmf::IsBitwiseMoveable<A9>::value &&
8237 bslmf::IsBitwiseMoveable<A10>::value &&
8238 bslmf::IsBitwiseMoveable<A11>::value &&
8239 bslmf::IsBitwiseMoveable<A12>::value);
8240
8241 // INSTANCE DATA
8242 Bind_BoundTupleValue<A1> d_a1;
8243 Bind_BoundTupleValue<A2> d_a2;
8244 Bind_BoundTupleValue<A3> d_a3;
8245 Bind_BoundTupleValue<A4> d_a4;
8246 Bind_BoundTupleValue<A5> d_a5;
8247 Bind_BoundTupleValue<A6> d_a6;
8248 Bind_BoundTupleValue<A7> d_a7;
8249 Bind_BoundTupleValue<A8> d_a8;
8250 Bind_BoundTupleValue<A9> d_a9;
8251 Bind_BoundTupleValue<A10> d_a10;
8252 Bind_BoundTupleValue<A11> d_a11;
8253 Bind_BoundTupleValue<A12> d_a12;
8254
8255 // CREATORS
8256 Bind_BoundTuple12(const Bind_BoundTuple12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8257 A11,A12>& orig,
8258 bslma::Allocator *allocator = 0)
8259 : d_a1(orig.d_a1,allocator)
8260 , d_a2(orig.d_a2,allocator)
8261 , d_a3(orig.d_a3,allocator)
8262 , d_a4(orig.d_a4,allocator)
8263 , d_a5(orig.d_a5,allocator)
8264 , d_a6(orig.d_a6,allocator)
8265 , d_a7(orig.d_a7,allocator)
8266 , d_a8(orig.d_a8,allocator)
8267 , d_a9(orig.d_a9,allocator)
8268 , d_a10(orig.d_a10,allocator)
8269 , d_a11(orig.d_a11,allocator)
8270 , d_a12(orig.d_a12,allocator)
8271 {
8272 }
8273
8274 Bind_BoundTuple12(
8275 bslmf::MovableRef<Bind_BoundTuple12<
8276 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> > orig,
8277 bslma::Allocator *allocator = 0)
8278 : d_a1(bslmf::MovableRefUtil::move(
8279 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8280 , d_a2(bslmf::MovableRefUtil::move(
8281 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8282 , d_a3(bslmf::MovableRefUtil::move(
8283 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8284 , d_a4(bslmf::MovableRefUtil::move(
8285 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8286 , d_a5(bslmf::MovableRefUtil::move(
8287 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8288 , d_a6(bslmf::MovableRefUtil::move(
8289 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8290 , d_a7(bslmf::MovableRefUtil::move(
8291 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8292 , d_a8(bslmf::MovableRefUtil::move(
8293 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8294 , d_a9(bslmf::MovableRefUtil::move(
8295 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8296 , d_a10(bslmf::MovableRefUtil::move(
8297 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8298 , d_a11(bslmf::MovableRefUtil::move(
8299 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8300 , d_a12(bslmf::MovableRefUtil::move(
8301 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8302 {
8303 }
8304
8305 Bind_BoundTuple12(A1 const& a1,
8306 A2 const& a2,
8307 A3 const& a3,
8308 A4 const& a4,
8309 A5 const& a5,
8310 A6 const& a6,
8311 A7 const& a7,
8312 A8 const& a8,
8313 A9 const& a9,
8314 A10 const& a10,
8315 A11 const& a11,
8316 A12 const& a12,
8317 bslma::Allocator *allocator = 0)
8318 : d_a1(a1,allocator)
8319 , d_a2(a2,allocator)
8320 , d_a3(a3,allocator)
8321 , d_a4(a4,allocator)
8322 , d_a5(a5,allocator)
8323 , d_a6(a6,allocator)
8324 , d_a7(a7,allocator)
8325 , d_a8(a8,allocator)
8326 , d_a9(a9,allocator)
8327 , d_a10(a10,allocator)
8328 , d_a11(a11,allocator)
8329 , d_a12(a12,allocator)
8330 {
8331 }
8332
8333 Bind_BoundTuple12(bslmf::MovableRef<A1> a1,
8334 bslmf::MovableRef<A2> a2,
8335 bslmf::MovableRef<A3> a3,
8336 bslmf::MovableRef<A4> a4,
8337 bslmf::MovableRef<A5> a5,
8338 bslmf::MovableRef<A6> a6,
8339 bslmf::MovableRef<A7> a7,
8340 bslmf::MovableRef<A8> a8,
8341 bslmf::MovableRef<A9> a9,
8342 bslmf::MovableRef<A10> a10,
8343 bslmf::MovableRef<A11> a11,
8344 bslmf::MovableRef<A12> a12,
8345 bslma::Allocator *allocator = 0)
8346 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8347 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8348 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8349 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8350 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8351 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8352 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8353 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8354 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8355 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8356 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8357 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8358 {
8359 }
8360};
8361
8362/// This `struct` stores a list of thirteen arguments. It does *not* use
8363/// the const-forwarding type of its arguments, unlike `Bind_ArgTuple13`
8364/// which applies that optimization to avoid unnecessary copying.
8365template <class A1, class A2, class A3, class A4, class A5, class A6,
8366 class A7, class A8, class A9, class A10, class A11, class A12,
8367 class A13>
8368struct Bind_BoundTuple13
8369 : bslmf::TypeList13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> {
8370
8371 // TRAITS
8372 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8373 Bind_BoundTuple13, bslmf::IsBitwiseMoveable,
8374 bslmf::IsBitwiseMoveable<A1>::value &&
8375 bslmf::IsBitwiseMoveable<A2>::value &&
8376 bslmf::IsBitwiseMoveable<A3>::value &&
8377 bslmf::IsBitwiseMoveable<A4>::value &&
8378 bslmf::IsBitwiseMoveable<A5>::value &&
8379 bslmf::IsBitwiseMoveable<A6>::value &&
8380 bslmf::IsBitwiseMoveable<A7>::value &&
8381 bslmf::IsBitwiseMoveable<A8>::value &&
8382 bslmf::IsBitwiseMoveable<A9>::value &&
8383 bslmf::IsBitwiseMoveable<A10>::value &&
8384 bslmf::IsBitwiseMoveable<A11>::value &&
8385 bslmf::IsBitwiseMoveable<A12>::value &&
8386 bslmf::IsBitwiseMoveable<A13>::value);
8387
8388 // INSTANCE DATA
8389 Bind_BoundTupleValue<A1> d_a1;
8390 Bind_BoundTupleValue<A2> d_a2;
8391 Bind_BoundTupleValue<A3> d_a3;
8392 Bind_BoundTupleValue<A4> d_a4;
8393 Bind_BoundTupleValue<A5> d_a5;
8394 Bind_BoundTupleValue<A6> d_a6;
8395 Bind_BoundTupleValue<A7> d_a7;
8396 Bind_BoundTupleValue<A8> d_a8;
8397 Bind_BoundTupleValue<A9> d_a9;
8398 Bind_BoundTupleValue<A10> d_a10;
8399 Bind_BoundTupleValue<A11> d_a11;
8400 Bind_BoundTupleValue<A12> d_a12;
8401 Bind_BoundTupleValue<A13> d_a13;
8402
8403 // CREATORS
8404 Bind_BoundTuple13(const Bind_BoundTuple13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8405 A11,A12,A13>& orig,
8406 bslma::Allocator *allocator = 0)
8407 : d_a1(orig.d_a1,allocator)
8408 , d_a2(orig.d_a2,allocator)
8409 , d_a3(orig.d_a3,allocator)
8410 , d_a4(orig.d_a4,allocator)
8411 , d_a5(orig.d_a5,allocator)
8412 , d_a6(orig.d_a6,allocator)
8413 , d_a7(orig.d_a7,allocator)
8414 , d_a8(orig.d_a8,allocator)
8415 , d_a9(orig.d_a9,allocator)
8416 , d_a10(orig.d_a10,allocator)
8417 , d_a11(orig.d_a11,allocator)
8418 , d_a12(orig.d_a12,allocator)
8419 , d_a13(orig.d_a13,allocator)
8420 {
8421 }
8422
8423 Bind_BoundTuple13(
8424 bslmf::MovableRef<Bind_BoundTuple13<
8425 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> > orig,
8426 bslma::Allocator *allocator = 0)
8427 : d_a1(bslmf::MovableRefUtil::move(
8428 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8429 , d_a2(bslmf::MovableRefUtil::move(
8430 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8431 , d_a3(bslmf::MovableRefUtil::move(
8432 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8433 , d_a4(bslmf::MovableRefUtil::move(
8434 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8435 , d_a5(bslmf::MovableRefUtil::move(
8436 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8437 , d_a6(bslmf::MovableRefUtil::move(
8438 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8439 , d_a7(bslmf::MovableRefUtil::move(
8440 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8441 , d_a8(bslmf::MovableRefUtil::move(
8442 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8443 , d_a9(bslmf::MovableRefUtil::move(
8444 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8445 , d_a10(bslmf::MovableRefUtil::move(
8446 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8447 , d_a11(bslmf::MovableRefUtil::move(
8448 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8449 , d_a12(bslmf::MovableRefUtil::move(
8450 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8451 , d_a13(bslmf::MovableRefUtil::move(
8452 bslmf::MovableRefUtil::access(orig).d_a13),allocator)
8453 {
8454 }
8455
8456 Bind_BoundTuple13(A1 const& a1,
8457 A2 const& a2,
8458 A3 const& a3,
8459 A4 const& a4,
8460 A5 const& a5,
8461 A6 const& a6,
8462 A7 const& a7,
8463 A8 const& a8,
8464 A9 const& a9,
8465 A10 const& a10,
8466 A11 const& a11,
8467 A12 const& a12,
8468 A13 const& a13,
8469 bslma::Allocator *allocator = 0)
8470 : d_a1(a1,allocator)
8471 , d_a2(a2,allocator)
8472 , d_a3(a3,allocator)
8473 , d_a4(a4,allocator)
8474 , d_a5(a5,allocator)
8475 , d_a6(a6,allocator)
8476 , d_a7(a7,allocator)
8477 , d_a8(a8,allocator)
8478 , d_a9(a9,allocator)
8479 , d_a10(a10,allocator)
8480 , d_a11(a11,allocator)
8481 , d_a12(a12,allocator)
8482 , d_a13(a13,allocator)
8483 {
8484 }
8485
8486 Bind_BoundTuple13(bslmf::MovableRef<A1> a1,
8487 bslmf::MovableRef<A2> a2,
8488 bslmf::MovableRef<A3> a3,
8489 bslmf::MovableRef<A4> a4,
8490 bslmf::MovableRef<A5> a5,
8491 bslmf::MovableRef<A6> a6,
8492 bslmf::MovableRef<A7> a7,
8493 bslmf::MovableRef<A8> a8,
8494 bslmf::MovableRef<A9> a9,
8495 bslmf::MovableRef<A10> a10,
8496 bslmf::MovableRef<A11> a11,
8497 bslmf::MovableRef<A12> a12,
8498 bslmf::MovableRef<A13> a13,
8499 bslma::Allocator *allocator = 0)
8500 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8501 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8502 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8503 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8504 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8505 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8506 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8507 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8508 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8509 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8510 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8511 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8512 , d_a13(bslmf::MovableRefUtil::move(a13), allocator)
8513 {
8514 }
8515};
8516
8517/// This `struct` stores a list of fourteen arguments. It does *not* use
8518/// the const-forwarding type of its arguments, unlike `Bind_ArgTuple14`
8519/// which applies that optimization to avoid unnecessary copying.
8520template <class A1, class A2, class A3, class A4, class A5, class A6,
8521 class A7, class A8, class A9, class A10, class A11, class A12,
8522 class A13, class A14>
8523struct Bind_BoundTuple14
8524 : bslmf::TypeList14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> {
8525
8526 // TRAITS
8527 BSLMF_NESTED_TRAIT_DECLARATION_IF(
8528 Bind_BoundTuple14, bslmf::IsBitwiseMoveable,
8529 bslmf::IsBitwiseMoveable<A1>::value &&
8530 bslmf::IsBitwiseMoveable<A2>::value &&
8531 bslmf::IsBitwiseMoveable<A3>::value &&
8532 bslmf::IsBitwiseMoveable<A4>::value &&
8533 bslmf::IsBitwiseMoveable<A5>::value &&
8534 bslmf::IsBitwiseMoveable<A6>::value &&
8535 bslmf::IsBitwiseMoveable<A7>::value &&
8536 bslmf::IsBitwiseMoveable<A8>::value &&
8537 bslmf::IsBitwiseMoveable<A9>::value &&
8538 bslmf::IsBitwiseMoveable<A10>::value &&
8539 bslmf::IsBitwiseMoveable<A11>::value &&
8540 bslmf::IsBitwiseMoveable<A12>::value &&
8541 bslmf::IsBitwiseMoveable<A13>::value &&
8542 bslmf::IsBitwiseMoveable<A14>::value);
8543
8544 // INSTANCE DATA
8545 Bind_BoundTupleValue<A1> d_a1;
8546 Bind_BoundTupleValue<A2> d_a2;
8547 Bind_BoundTupleValue<A3> d_a3;
8548 Bind_BoundTupleValue<A4> d_a4;
8549 Bind_BoundTupleValue<A5> d_a5;
8550 Bind_BoundTupleValue<A6> d_a6;
8551 Bind_BoundTupleValue<A7> d_a7;
8552 Bind_BoundTupleValue<A8> d_a8;
8553 Bind_BoundTupleValue<A9> d_a9;
8554 Bind_BoundTupleValue<A10> d_a10;
8555 Bind_BoundTupleValue<A11> d_a11;
8556 Bind_BoundTupleValue<A12> d_a12;
8557 Bind_BoundTupleValue<A13> d_a13;
8558 Bind_BoundTupleValue<A14> d_a14;
8559
8560 // CREATORS
8561 Bind_BoundTuple14(const Bind_BoundTuple14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,
8562 A11,A12,A13,A14>& orig,
8563 bslma::Allocator *allocator = 0)
8564 : d_a1(orig.d_a1,allocator)
8565 , d_a2(orig.d_a2,allocator)
8566 , d_a3(orig.d_a3,allocator)
8567 , d_a4(orig.d_a4,allocator)
8568 , d_a5(orig.d_a5,allocator)
8569 , d_a6(orig.d_a6,allocator)
8570 , d_a7(orig.d_a7,allocator)
8571 , d_a8(orig.d_a8,allocator)
8572 , d_a9(orig.d_a9,allocator)
8573 , d_a10(orig.d_a10,allocator)
8574 , d_a11(orig.d_a11,allocator)
8575 , d_a12(orig.d_a12,allocator)
8576 , d_a13(orig.d_a13,allocator)
8577 , d_a14(orig.d_a14,allocator)
8578 {
8579 }
8580
8581 Bind_BoundTuple14(
8582 bslmf::MovableRef<Bind_BoundTuple14<
8583 A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> > orig,
8584 bslma::Allocator *allocator = 0)
8585 : d_a1(bslmf::MovableRefUtil::move(
8586 bslmf::MovableRefUtil::access(orig).d_a1), allocator)
8587 , d_a2(bslmf::MovableRefUtil::move(
8588 bslmf::MovableRefUtil::access(orig).d_a2), allocator)
8589 , d_a3(bslmf::MovableRefUtil::move(
8590 bslmf::MovableRefUtil::access(orig).d_a3), allocator)
8591 , d_a4(bslmf::MovableRefUtil::move(
8592 bslmf::MovableRefUtil::access(orig).d_a4), allocator)
8593 , d_a5(bslmf::MovableRefUtil::move(
8594 bslmf::MovableRefUtil::access(orig).d_a5), allocator)
8595 , d_a6(bslmf::MovableRefUtil::move(
8596 bslmf::MovableRefUtil::access(orig).d_a6), allocator)
8597 , d_a7(bslmf::MovableRefUtil::move(
8598 bslmf::MovableRefUtil::access(orig).d_a7), allocator)
8599 , d_a8(bslmf::MovableRefUtil::move(
8600 bslmf::MovableRefUtil::access(orig).d_a8), allocator)
8601 , d_a9(bslmf::MovableRefUtil::move(
8602 bslmf::MovableRefUtil::access(orig).d_a9), allocator)
8603 , d_a10(bslmf::MovableRefUtil::move(
8604 bslmf::MovableRefUtil::access(orig).d_a10),allocator)
8605 , d_a11(bslmf::MovableRefUtil::move(
8606 bslmf::MovableRefUtil::access(orig).d_a11),allocator)
8607 , d_a12(bslmf::MovableRefUtil::move(
8608 bslmf::MovableRefUtil::access(orig).d_a12),allocator)
8609 , d_a13(bslmf::MovableRefUtil::move(
8610 bslmf::MovableRefUtil::access(orig).d_a13),allocator)
8611 , d_a14(bslmf::MovableRefUtil::move(
8612 bslmf::MovableRefUtil::access(orig).d_a14),allocator)
8613 {
8614 }
8615
8616 Bind_BoundTuple14(A1 const& a1,
8617 A2 const& a2,
8618 A3 const& a3,
8619 A4 const& a4,
8620 A5 const& a5,
8621 A6 const& a6,
8622 A7 const& a7,
8623 A8 const& a8,
8624 A9 const& a9,
8625 A10 const& a10,
8626 A11 const& a11,
8627 A12 const& a12,
8628 A13 const& a13,
8629 A14 const& a14,
8630 bslma::Allocator *allocator = 0)
8631 : d_a1(a1,allocator)
8632 , d_a2(a2,allocator)
8633 , d_a3(a3,allocator)
8634 , d_a4(a4,allocator)
8635 , d_a5(a5,allocator)
8636 , d_a6(a6,allocator)
8637 , d_a7(a7,allocator)
8638 , d_a8(a8,allocator)
8639 , d_a9(a9,allocator)
8640 , d_a10(a10,allocator)
8641 , d_a11(a11,allocator)
8642 , d_a12(a12,allocator)
8643 , d_a13(a13,allocator)
8644 , d_a14(a14,allocator)
8645 {
8646 }
8647
8648 Bind_BoundTuple14(bslmf::MovableRef<A1> a1,
8649 bslmf::MovableRef<A2> a2,
8650 bslmf::MovableRef<A3> a3,
8651 bslmf::MovableRef<A4> a4,
8652 bslmf::MovableRef<A5> a5,
8653 bslmf::MovableRef<A6> a6,
8654 bslmf::MovableRef<A7> a7,
8655 bslmf::MovableRef<A8> a8,
8656 bslmf::MovableRef<A9> a9,
8657 bslmf::MovableRef<A10> a10,
8658 bslmf::MovableRef<A11> a11,
8659 bslmf::MovableRef<A12> a12,
8660 bslmf::MovableRef<A13> a13,
8661 bslmf::MovableRef<A14> a14,
8662 bslma::Allocator *allocator = 0)
8663 : d_a1( bslmf::MovableRefUtil::move(a1), allocator)
8664 , d_a2( bslmf::MovableRefUtil::move(a2), allocator)
8665 , d_a3( bslmf::MovableRefUtil::move(a3), allocator)
8666 , d_a4( bslmf::MovableRefUtil::move(a4), allocator)
8667 , d_a5( bslmf::MovableRefUtil::move(a5), allocator)
8668 , d_a6( bslmf::MovableRefUtil::move(a6), allocator)
8669 , d_a7( bslmf::MovableRefUtil::move(a7), allocator)
8670 , d_a8( bslmf::MovableRefUtil::move(a8), allocator)
8671 , d_a9( bslmf::MovableRefUtil::move(a9), allocator)
8672 , d_a10(bslmf::MovableRefUtil::move(a10), allocator)
8673 , d_a11(bslmf::MovableRefUtil::move(a11), allocator)
8674 , d_a12(bslmf::MovableRefUtil::move(a12), allocator)
8675 , d_a13(bslmf::MovableRefUtil::move(a13), allocator)
8676 , d_a14(bslmf::MovableRefUtil::move(a14), allocator)
8677 {
8678 }
8679};
8680} // close package namespace
8681
8682 // ========================
8683 // class bdlf::Bind_Invoker
8684 // ========================
8685
8686#define BDLF_BIND_EVAL(N) \
8687 bdlf::Bind_Evaluator< \
8688 typename bslmf::TypeListTypeOf<N, t_BOUND_TUPLE>::Type, \
8689 t_ARG_TUPLE>::eval(argList, (boundList->d_a##N).value())
8690
8691namespace bdlf {
8692/// Invoker for functions that take zero arguments.
8693template <class t_RET>
8694struct Bind_Invoker<t_RET, 0> {
8695 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8696 t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE&) const
8697 {
8698 return (*func)();
8699 }
8700};
8701
8702/// Invoker for functions that take zero arguments.
8703template <>
8704struct Bind_Invoker<void, 0> {
8705 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8706 void invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE&) const
8707 {
8708 (*func)();
8709 }
8710};
8711
8712/// Invoker for functions that take one argument.
8713template <class t_RET>
8714struct Bind_Invoker<t_RET, 1> {
8715 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8716 t_RET invoke(t_FUNC *func,
8717 t_BOUND_TUPLE *boundList,
8718 t_ARG_TUPLE& argList) const
8719 {
8720 return (*func)(BDLF_BIND_EVAL(1));
8721 }
8722};
8723
8724/// Invoker for functions that take one argument.
8725template <>
8726struct Bind_Invoker<void, 1> {
8727 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8728 void invoke(t_FUNC *func,
8729 t_BOUND_TUPLE *boundList,
8730 t_ARG_TUPLE& argList) const
8731 {
8732 (*func)(BDLF_BIND_EVAL(1));
8733 }
8734};
8735
8736/// Invoker for function that take two arguments.
8737template <class t_RET>
8738struct Bind_Invoker<t_RET, 2> {
8739 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8740 t_RET invoke(t_FUNC *func,
8741 t_BOUND_TUPLE *boundList,
8742 t_ARG_TUPLE& argList) const
8743 {
8744 return (*func)(BDLF_BIND_EVAL(1),
8745 BDLF_BIND_EVAL(2));
8746 }
8747};
8748
8749/// Invoker for functions that take two arguments.
8750template <>
8751struct Bind_Invoker<void, 2> {
8752 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8753 void invoke(t_FUNC *func,
8754 t_BOUND_TUPLE *boundList,
8755 t_ARG_TUPLE& argList) const
8756 {
8757 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2));
8758 }
8759};
8760
8761/// Invoker for functions that take three arguments.
8762template <class t_RET>
8763struct Bind_Invoker<t_RET, 3> {
8764 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8765 t_RET invoke(t_FUNC *func,
8766 t_BOUND_TUPLE *boundList,
8767 t_ARG_TUPLE& argList) const
8768 {
8769 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8770 BDLF_BIND_EVAL(3));
8771 }
8772};
8773
8774/// Invoker for functions that take three arguments.
8775template <>
8776struct Bind_Invoker<void, 3> {
8777 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8778 void invoke(t_FUNC *func,
8779 t_BOUND_TUPLE *boundList,
8780 t_ARG_TUPLE& argList) const
8781 {
8782 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3));
8783 }
8784};
8785
8786/// Invoker for functions that take four arguments.
8787template <class t_RET>
8788struct Bind_Invoker<t_RET, 4> {
8789 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8790 t_RET invoke(t_FUNC *func,
8791 t_BOUND_TUPLE *boundList,
8792 t_ARG_TUPLE& argList) const
8793 {
8794 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8795 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4));
8796 }
8797};
8798
8799/// Invoker for functions that take four arguments.
8800template <>
8801struct Bind_Invoker<void, 4> {
8802 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8803 void invoke(t_FUNC *func,
8804 t_BOUND_TUPLE *boundList,
8805 t_ARG_TUPLE& argList) const
8806 {
8807 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8808 BDLF_BIND_EVAL(4));
8809 }
8810};
8811
8812/// Invoker for functions that take five arguments.
8813template <class t_RET>
8814struct Bind_Invoker<t_RET, 5> {
8815 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8816 t_RET invoke(t_FUNC *func,
8817 t_BOUND_TUPLE *boundList,
8818 t_ARG_TUPLE& argList) const
8819 {
8820 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8821 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8822 BDLF_BIND_EVAL(5));
8823 }
8824};
8825
8826/// Invoker for functions that take five arguments.
8827template <>
8828struct Bind_Invoker<void, 5> {
8829 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8830 void invoke(t_FUNC *func,
8831 t_BOUND_TUPLE *boundList,
8832 t_ARG_TUPLE& argList) const
8833 {
8834 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8835 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5));
8836 }
8837};
8838
8839/// Invoker for functions that take six arguments.
8840template <class t_RET>
8841struct Bind_Invoker<t_RET, 6> {
8842 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8843 t_RET invoke(t_FUNC *func,
8844 t_BOUND_TUPLE *boundList,
8845 t_ARG_TUPLE& argList) const
8846 {
8847 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8848 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8849 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6));
8850 }
8851};
8852
8853/// Invoker for functions that take six arguments.
8854template <>
8855struct Bind_Invoker<void, 6> {
8856 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8857 void invoke(t_FUNC *func,
8858 t_BOUND_TUPLE *boundList,
8859 t_ARG_TUPLE& argList) const
8860 {
8861 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8862 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6));
8863 }
8864};
8865
8866/// Invoker for functions that take seven arguments.
8867template <class t_RET>
8868struct Bind_Invoker<t_RET, 7> {
8869 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8870 t_RET invoke(t_FUNC *func,
8871 t_BOUND_TUPLE *boundList,
8872 t_ARG_TUPLE& argList) const
8873 {
8874 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8875 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8876 BDLF_BIND_EVAL(7));
8877 }
8878};
8879
8880/// Invoker for functions that take seven arguments.
8881template <>
8882struct Bind_Invoker<void, 7> {
8883 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8884 void invoke(t_FUNC *func,
8885 t_BOUND_TUPLE *boundList,
8886 t_ARG_TUPLE& argList) const
8887 {
8888 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8889 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8890 BDLF_BIND_EVAL(7));
8891 }
8892};
8893
8894/// Invoker for functions that take eight arguments.
8895template <class t_RET>
8896struct Bind_Invoker<t_RET, 8> {
8897 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8898 t_RET invoke(t_FUNC *func,
8899 t_BOUND_TUPLE *boundList,
8900 t_ARG_TUPLE& argList) const
8901 {
8902 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8903 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8904 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8905 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8));
8906 }
8907};
8908
8909/// Invoker for functions that take eight arguments.
8910template <>
8911struct Bind_Invoker<void, 8> {
8912 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8913 void invoke(t_FUNC *func,
8914 t_BOUND_TUPLE *boundList,
8915 t_ARG_TUPLE& argList) const
8916 {
8917 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8918 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8919 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8));
8920 }
8921};
8922
8923/// Invoker for functions that take nine arguments.
8924template <class t_RET>
8925struct Bind_Invoker<t_RET, 9> {
8926 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8927 t_RET invoke(t_FUNC *func,
8928 t_BOUND_TUPLE *boundList,
8929 t_ARG_TUPLE& argList) const
8930 {
8931 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8932 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8933 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9)
8934 );
8935 }
8936};
8937
8938/// Invoker for functions that take nine arguments.
8939template <>
8940struct Bind_Invoker<void, 9> {
8941 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8942 void invoke(t_FUNC *func,
8943 t_BOUND_TUPLE *boundList,
8944 t_ARG_TUPLE& argList) const
8945 {
8946 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8947 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8948 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9));
8949 }
8950};
8951
8952/// Invoker for functions that take nine arguments.
8953template <class t_RET>
8954struct Bind_Invoker<t_RET, 10> {
8955 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8956 t_RET invoke(t_FUNC *func,
8957 t_BOUND_TUPLE *boundList,
8958 t_ARG_TUPLE& argList) const
8959 {
8960 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8961 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8962 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8963 BDLF_BIND_EVAL(10));
8964 }
8965};
8966
8967/// Invoker for functions that take ten arguments and return void.
8968template <>
8969struct Bind_Invoker<void, 10> {
8970 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8971 void invoke(t_FUNC *func,
8972 t_BOUND_TUPLE *boundList,
8973 t_ARG_TUPLE& argList) const
8974 {
8975 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
8976 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8977 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
8978 BDLF_BIND_EVAL(10));
8979 }
8980};
8981
8982/// Invoker for functions that take eleven arguments.
8983template <class t_RET>
8984struct Bind_Invoker<t_RET, 11> {
8985 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
8986 t_RET invoke(t_FUNC *func,
8987 t_BOUND_TUPLE *boundList,
8988 t_ARG_TUPLE& argList) const
8989 {
8990 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
8991 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
8992 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
8993 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
8994 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
8995 BDLF_BIND_EVAL(11));
8996 }
8997};
8998
8999/// Invoker for functions that take eleven arguments and return void.
9000template <>
9001struct Bind_Invoker<void, 11> {
9002 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9003 void invoke(t_FUNC *func,
9004 t_BOUND_TUPLE *boundList,
9005 t_ARG_TUPLE& argList) const
9006 {
9007 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),BDLF_BIND_EVAL(3),
9008 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9009 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9010 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11));
9011 }
9012};
9013
9014/// Invoker for functions that take nine arguments.
9015template <class t_RET>
9016struct Bind_Invoker<t_RET, 12> {
9017 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9018 t_RET invoke(t_FUNC *func,
9019 t_BOUND_TUPLE *boundList,
9020 t_ARG_TUPLE& argList) const
9021 {
9022 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
9023 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
9024 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9025 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
9026 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
9027 BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12));
9028 }
9029};
9030
9031/// Invoker for functions that take twelve arguments and return void.
9032template <>
9033struct Bind_Invoker<void, 12> {
9034 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9035 void invoke(t_FUNC *func,
9036 t_BOUND_TUPLE *boundList,
9037 t_ARG_TUPLE& argList) const
9038 {
9039 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
9040 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9041 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9042 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12));
9043 }
9044};
9045
9046/// Invoker for functions that take thirteen arguments.
9047template <class t_RET>
9048struct Bind_Invoker<t_RET, 13> {
9049 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9050 t_RET invoke(t_FUNC *func,
9051 t_BOUND_TUPLE *boundList,
9052 t_ARG_TUPLE& argList) const
9053 {
9054 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
9055 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
9056 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9057 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
9058 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
9059 BDLF_BIND_EVAL(11), BDLF_BIND_EVAL(12),
9060 BDLF_BIND_EVAL(13));
9061 }
9062};
9063
9064/// Invoker for functions that take thirteen arguments and return void.
9065template <>
9066struct Bind_Invoker<void, 13> {
9067 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9068 void invoke(t_FUNC *func,
9069 t_BOUND_TUPLE *boundList,
9070 t_ARG_TUPLE& argList) const
9071 {
9072 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
9073 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9074 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9075 BDLF_BIND_EVAL(10),BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9076 BDLF_BIND_EVAL(13));
9077 }
9078};
9079
9080/// Invoker for functions that take fourteen arguments.
9081template <class t_RET>
9082struct Bind_Invoker<t_RET, 14> {
9083 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9084 t_RET invoke(t_FUNC *func,
9085 t_BOUND_TUPLE *boundList,
9086 t_ARG_TUPLE& argList) const
9087 {
9088 return (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2),
9089 BDLF_BIND_EVAL(3), BDLF_BIND_EVAL(4),
9090 BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9091 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8),
9092 BDLF_BIND_EVAL(9), BDLF_BIND_EVAL(10),
9093 BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9094 BDLF_BIND_EVAL(13), BDLF_BIND_EVAL(14));
9095 }
9096};
9097
9098/// Invoker for functions that take fourteen arguments and return void.
9099template <>
9100struct Bind_Invoker<void, 14> {
9101 template <class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9102 void invoke(t_FUNC *func,
9103 t_BOUND_TUPLE *boundList,
9104 t_ARG_TUPLE& argList) const
9105 {
9106 (*func)(BDLF_BIND_EVAL(1), BDLF_BIND_EVAL(2), BDLF_BIND_EVAL(3),
9107 BDLF_BIND_EVAL(4), BDLF_BIND_EVAL(5), BDLF_BIND_EVAL(6),
9108 BDLF_BIND_EVAL(7), BDLF_BIND_EVAL(8), BDLF_BIND_EVAL(9),
9109 BDLF_BIND_EVAL(10), BDLF_BIND_EVAL(11),BDLF_BIND_EVAL(12),
9110 BDLF_BIND_EVAL(13), BDLF_BIND_EVAL(14));
9111 }
9112};
9113} // close package namespace
9114
9115#undef BDLF_BIND_EVAL
9116
9117namespace bdlf {
9118 // ====================
9119 // class Bind_Evaluator
9120 // ====================
9121
9122/// This utility provides a default argument evaluator that simply returns
9123/// whatever value is passed.
9124///
9125/// See @ref bdlf_bind
9126template <class t_BOUND_TUPLE_ELEMENT, class t_ARG_TUPLE>
9127struct Bind_Evaluator {
9128
9129 typedef typename bslmf::ArrayToConstPointer<t_BOUND_TUPLE_ELEMENT>::Type
9130 BoundType_Impl;
9131 typedef typename bslmf::ForwardingRefType<BoundType_Impl>::Type BoundType;
9132
9133 /// Return the specified `value`.
9134 static
9135 BoundType eval(t_ARG_TUPLE&, BoundType value)
9136 {
9137 return value;
9138 }
9139};
9140
9141/// This partial specialization of `Bind_Evaluator` provides an argument
9142/// evaluator that substitutes the place-holder at position `t_INDEX` with
9143/// the corresponding element in the specified `t_ARG_TUPLE`.
9144template <int t_INDEX, class t_ARG_TUPLE>
9145struct Bind_Evaluator<PlaceHolder<t_INDEX>, t_ARG_TUPLE> {
9146
9147 // PUBLIC TYPES
9148 typedef typename bslmf::ArrayToConstPointer<
9149 typename bslmf::TypeListTypeOf<t_INDEX,
9150 t_ARG_TUPLE>::TypeOrDefault>::Type
9151 ReturnType_Impl;
9152 typedef typename bslmf::ForwardingType<ReturnType_Impl>::Type ReturnType;
9153
9154 // CLASS METHODS
9155
9156 /// Return the first value from the specified `argTuple`.
9157 static
9158 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<1>&)
9159 {
9160 return *(&argTuple.d_a1.value());
9161 }
9162
9163 /// Return the second value from the specified `argTuple`.
9164 static
9165 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<2>&)
9166 {
9167 return *(&argTuple.d_a2.value());
9168 }
9169
9170 /// Return the third value from the specified `argTuple`.
9171 static
9172 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<3>&)
9173 {
9174 return *(&argTuple.d_a3.value());
9175 }
9176
9177 /// Return the fourth value from the specified `argTuple`.
9178 static
9179 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<4>&)
9180 {
9181 return *(&argTuple.d_a4.value());
9182 }
9183
9184 /// Return the fifth value from the specified `argTuple`.
9185 static
9186 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<5>&)
9187 {
9188 return *(&argTuple.d_a5.value());
9189 }
9190
9191 /// Return the sixth value from the specified `argTuple`.
9192 static
9193 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<6>&)
9194 {
9195 return *(&argTuple.d_a6.value());
9196 }
9197
9198 /// Return the seventh value from the specified `argTuple`.
9199 static
9200 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<7>&)
9201 {
9202 return *(&argTuple.d_a7.value());
9203 }
9204
9205 /// Return the eighth value from the specified `argTuple`.
9206 static
9207 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<8>&)
9208 {
9209 return *(&argTuple.d_a8.value());
9210 }
9211
9212 /// Return the ninth value from the specified `argTuple`.
9213 static
9214 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<9>&)
9215 {
9216 return *(&argTuple.d_a9.value());
9217 }
9218
9219 /// Return the tenth value from the specified `argTuple`.
9220 static
9221 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<10>&)
9222 {
9223 return *(&argTuple.d_a10.value());
9224 }
9225
9226 /// Return the eleventh value from the specified `argTuple`.
9227 static
9228 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<11>&)
9229 {
9230 return *(&argTuple.d_a11.value());
9231 }
9232
9233 /// Return the twelfth value from the specified `argTuple`.
9234 static
9235 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<12>&)
9236 {
9237 return *(&argTuple.d_a12.value());
9238 }
9239
9240 /// Return the thirteenth value from the specified `argTuple`.
9241 static
9242 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<13>&)
9243 {
9244 return *(&argTuple.d_a13.value());
9245 }
9246
9247 /// Return the fourteenth value from the specified `argTuple`.
9248 static
9249 ReturnType eval(t_ARG_TUPLE& argTuple, const PlaceHolder<14>&)
9250 {
9251 return *(&argTuple.d_a14.value());
9252 }
9253};
9254
9255/// This utility provides an evaluator for nested `Bind` arguments. The
9256/// `Bind` function object is invoked using the provided argument list and
9257/// the result is returned.
9258template <class t_RET, class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9259struct Bind_Evaluator<Bind<t_RET, t_FUNC, t_BOUND_TUPLE>, t_ARG_TUPLE> {
9260
9261 /// Call the specified `func` functor with the specified `argList`
9262 /// arguments and return the result.
9263 static
9264 typename Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
9265 eval(t_ARG_TUPLE& argList,
9266 const Bind<t_RET, t_FUNC, t_BOUND_TUPLE>& func)
9267 {
9268 return func.invoke(argList);
9269 }
9270};
9271
9272/// This utility provides an evaluator for nested `BindWrapper` arguments.
9273/// It is a specialization of the `Bind_Evaluator` declared in the
9274/// @ref bdlf_bind component to enable nested `BindWrapper` objects in the same
9275/// fashion as nested `Bind` objects. The underlying `Bind` function object
9276/// is invoked using the provided argument list and the result is returned.
9277template <class t_RET, class t_FUNC, class t_BOUND_TUPLE, class t_ARG_TUPLE>
9278struct Bind_Evaluator<BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE>, t_ARG_TUPLE> {
9279
9280 /// Call the specified `func` functor with the specified `argList`
9281 /// arguments and return the result.
9282 static inline typename Bind<t_RET, t_FUNC, t_BOUND_TUPLE>::ResultType
9283 eval(t_ARG_TUPLE& argList,
9284 const BindWrapper<t_RET, t_FUNC, t_BOUND_TUPLE>& func)
9285 {
9286 return func.invoke(argList);
9287 }
9288};
9289
9290} // close package namespace
9291
9292
9293
9294#endif
9295
9296// ----------------------------------------------------------------------------
9297// Copyright 2019 Bloomberg Finance L.P.
9298//
9299// Licensed under the Apache License, Version 2.0 (the "License");
9300// you may not use this file except in compliance with the License.
9301// You may obtain a copy of the License at
9302//
9303// http://www.apache.org/licenses/LICENSE-2.0
9304//
9305// Unless required by applicable law or agreed to in writing, software
9306// distributed under the License is distributed on an "AS IS" BASIS,
9307// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
9308// See the License for the specific language governing permissions and
9309// limitations under the License.
9310// ----------------------------- END-OF-FILE ----------------------------------
9311
9312/** @} */
9313/** @} */
9314/** @} */
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_movableref.h
bslmf_nestedtraitdeclaration.h
bslmf_nil.h
bslmf_removecv.h
bslmf_resulttype.h
bslmf_tag.h
bslmf_typelist.h
bslmf_util.h
bslmf_voidtype.h
bsls_compilerfeatures.h
bsls_ident.h
bsls_keyword.h
bsls_util.h
bdlf::BindUtil
Definition bdlf_bind.h:1798
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:3967
bdlf::BindUtil::bindSR
static BindWrapper< t_RET, t_FUNC, bdlf::Bind_BoundTuple0 > bindSR(bslma::Allocator *allocator, t_FUNC func)
Definition bdlf_bind.h:3790
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:3521
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:4117
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:3107
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:3353
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:2965
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:2055
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:3305
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:4063
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:2013
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:3186
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:3461
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:2101
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:3155
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:3035
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:2264
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:2636
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:2464
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:3728
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:3926
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:4306
bdlf::BindUtil::bindS
static BindWrapper< bslmf::Nil, t_FUNC, bdlf::Bind_BoundTuple0 > bindS(bslma::Allocator *allocator, t_FUNC func)
Definition bdlf_bind.h:3092
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:4378
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:2781
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:3221
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:2838
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:1866
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:4454
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:3889
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:3856
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:2728
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:3828
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:2596
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:4176
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:1887
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:2394
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:2205
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:2680
bdlf::BindUtil::bind
static Bind< bslmf::Nil, t_FUNC, Bind_BoundTuple0 > bind(t_FUNC func)
Definition bdlf_bind.h:1835
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:2481
bdlf::BindUtil::bindR
static Bind< t_RET, t_FUNC, Bind_BoundTuple0 > bindR(t_FUNC func)
Definition bdlf_bind.h:2450
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:3405
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:1941
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:2561
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:2503
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:4239
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:1912
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:3261
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:3806
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:2151
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:1848
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:2899
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:3586
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:3655
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:4013
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:2530
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:1975
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:3128
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:2327
bdlf::BindWrapper
Definition bdlf_bind.h:1319
bdlf::BindWrapper::BindWrapper
BindWrapper(typename bslmf::ForwardingType< t_FUNC >::Type func, const t_BOUND_TUPLE &tuple, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1349
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:1667
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6, P7 &p7) const
Definition bdlf_bind.h:1549
bdlf::BindWrapper::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:1390
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:1742
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3) const
Definition bdlf_bind.h:1462
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:1359
bdlf::BindWrapper::BindWrapper
BindWrapper(const BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE > &original)
Definition bdlf_bind.h:1371
bdlf::BindWrapper::BindWrapper
BindWrapper(bslmf::MovableRef< BindWrapper< t_RET, t_FUNC, t_BOUND_TUPLE > > original) BSLS_KEYWORD_NOEXCEPT
Definition bdlf_bind.h:1378
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:1640
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:1654
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4) const
Definition bdlf_bind.h:1493
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:1342
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2) const
Definition bdlf_bind.h:1442
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1) const
Definition bdlf_bind.h:1432
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:1601
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2) const
Definition bdlf_bind.h:1452
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4) const
Definition bdlf_bind.h:1483
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:1514
bdlf::BindWrapper::operator->
const bdlf::Bind< t_RET, t_FUNC, t_BOUND_TUPLE > * operator->() const
Definition bdlf_bind.h:1404
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:1710
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:1627
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:1759
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:1681
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:1576
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:1588
bdlf::BindWrapper::operator*
const bdlf::Bind< t_RET, t_FUNC, t_BOUND_TUPLE > & operator*() const
Definition bdlf_bind.h:1397
bdlf::BindWrapper::operator()
ResultType operator()() const
Definition bdlf_bind.h:1412
bdlf::BindWrapper::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3) const
Definition bdlf_bind.h:1472
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:1536
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6) const
Definition bdlf_bind.h:1525
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:1694
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:1613
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:1562
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:1422
bdlf::BindWrapper::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5) const
Definition bdlf_bind.h:1504
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:1725
bdlf::Bind_ArgTupleValue< TYPE & >::value
TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:4589
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:4594
bdlf::Bind_ArgTupleValue< TYPE & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE & > &original)
Definition bdlf_bind.h:4574
bdlf::Bind_ArgTupleValue< TYPE & >::Bind_ArgTupleValue
Bind_ArgTupleValue(TYPE &value)
Definition bdlf_bind.h:4581
bdlf::Bind_ArgTupleValue< TYPE const & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const TYPE &value)
Definition bdlf_bind.h:4619
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:4632
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:4627
bdlf::Bind_ArgTupleValue< TYPE const & >::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE const & > &original)
Definition bdlf_bind.h:4612
bdlf::Bind_ArgTupleValue
Definition bdlf_bind.h:4523
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:4556
bdlf::Bind_ArgTupleValue::Bind_ArgTupleValue
Bind_ArgTupleValue(TYPE value)
Definition bdlf_bind.h:4543
bdlf::Bind_ArgTupleValue::value
STORAGE_TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:4551
bdlf::Bind_ArgTupleValue::Bind_ArgTupleValue
Bind_ArgTupleValue(const Bind_ArgTupleValue< TYPE > &original)
Definition bdlf_bind.h:4536
bdlf::Bind_BoundTupleValue
Definition bdlf_bind.h:1101
bdlf::Bind_BoundTupleValue::value
TYPE & value()
Return a reference to the modifiable object held by this proxy.
Definition bdlf_bind.h:1151
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(bslmf::MovableRef< TYPE > value, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1142
bdlf::Bind_BoundTupleValue::value
const TYPE & value() const
Return a reference to the non-modifiable object held by this proxy.
Definition bdlf_bind.h:1156
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(const TYPE &value, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1134
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(bslmf::MovableRef< Bind_BoundTupleValue< TYPE > > original, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1123
bdlf::Bind_BoundTupleValue::Bind_BoundTupleValue
Bind_BoundTupleValue(const Bind_BoundTupleValue< TYPE > &original, bslma::Allocator *basicAllocator)
Definition bdlf_bind.h:1114
bdlf::Bind_ImplExplicit
Definition bdlf_bind.h:5974
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:6286
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:6271
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(const Bind_ImplExplicit &other, bslma::Allocator *allocator)
Definition bdlf_bind.h:6087
bdlf::Bind_ImplExplicit::ResultType
Traits::ResultType ResultType
The return type of this binder object.
Definition bdlf_bind.h:5983
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:6219
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) const
Definition bdlf_bind.h:6184
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:6195
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1) const
Definition bdlf_bind.h:6129
bdlf::Bind_ImplExplicit::Bind_ImplExplicit
Bind_ImplExplicit(bslmf::MovableRef< Bind_ImplExplicit > other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:6094
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:6173
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2) const
Definition bdlf_bind.h:6140
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:6207
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3, P4 p4) const
Definition bdlf_bind.h:6162
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:6244
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:6231
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:6257
bdlf::Bind_ImplExplicit::operator()
ResultType operator()() const
Definition bdlf_bind.h:6119
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:6069
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:6079
bdlf::Bind_ImplExplicit::operator()
ResultType operator()(P1 p1, P2 p2, P3 p3) const
Definition bdlf_bind.h:6151
bdlf::Bind_ImplExplicit::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:6111
bdlf::Bind_Impl
Definition bdlf_bind.h:5385
bdlf::Bind_Impl::ResultType
Traits::ResultType ResultType
Definition bdlf_bind.h:5394
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:5580
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:5927
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:5780
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:5869
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:5747
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:5798
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:5454
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4) const
Definition bdlf_bind.h:5592
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1) const
Definition bdlf_bind.h:5520
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5, P6 &p6) const
Definition bdlf_bind.h:5644
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:5686
bdlf::Bind_Impl::operator()
ResultType operator()() const
Definition bdlf_bind.h:5508
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3) const
Definition bdlf_bind.h:5568
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:5446
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:5702
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:5732
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:5764
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:5887
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:5630
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(const Bind_Impl &other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5472
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:5657
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2, P3 &p3, P4 &p4, P5 &p5) const
Definition bdlf_bind.h:5618
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2) const
Definition bdlf_bind.h:5556
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:5716
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:5832
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1, P2 const &p2, P3 const &p3, P4 const &p4) const
Definition bdlf_bind.h:5604
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:5672
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:5909
bdlf::Bind_Impl::invoke
ResultType invoke(t_ARG_TUPLE &arguments) const
Definition bdlf_bind.h:5500
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:5814
bdlf::Bind_Impl::operator()
ResultType operator()(P1 &p1, P2 &p2) const
Definition bdlf_bind.h:5544
bdlf::Bind_Impl::Bind_Impl
Bind_Impl(bslmf::MovableRef< Bind_Impl > other, bslma::Allocator *basicAllocator=0)
Definition bdlf_bind.h:5483
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:5848
bdlf::Bind_Impl::operator()
ResultType operator()(P1 const &p1) const
Definition bdlf_bind.h:5532
bdlf::Bind_MemFnObjectWrapper
Definition bdlf_bind.h:6999
bdlf::Bind_MemFnObjectWrapper::Bind_MemFnObjectWrapper
Bind_MemFnObjectWrapper(t_ARG_TYPE &object)
Definition bdlf_bind.h:7045
bdlf::Bind_MemFnObjectWrapper::operator*
t_TYPE & operator*() const
Definition bdlf_bind.h:7063
bdlf::Bind_MemFnObjectWrapper::Bind_MemFnObjectWrapper
Bind_MemFnObjectWrapper(BSLMF_MOVABLEREF_DEDUCE(t_ARG_TYPE) object)
Definition bdlf_bind.h:7052
bdlf::Bind_MemFnObjectWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper, bslmf::HasPointerSemantics)
bdlf::Bind_MemFnObjectWrapper::BSLMF_NESTED_TRAIT_DECLARATION
BSLMF_NESTED_TRAIT_DECLARATION(Bind_MemFnObjectWrapper, bslmf::IsBitwiseMoveable)
bdlf::Bind
Definition bdlf_bind.h:1233
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:1267
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:1243
bdlf::Bind::Bind
Bind(const Bind &other, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1278
bdlf::Bind::Bind
Bind(bslmf::MovableRef< Bind > other, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1292
bdlf::MemFn
Definition bdlf_memfn.h:283
bsl::function
Forward declaration.
Definition bslstl_function.h:946
bsl::shared_ptr
Definition bslstl_sharedptr.h:1838
bsl::shared_ptr::ptr
element_type * ptr() const BSLS_KEYWORD_NOEXCEPT
Definition bslstl_sharedptr.h:5779
bsl::shared_ptr::createInplace
void createInplace()
Definition bslstl_sharedptr.h:5539
bslalg::ConstructorProxy
Definition bslalg_constructorproxy.h:376
bslalg::ConstructorProxy::object
OBJECT_TYPE & object() BSLS_KEYWORD_NOEXCEPT
Return a reference to the modifiable object held by this proxy.
Definition bslalg_constructorproxy.h:1197
bslma::Allocator
Definition bslma_allocator.h:545
bslmf::ForwardingRefType::Type
Imp::Type Type
Definition bslmf_forwardingreftype.h:274
bslmf::ForwardingType
Definition bslmf_forwardingtype.h:430
bslmf::ForwardingType::Type
Imp::Type Type
Definition bslmf_forwardingtype.h:441
bslmf::MovableRef
Definition bslmf_movableref.h:752
BDLF_BIND_EVAL
#define BDLF_BIND_EVAL(N)
Definition bdlf_bind.h:8686
BDLF_BIND_PARAMINDEX
#define BDLF_BIND_PARAMINDEX(N)
Definition bdlf_bind.h:7144
BSLMF_ASSERT
#define BSLMF_ASSERT(expr)
Definition bslmf_assert.h:231
BSLMF_MOVABLEREF_DEDUCE
#define BSLMF_MOVABLEREF_DEDUCE(...)
Definition bslmf_movableref.h:691
BSLS_COMPILERFEATURES_FORWARD_REF
#define BSLS_COMPILERFEATURES_FORWARD_REF(T)
Definition bsls_compilerfeatures.h:2343
BSLS_COMPILERFEATURES_FORWARD
#define BSLS_COMPILERFEATURES_FORWARD(T, V)
Definition bsls_compilerfeatures.h:2349
BSLS_IDENT
#define BSLS_IDENT(str)
BSLS_IDENT() - insert string into .comment binary segment (if supported)
Definition bsls_ident.h:238
BSLS_KEYWORD_NOEXCEPT
#define BSLS_KEYWORD_NOEXCEPT
Definition bsls_keyword.h:674
bdlf
Definition bdlf_bind.h:979
bsl
Definition bdlat_valuetypefunctions.h:939
bslmf
Definition bdlbb_blob.h:579
bdlf::Bind_ArgTuple0
This struct provides the creators for a list of zero arguments.
Definition bdlf_bind.h:4641
bdlf::Bind_ArgTuple0::Bind_ArgTuple0
Bind_ArgTuple0(const Bind_ArgTuple0 &)
Definition bdlf_bind.h:4647
bdlf::Bind_ArgTuple0::Bind_ArgTuple0
Bind_ArgTuple0()
Definition bdlf_bind.h:4644
bdlf::Bind_ArgTuple10
This struct stores a list of ten arguments.
Definition bdlf_bind.h:5015
bdlf::Bind_ArgTuple10::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5025
bdlf::Bind_ArgTuple10::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5019
bdlf::Bind_ArgTuple10::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5024
bdlf::Bind_ArgTuple10::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5030
bdlf::Bind_ArgTuple10::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5031
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:5057
bdlf::Bind_ArgTuple10::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5033
bdlf::Bind_ArgTuple10::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5023
bdlf::Bind_ArgTuple10::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5027
bdlf::Bind_ArgTuple10::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5034
bdlf::Bind_ArgTuple10::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5039
bdlf::Bind_ArgTuple10::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5026
bdlf::Bind_ArgTuple10::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5037
bdlf::Bind_ArgTuple10::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5036
bdlf::Bind_ArgTuple10::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5038
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:5042
bdlf::Bind_ArgTuple10::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5032
bdlf::Bind_ArgTuple10::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5035
bdlf::Bind_ArgTuple10::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5018
bdlf::Bind_ArgTuple10::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5022
bdlf::Bind_ArgTuple10::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5021
bdlf::Bind_ArgTuple10::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5020
bdlf::Bind_ArgTuple11
This struct stores a list of eleven arguments.
Definition bdlf_bind.h:5077
bdlf::Bind_ArgTuple11::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5099
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:5122
bdlf::Bind_ArgTuple11::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5094
bdlf::Bind_ArgTuple11::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5081
bdlf::Bind_ArgTuple11::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5103
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:5106
bdlf::Bind_ArgTuple11::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5097
bdlf::Bind_ArgTuple11::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5098
bdlf::Bind_ArgTuple11::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5085
bdlf::Bind_ArgTuple11::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5096
bdlf::Bind_ArgTuple11::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5088
bdlf::Bind_ArgTuple11::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5084
bdlf::Bind_ArgTuple11::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5090
bdlf::Bind_ArgTuple11::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5086
bdlf::Bind_ArgTuple11::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5100
bdlf::Bind_ArgTuple11::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5087
bdlf::Bind_ArgTuple11::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5082
bdlf::Bind_ArgTuple11::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5095
bdlf::Bind_ArgTuple11::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5101
bdlf::Bind_ArgTuple11::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5102
bdlf::Bind_ArgTuple11::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5083
bdlf::Bind_ArgTuple11::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5080
bdlf::Bind_ArgTuple11::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5089
bdlf::Bind_ArgTuple11::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5093
bdlf::Bind_ArgTuple12
This struct stores a list of twelve arguments.
Definition bdlf_bind.h:5144
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:5175
bdlf::Bind_ArgTuple12::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5150
bdlf::Bind_ArgTuple12::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5156
bdlf::Bind_ArgTuple12::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5157
bdlf::Bind_ArgTuple12::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5170
bdlf::Bind_ArgTuple12::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5148
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:5192
bdlf::Bind_ArgTuple12::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5161
bdlf::Bind_ArgTuple12::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5169
bdlf::Bind_ArgTuple12::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5172
bdlf::Bind_ArgTuple12::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5166
bdlf::Bind_ArgTuple12::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5153
bdlf::Bind_ArgTuple12::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5149
bdlf::Bind_ArgTuple12::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5164
bdlf::Bind_ArgTuple12::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5158
bdlf::Bind_ArgTuple12::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5163
bdlf::Bind_ArgTuple12::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5165
bdlf::Bind_ArgTuple12::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5152
bdlf::Bind_ArgTuple12::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5155
bdlf::Bind_ArgTuple12::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5171
bdlf::Bind_ArgTuple12::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5168
bdlf::Bind_ArgTuple12::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5154
bdlf::Bind_ArgTuple12::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5151
bdlf::Bind_ArgTuple12::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5147
bdlf::Bind_ArgTuple12::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5167
bdlf::Bind_ArgTuple12::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5162
bdlf::Bind_ArgTuple13
This struct stores a list of thirteen arguments.
Definition bdlf_bind.h:5215
bdlf::Bind_ArgTuple13::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5244
bdlf::Bind_ArgTuple13::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5240
bdlf::Bind_ArgTuple13::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5243
bdlf::Bind_ArgTuple13::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5221
bdlf::Bind_ArgTuple13::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5239
bdlf::Bind_ArgTuple13::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5236
bdlf::Bind_ArgTuple13::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5233
bdlf::Bind_ArgTuple13::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5242
bdlf::Bind_ArgTuple13::FA13
bslmf::ForwardingType< A13 >::Type FA13
Definition bdlf_bind.h:5230
bdlf::Bind_ArgTuple13::d_a13
Bind_ArgTupleValue< FA13 > d_a13
Definition bdlf_bind.h:5245
bdlf::Bind_ArgTuple13::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5222
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:5266
bdlf::Bind_ArgTuple13::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5235
bdlf::Bind_ArgTuple13::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5234
bdlf::Bind_ArgTuple13::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5241
bdlf::Bind_ArgTuple13::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5229
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:5248
bdlf::Bind_ArgTuple13::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5224
bdlf::Bind_ArgTuple13::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5238
bdlf::Bind_ArgTuple13::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5223
bdlf::Bind_ArgTuple13::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5228
bdlf::Bind_ArgTuple13::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5220
bdlf::Bind_ArgTuple13::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5219
bdlf::Bind_ArgTuple13::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5237
bdlf::Bind_ArgTuple13::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5226
bdlf::Bind_ArgTuple13::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5227
bdlf::Bind_ArgTuple13::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5225
bdlf::Bind_ArgTuple13::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5218
bdlf::Bind_ArgTuple14
This struct stores a list of fourteen arguments.
Definition bdlf_bind.h:5291
bdlf::Bind_ArgTuple14::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:5297
bdlf::Bind_ArgTuple14::FA10
bslmf::ForwardingType< A10 >::Type FA10
Definition bdlf_bind.h:5303
bdlf::Bind_ArgTuple14::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:5299
bdlf::Bind_ArgTuple14::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:5294
bdlf::Bind_ArgTuple14::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:5310
bdlf::Bind_ArgTuple14::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:5296
bdlf::Bind_ArgTuple14::d_a13
Bind_ArgTupleValue< FA13 > d_a13
Definition bdlf_bind.h:5322
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:5326
bdlf::Bind_ArgTuple14::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:5301
bdlf::Bind_ArgTuple14::FA12
bslmf::ForwardingType< A12 >::Type FA12
Definition bdlf_bind.h:5305
bdlf::Bind_ArgTuple14::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:5316
bdlf::Bind_ArgTuple14::d_a10
Bind_ArgTupleValue< FA10 > d_a10
Definition bdlf_bind.h:5319
bdlf::Bind_ArgTuple14::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:5312
bdlf::Bind_ArgTuple14::d_a11
Bind_ArgTupleValue< FA11 > d_a11
Definition bdlf_bind.h:5320
bdlf::Bind_ArgTuple14::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:5314
bdlf::Bind_ArgTuple14::d_a14
Bind_ArgTupleValue< FA14 > d_a14
Definition bdlf_bind.h:5323
bdlf::Bind_ArgTuple14::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:5302
bdlf::Bind_ArgTuple14::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:5311
bdlf::Bind_ArgTuple14::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:5298
bdlf::Bind_ArgTuple14::FA11
bslmf::ForwardingType< A11 >::Type FA11
Definition bdlf_bind.h:5304
bdlf::Bind_ArgTuple14::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:5313
bdlf::Bind_ArgTuple14::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:5295
bdlf::Bind_ArgTuple14::FA14
bslmf::ForwardingType< A14 >::Type FA14
Definition bdlf_bind.h:5307
bdlf::Bind_ArgTuple14::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:5315
bdlf::Bind_ArgTuple14::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:5318
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:5345
bdlf::Bind_ArgTuple14::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:5300
bdlf::Bind_ArgTuple14::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:5317
bdlf::Bind_ArgTuple14::d_a12
Bind_ArgTupleValue< FA12 > d_a12
Definition bdlf_bind.h:5321
bdlf::Bind_ArgTuple14::FA13
bslmf::ForwardingType< A13 >::Type FA13
Definition bdlf_bind.h:5306
bdlf::Bind_ArgTuple1
This struct stores a list of one argument.
Definition bdlf_bind.h:4655
bdlf::Bind_ArgTuple1::Bind_ArgTuple1
Bind_ArgTuple1(FA1 a1)
Definition bdlf_bind.h:4669
bdlf::Bind_ArgTuple1::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4661
bdlf::Bind_ArgTuple1::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4658
bdlf::Bind_ArgTuple1::Bind_ArgTuple1
Bind_ArgTuple1(const Bind_ArgTuple1< A1 > &orig)
Definition bdlf_bind.h:4664
bdlf::Bind_ArgTuple2
This struct stores a list of two arguments.
Definition bdlf_bind.h:4678
bdlf::Bind_ArgTuple2::Bind_ArgTuple2
Bind_ArgTuple2(FA1 a1, FA2 a2)
Definition bdlf_bind.h:4695
bdlf::Bind_ArgTuple2::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4685
bdlf::Bind_ArgTuple2::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4681
bdlf::Bind_ArgTuple2::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4682
bdlf::Bind_ArgTuple2::Bind_ArgTuple2
Bind_ArgTuple2(const Bind_ArgTuple2< A1, A2 > &orig)
Definition bdlf_bind.h:4689
bdlf::Bind_ArgTuple2::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4686
bdlf::Bind_ArgTuple3
This struct stores a list of three arguments.
Definition bdlf_bind.h:4705
bdlf::Bind_ArgTuple3::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4713
bdlf::Bind_ArgTuple3::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4708
bdlf::Bind_ArgTuple3::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4714
bdlf::Bind_ArgTuple3::Bind_ArgTuple3
Bind_ArgTuple3(FA1 a1, FA2 a2, FA3 a3)
Definition bdlf_bind.h:4725
bdlf::Bind_ArgTuple3::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4710
bdlf::Bind_ArgTuple3::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4715
bdlf::Bind_ArgTuple3::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4709
bdlf::Bind_ArgTuple3::Bind_ArgTuple3
Bind_ArgTuple3(const Bind_ArgTuple3< A1, A2, A3 > &orig)
Definition bdlf_bind.h:4718
bdlf::Bind_ArgTuple4
This struct stores a list of four arguments.
Definition bdlf_bind.h:4736
bdlf::Bind_ArgTuple4::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4741
bdlf::Bind_ArgTuple4::Bind_ArgTuple4
Bind_ArgTuple4(FA1 a1, FA2 a2, FA3 a3, FA4 a4)
Definition bdlf_bind.h:4759
bdlf::Bind_ArgTuple4::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4742
bdlf::Bind_ArgTuple4::Bind_ArgTuple4
Bind_ArgTuple4(const Bind_ArgTuple4< A1, A2, A3, A4 > &orig)
Definition bdlf_bind.h:4751
bdlf::Bind_ArgTuple4::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4746
bdlf::Bind_ArgTuple4::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4739
bdlf::Bind_ArgTuple4::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4748
bdlf::Bind_ArgTuple4::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4747
bdlf::Bind_ArgTuple4::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4745
bdlf::Bind_ArgTuple4::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4740
bdlf::Bind_ArgTuple5
This struct stores a list of five arguments.
Definition bdlf_bind.h:4771
bdlf::Bind_ArgTuple5::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4782
bdlf::Bind_ArgTuple5::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4781
bdlf::Bind_ArgTuple5::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4785
bdlf::Bind_ArgTuple5::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4774
bdlf::Bind_ArgTuple5::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4777
bdlf::Bind_ArgTuple5::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4778
bdlf::Bind_ArgTuple5::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4775
bdlf::Bind_ArgTuple5::Bind_ArgTuple5
Bind_ArgTuple5(const Bind_ArgTuple5< A1, A2, A3, A4, A5 > &orig)
Definition bdlf_bind.h:4788
bdlf::Bind_ArgTuple5::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4783
bdlf::Bind_ArgTuple5::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4776
bdlf::Bind_ArgTuple5::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4784
bdlf::Bind_ArgTuple5::Bind_ArgTuple5
Bind_ArgTuple5(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5)
Definition bdlf_bind.h:4797
bdlf::Bind_ArgTuple6
This struct stores a list of six arguments.
Definition bdlf_bind.h:4810
bdlf::Bind_ArgTuple6::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4817
bdlf::Bind_ArgTuple6::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4825
bdlf::Bind_ArgTuple6::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4813
bdlf::Bind_ArgTuple6::Bind_ArgTuple6
Bind_ArgTuple6(FA1 a1, FA2 a2, FA3 a3, FA4 a4, FA5 a5, FA6 a6)
Definition bdlf_bind.h:4839
bdlf::Bind_ArgTuple6::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4818
bdlf::Bind_ArgTuple6::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4815
bdlf::Bind_ArgTuple6::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4826
bdlf::Bind_ArgTuple6::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4822
bdlf::Bind_ArgTuple6::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4814
bdlf::Bind_ArgTuple6::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4816
bdlf::Bind_ArgTuple6::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4821
bdlf::Bind_ArgTuple6::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4823
bdlf::Bind_ArgTuple6::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4824
bdlf::Bind_ArgTuple6::Bind_ArgTuple6
Bind_ArgTuple6(const Bind_ArgTuple6< A1, A2, A3, A4, A5, A6 > &orig)
Definition bdlf_bind.h:4829
bdlf::Bind_ArgTuple7
This struct stores a list of seven arguments.
Definition bdlf_bind.h:4853
bdlf::Bind_ArgTuple7::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4867
bdlf::Bind_ArgTuple7::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4861
bdlf::Bind_ArgTuple7::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4857
bdlf::Bind_ArgTuple7::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4858
bdlf::Bind_ArgTuple7::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4871
bdlf::Bind_ArgTuple7::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4856
bdlf::Bind_ArgTuple7::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4869
bdlf::Bind_ArgTuple7::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4859
bdlf::Bind_ArgTuple7::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4868
bdlf::Bind_ArgTuple7::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4862
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:4886
bdlf::Bind_ArgTuple7::Bind_ArgTuple7
Bind_ArgTuple7(const Bind_ArgTuple7< A1, A2, A3, A4, A5, A6, A7 > &orig)
Definition bdlf_bind.h:4875
bdlf::Bind_ArgTuple7::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4860
bdlf::Bind_ArgTuple7::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4866
bdlf::Bind_ArgTuple7::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4870
bdlf::Bind_ArgTuple7::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4865
bdlf::Bind_ArgTuple8
This struct stores a list of eight arguments.
Definition bdlf_bind.h:4902
bdlf::Bind_ArgTuple8::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4911
bdlf::Bind_ArgTuple8::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4916
bdlf::Bind_ArgTuple8::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4915
bdlf::Bind_ArgTuple8::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4909
bdlf::Bind_ArgTuple8::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4919
bdlf::Bind_ArgTuple8::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4906
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:4938
bdlf::Bind_ArgTuple8::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4917
bdlf::Bind_ArgTuple8::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4920
bdlf::Bind_ArgTuple8::Bind_ArgTuple8
Bind_ArgTuple8(const Bind_ArgTuple8< A1, A2, A3, A4, A5, A6, A7, A8 > &orig)
Definition bdlf_bind.h:4926
bdlf::Bind_ArgTuple8::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4921
bdlf::Bind_ArgTuple8::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4907
bdlf::Bind_ArgTuple8::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4905
bdlf::Bind_ArgTuple8::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4910
bdlf::Bind_ArgTuple8::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4918
bdlf::Bind_ArgTuple8::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:4922
bdlf::Bind_ArgTuple8::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4908
bdlf::Bind_ArgTuple8::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:4912
bdlf::Bind_ArgTuple9
This struct stores a list of nine arguments.
Definition bdlf_bind.h:4956
bdlf::Bind_ArgTuple9::FA8
bslmf::ForwardingType< A8 >::Type FA8
Definition bdlf_bind.h:4966
bdlf::Bind_ArgTuple9::FA7
bslmf::ForwardingType< A7 >::Type FA7
Definition bdlf_bind.h:4965
bdlf::Bind_ArgTuple9::d_a8
Bind_ArgTupleValue< FA8 > d_a8
Definition bdlf_bind.h:4977
bdlf::Bind_ArgTuple9::d_a5
Bind_ArgTupleValue< FA5 > d_a5
Definition bdlf_bind.h:4974
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:4995
bdlf::Bind_ArgTuple9::FA1
bslmf::ForwardingType< A1 >::Type FA1
Definition bdlf_bind.h:4959
bdlf::Bind_ArgTuple9::FA5
bslmf::ForwardingType< A5 >::Type FA5
Definition bdlf_bind.h:4963
bdlf::Bind_ArgTuple9::d_a4
Bind_ArgTupleValue< FA4 > d_a4
Definition bdlf_bind.h:4973
bdlf::Bind_ArgTuple9::d_a1
Bind_ArgTupleValue< FA1 > d_a1
Definition bdlf_bind.h:4970
bdlf::Bind_ArgTuple9::FA4
bslmf::ForwardingType< A4 >::Type FA4
Definition bdlf_bind.h:4962
bdlf::Bind_ArgTuple9::FA3
bslmf::ForwardingType< A3 >::Type FA3
Definition bdlf_bind.h:4961
bdlf::Bind_ArgTuple9::FA6
bslmf::ForwardingType< A6 >::Type FA6
Definition bdlf_bind.h:4964
bdlf::Bind_ArgTuple9::d_a2
Bind_ArgTupleValue< FA2 > d_a2
Definition bdlf_bind.h:4971
bdlf::Bind_ArgTuple9::FA9
bslmf::ForwardingType< A9 >::Type FA9
Definition bdlf_bind.h:4967
bdlf::Bind_ArgTuple9::d_a3
Bind_ArgTupleValue< FA3 > d_a3
Definition bdlf_bind.h:4972
bdlf::Bind_ArgTuple9::d_a9
Bind_ArgTupleValue< FA9 > d_a9
Definition bdlf_bind.h:4978
bdlf::Bind_ArgTuple9::Bind_ArgTuple9
Bind_ArgTuple9(const Bind_ArgTuple9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > &orig)
Definition bdlf_bind.h:4982
bdlf::Bind_ArgTuple9::d_a7
Bind_ArgTupleValue< FA7 > d_a7
Definition bdlf_bind.h:4976
bdlf::Bind_ArgTuple9::d_a6
Bind_ArgTupleValue< FA6 > d_a6
Definition bdlf_bind.h:4975
bdlf::Bind_ArgTuple9::FA2
bslmf::ForwardingType< A2 >::Type FA2
Definition bdlf_bind.h:4960
bdlf::Bind_BoundTuple0
This struct provides the creators for a list of zero arguments.
Definition bdlf_bind.h:1164
bdlf::Bind_BoundTuple0::Bind_BoundTuple0
Bind_BoundTuple0(const Bind_BoundTuple0 &, bslma::Allocator *=0)
Definition bdlf_bind.h:1175
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:1171
bdlf::Bind_BoundTuple10
Definition bdlf_bind.h:7960
bdlf::Bind_BoundTuple10::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7982
bdlf::Bind_BoundTuple10::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:7985
bdlf::Bind_BoundTuple10::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7979
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:8056
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:7989
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:8005
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:7981
bdlf::Bind_BoundTuple10::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7984
bdlf::Bind_BoundTuple10::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7980
bdlf::Bind_BoundTuple10::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7977
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:8032
bdlf::Bind_BoundTuple10::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7978
bdlf::Bind_BoundTuple10::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7983
bdlf::Bind_BoundTuple10::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:7986
bdlf::Bind_BoundTuple11
Definition bdlf_bind.h:8087
bdlf::Bind_BoundTuple11::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8113
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:8118
bdlf::Bind_BoundTuple11::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8107
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:8190
bdlf::Bind_BoundTuple11::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8115
bdlf::Bind_BoundTuple11::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8111
bdlf::Bind_BoundTuple11::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8110
bdlf::Bind_BoundTuple11::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8112
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:8135
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:8106
bdlf::Bind_BoundTuple11::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8105
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:8164
bdlf::Bind_BoundTuple11::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8114
bdlf::Bind_BoundTuple11::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8109
bdlf::Bind_BoundTuple11::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8108
bdlf::Bind_BoundTuple12
Definition bdlf_bind.h:8223
bdlf::Bind_BoundTuple12::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8251
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:8256
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:8305
bdlf::Bind_BoundTuple12::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8242
bdlf::Bind_BoundTuple12::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8243
bdlf::Bind_BoundTuple12::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8245
bdlf::Bind_BoundTuple12::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8246
bdlf::Bind_BoundTuple12::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8249
bdlf::Bind_BoundTuple12::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8248
bdlf::Bind_BoundTuple12::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8250
bdlf::Bind_BoundTuple12::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8247
bdlf::Bind_BoundTuple12::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8253
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:8333
bdlf::Bind_BoundTuple12::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8244
bdlf::Bind_BoundTuple12::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8252
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:8274
bdlf::Bind_BoundTuple13
Definition bdlf_bind.h:8369
bdlf::Bind_BoundTuple13::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8395
bdlf::Bind_BoundTuple13::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8399
bdlf::Bind_BoundTuple13::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8393
bdlf::Bind_BoundTuple13::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8397
bdlf::Bind_BoundTuple13::d_a13
Bind_BoundTupleValue< A13 > d_a13
Definition bdlf_bind.h:8401
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:8404
bdlf::Bind_BoundTuple13::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8390
bdlf::Bind_BoundTuple13::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8389
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:8486
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:8456
bdlf::Bind_BoundTuple13::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8396
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:8423
bdlf::Bind_BoundTuple13::d_a10
Bind_BoundTupleValue< A10 > d_a10
Definition bdlf_bind.h:8398
bdlf::Bind_BoundTuple13::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8400
bdlf::Bind_BoundTuple13::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8392
bdlf::Bind_BoundTuple13::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8391
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:8394
bdlf::Bind_BoundTuple14
Definition bdlf_bind.h:8524
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:8648
bdlf::Bind_BoundTuple14::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:8547
bdlf::Bind_BoundTuple14::d_a14
Bind_BoundTupleValue< A14 > d_a14
Definition bdlf_bind.h:8558
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:8561
bdlf::Bind_BoundTuple14::d_a11
Bind_BoundTupleValue< A11 > d_a11
Definition bdlf_bind.h:8555
bdlf::Bind_BoundTuple14::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:8548
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:8554
bdlf::Bind_BoundTuple14::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:8550
bdlf::Bind_BoundTuple14::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:8551
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:8616
bdlf::Bind_BoundTuple14::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:8545
bdlf::Bind_BoundTuple14::d_a9
Bind_BoundTupleValue< A9 > d_a9
Definition bdlf_bind.h:8553
bdlf::Bind_BoundTuple14::d_a13
Bind_BoundTupleValue< A13 > d_a13
Definition bdlf_bind.h:8557
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:8581
bdlf::Bind_BoundTuple14::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:8546
bdlf::Bind_BoundTuple14::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:8552
bdlf::Bind_BoundTuple14::d_a12
Bind_BoundTupleValue< A12 > d_a12
Definition bdlf_bind.h:8556
bdlf::Bind_BoundTuple14::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:8549
bdlf::Bind_BoundTuple1
Definition bdlf_bind.h:1185
bdlf::Bind_BoundTuple1::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:1193
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:1202
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(const Bind_BoundTuple1< A1 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1196
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(bslmf::MovableRef< A1 > a1, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1215
bdlf::Bind_BoundTuple1::Bind_BoundTuple1
Bind_BoundTuple1(A1 const &a1, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:1210
bdlf::Bind_BoundTuple2
Definition bdlf_bind.h:7282
bdlf::Bind_BoundTuple2::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7291
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(A1 const &a1, A2 const &a2, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7312
bdlf::Bind_BoundTuple2::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7292
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:7302
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(const Bind_BoundTuple2< A1, A2 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7295
bdlf::Bind_BoundTuple2::Bind_BoundTuple2
Bind_BoundTuple2(bslmf::MovableRef< A1 > a1, bslmf::MovableRef< A2 > a2, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7320
bdlf::Bind_BoundTuple3
Definition bdlf_bind.h:7334
bdlf::Bind_BoundTuple3::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7346
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:7379
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(bslmf::MovableRef< Bind_BoundTuple3< A1, A2, A3 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7357
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:7349
bdlf::Bind_BoundTuple3::Bind_BoundTuple3
Bind_BoundTuple3(A1 const &a1, A2 const &a2, A3 const &a3, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7369
bdlf::Bind_BoundTuple3::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7344
bdlf::Bind_BoundTuple3::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7345
bdlf::Bind_BoundTuple4
Definition bdlf_bind.h:7395
bdlf::Bind_BoundTuple4::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7407
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(const Bind_BoundTuple4< A1, A2, A3, A4 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7412
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:7447
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:7406
bdlf::Bind_BoundTuple4::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7409
bdlf::Bind_BoundTuple4::Bind_BoundTuple4
Bind_BoundTuple4(bslmf::MovableRef< Bind_BoundTuple4< A1, A2, A3, A4 > > orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7421
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:7435
bdlf::Bind_BoundTuple4::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7408
bdlf::Bind_BoundTuple5
Definition bdlf_bind.h:7465
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:7494
bdlf::Bind_BoundTuple5::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7479
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:7481
bdlf::Bind_BoundTuple5::Bind_BoundTuple5
Bind_BoundTuple5(const Bind_BoundTuple5< A1, A2, A3, A4, A5 > &orig, bslma::Allocator *allocator=0)
Definition bdlf_bind.h:7484
bdlf::Bind_BoundTuple5::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7478
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:7524
bdlf::Bind_BoundTuple5::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7477
bdlf::Bind_BoundTuple5::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7480
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:7510
bdlf::Bind_BoundTuple6
Definition bdlf_bind.h:7544
bdlf::Bind_BoundTuple6::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7559
bdlf::Bind_BoundTuple6::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7561
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:7576
bdlf::Bind_BoundTuple6::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7562
bdlf::Bind_BoundTuple6::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7557
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:7595
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:7560
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:7611
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:7565
bdlf::Bind_BoundTuple6::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7558
bdlf::Bind_BoundTuple7
Definition bdlf_bind.h:7633
bdlf::Bind_BoundTuple7::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7651
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:7650
bdlf::Bind_BoundTuple7::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7653
bdlf::Bind_BoundTuple7::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7649
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:7669
bdlf::Bind_BoundTuple7::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7648
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:7690
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:7708
bdlf::Bind_BoundTuple7::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7652
bdlf::Bind_BoundTuple7::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7647
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:7656
bdlf::Bind_BoundTuple8
Definition bdlf_bind.h:7733
bdlf::Bind_BoundTuple8::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7751
bdlf::Bind_BoundTuple8::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7755
bdlf::Bind_BoundTuple8::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7753
bdlf::Bind_BoundTuple8::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7752
bdlf::Bind_BoundTuple8::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7754
bdlf::Bind_BoundTuple8::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7748
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:7815
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:7795
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:7758
bdlf::Bind_BoundTuple8::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7749
bdlf::Bind_BoundTuple8::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7750
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:7772
bdlf::Bind_BoundTuple9
Definition bdlf_bind.h:7842
bdlf::Bind_BoundTuple9::d_a1
Bind_BoundTupleValue< A1 > d_a1
Definition bdlf_bind.h:7858
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:7866
bdlf::Bind_BoundTuple9::d_a7
Bind_BoundTupleValue< A7 > d_a7
Definition bdlf_bind.h:7864
bdlf::Bind_BoundTuple9::d_a5
Bind_BoundTupleValue< A5 > d_a5
Definition bdlf_bind.h:7862
bdlf::Bind_BoundTuple9::d_a8
Bind_BoundTupleValue< A8 > d_a8
Definition bdlf_bind.h:7865
bdlf::Bind_BoundTuple9::d_a4
Bind_BoundTupleValue< A4 > d_a4
Definition bdlf_bind.h:7861
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:7869
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:7909
bdlf::Bind_BoundTuple9::d_a2
Bind_BoundTupleValue< A2 > d_a2
Definition bdlf_bind.h:7859
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:7884
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:7931
bdlf::Bind_BoundTuple9::d_a6
Bind_BoundTupleValue< A6 > d_a6
Definition bdlf_bind.h:7863
bdlf::Bind_BoundTuple9::d_a3
Bind_BoundTupleValue< A3 > d_a3
Definition bdlf_bind.h:7860
bdlf::Bind_CalcParameterMask
Definition bdlf_bind.h:7167
bdlf::Bind_CalcParameterMask::Type8
t_BOUND_TUPLE::template TypeOf< 8 >::TypeOrDefault Type8
Definition bdlf_bind.h:7176
bdlf::Bind_CalcParameterMask::Type2
t_BOUND_TUPLE::template TypeOf< 2 >::TypeOrDefault Type2
Definition bdlf_bind.h:7170
bdlf::Bind_CalcParameterMask::Type10
t_BOUND_TUPLE::template TypeOf< 10 >::TypeOrDefault Type10
Definition bdlf_bind.h:7178
bdlf::Bind_CalcParameterMask::Type6
t_BOUND_TUPLE::template TypeOf< 6 >::TypeOrDefault Type6
Definition bdlf_bind.h:7174
bdlf::Bind_CalcParameterMask::Type3
t_BOUND_TUPLE::template TypeOf< 3 >::TypeOrDefault Type3
Definition bdlf_bind.h:7171
bdlf::Bind_CalcParameterMask::Type4
t_BOUND_TUPLE::template TypeOf< 4 >::TypeOrDefault Type4
Definition bdlf_bind.h:7172
bdlf::Bind_CalcParameterMask::k_PARAM_MASK
@ k_PARAM_MASK
Definition bdlf_bind.h:7205
bdlf::Bind_CalcParameterMask::k_PARAMINDEX10
@ k_PARAMINDEX10
Definition bdlf_bind.h:7260
bdlf::Bind_CalcParameterMask::k_PARAM8
@ k_PARAM8
Definition bdlf_bind.h:7192
bdlf::Bind_CalcParameterMask::k_PARAM2
@ k_PARAM2
Definition bdlf_bind.h:7186
bdlf::Bind_CalcParameterMask::k_PARAM3
@ k_PARAM3
Definition bdlf_bind.h:7187
bdlf::Bind_CalcParameterMask::k_PARAMINDEX13
@ k_PARAMINDEX13
Definition bdlf_bind.h:7263
bdlf::Bind_CalcParameterMask::k_PARAM4
@ k_PARAM4
Definition bdlf_bind.h:7188
bdlf::Bind_CalcParameterMask::k_PARAM13
@ k_PARAM13
Definition bdlf_bind.h:7197
bdlf::Bind_CalcParameterMask::k_PARAM7
@ k_PARAM7
Definition bdlf_bind.h:7191
bdlf::Bind_CalcParameterMask::k_PARAMINDEX7
@ k_PARAMINDEX7
Definition bdlf_bind.h:7257
bdlf::Bind_CalcParameterMask::k_PARAMINDEX5
@ k_PARAMINDEX5
Definition bdlf_bind.h:7255
bdlf::Bind_CalcParameterMask::k_PARAMINDEX9
@ k_PARAMINDEX9
Definition bdlf_bind.h:7259
bdlf::Bind_CalcParameterMask::k_PARAM5
@ k_PARAM5
Definition bdlf_bind.h:7189
bdlf::Bind_CalcParameterMask::k_PARAM11
@ k_PARAM11
Definition bdlf_bind.h:7195
bdlf::Bind_CalcParameterMask::k_PARAMINDEX11
@ k_PARAMINDEX11
Definition bdlf_bind.h:7261
bdlf::Bind_CalcParameterMask::k_PARAMINDEX12
@ k_PARAMINDEX12
Definition bdlf_bind.h:7262
bdlf::Bind_CalcParameterMask::k_PARAMINDEX14
@ k_PARAMINDEX14
Definition bdlf_bind.h:7264
bdlf::Bind_CalcParameterMask::k_PARAM_MASK2
@ k_PARAM_MASK2
Definition bdlf_bind.h:7221
bdlf::Bind_CalcParameterMask::k_PARAMINDEX8
@ k_PARAMINDEX8
Definition bdlf_bind.h:7258
bdlf::Bind_CalcParameterMask::k_PARAM10
@ k_PARAM10
Definition bdlf_bind.h:7194
bdlf::Bind_CalcParameterMask::k_PARAM6
@ k_PARAM6
Definition bdlf_bind.h:7190
bdlf::Bind_CalcParameterMask::k_PARAMINDEX1
@ k_PARAMINDEX1
Definition bdlf_bind.h:7251
bdlf::Bind_CalcParameterMask::k_PARAMINDEX6
@ k_PARAMINDEX6
Definition bdlf_bind.h:7256
bdlf::Bind_CalcParameterMask::k_PARAMINDEX2
@ k_PARAMINDEX2
Definition bdlf_bind.h:7252
bdlf::Bind_CalcParameterMask::k_PARAM14
@ k_PARAM14
Definition bdlf_bind.h:7198
bdlf::Bind_CalcParameterMask::k_PARAM1
@ k_PARAM1
Definition bdlf_bind.h:7185
bdlf::Bind_CalcParameterMask::k_IS_EXPLICIT
@ k_IS_EXPLICIT
Definition bdlf_bind.h:7240
bdlf::Bind_CalcParameterMask::k_PARAMINDEX4
@ k_PARAMINDEX4
Definition bdlf_bind.h:7254
bdlf::Bind_CalcParameterMask::k_PARAM9
@ k_PARAM9
Definition bdlf_bind.h:7193
bdlf::Bind_CalcParameterMask::k_PARAM12
@ k_PARAM12
Definition bdlf_bind.h:7196
bdlf::Bind_CalcParameterMask::k_PARAMINDEX3
@ k_PARAMINDEX3
Definition bdlf_bind.h:7253
bdlf::Bind_CalcParameterMask::Type1
t_BOUND_TUPLE::template TypeOf< 1 >::TypeOrDefault Type1
Definition bdlf_bind.h:7169
bdlf::Bind_CalcParameterMask::Type7
t_BOUND_TUPLE::template TypeOf< 7 >::TypeOrDefault Type7
Definition bdlf_bind.h:7175
bdlf::Bind_CalcParameterMask::Type13
t_BOUND_TUPLE::template TypeOf< 13 >::TypeOrDefault Type13
Definition bdlf_bind.h:7181
bdlf::Bind_CalcParameterMask::Type12
t_BOUND_TUPLE::template TypeOf< 12 >::TypeOrDefault Type12
Definition bdlf_bind.h:7180
bdlf::Bind_CalcParameterMask::Type14
t_BOUND_TUPLE::template TypeOf< 14 >::TypeOrDefault Type14
Definition bdlf_bind.h:7182
bdlf::Bind_CalcParameterMask::Type9
t_BOUND_TUPLE::template TypeOf< 9 >::TypeOrDefault Type9
Definition bdlf_bind.h:7177
bdlf::Bind_CalcParameterMask::Type11
t_BOUND_TUPLE::template TypeOf< 11 >::TypeOrDefault Type11
Definition bdlf_bind.h:7179
bdlf::Bind_CalcParameterMask::Type5
t_BOUND_TUPLE::template TypeOf< 5 >::TypeOrDefault Type5
Definition bdlf_bind.h:7173
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:9283
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:9265
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:9158
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:9186
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:9214
bdlf::Bind_Evaluator< PlaceHolder< t_INDEX >, t_ARG_TUPLE >::ReturnType
bslmf::ForwardingType< ReturnType_Impl >::Type ReturnType
Definition bdlf_bind.h:9152
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:9235
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:9165
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:9221
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:9207
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:9242
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:9228
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:9193
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:9200
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:9172
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:9249
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:9151
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:9179
bdlf::Bind_Evaluator
Definition bdlf_bind.h:9127
bdlf::Bind_Evaluator::eval
static BoundType eval(t_ARG_TUPLE &, BoundType value)
Return the specified value.
Definition bdlf_bind.h:9135
bdlf::Bind_Evaluator::BoundType
bslmf::ForwardingRefType< BoundType_Impl >::Type BoundType
Definition bdlf_bind.h:9131
bdlf::Bind_Evaluator::BoundType_Impl
bslmf::ArrayToConstPointer< t_BOUND_TUPLE_ELEMENT >::Type BoundType_Impl
Definition bdlf_bind.h:9130
bdlf::Bind_FuncTraitsHasNoEllipsis
Definition bdlf_bind.h:6348
bdlf::Bind_FuncTraitsHasNoEllipsis::k_VAL
@ k_VAL
Definition bdlf_bind.h:6351
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::Type
bsl::function< PROTO > Type
Definition bdlf_bind.h:6786
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::ResultType
bsl::function< PROTO >::result_type ResultType
Definition bdlf_bind.h:6788
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO >, 0, 0, 0 >::WrapperType
bsl::function< PROTO > WrapperType
Definition bdlf_bind.h:6787
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::ResultType
bsl::function< PROTO >::result_type ResultType
Definition bdlf_bind.h:6824
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::Type
bsl::function< PROTO > Type
Definition bdlf_bind.h:6822
bdlf::Bind_FuncTraitsImp< bslmf::Nil, bsl::function< PROTO > *, 0, 0, 0 >::WrapperType
bsl::function< PROTO > * WrapperType
Definition bdlf_bind.h:6823
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6769
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::ResultType
Bind_FuncTraitsImp_OneResultTypeOrAnother< t_FUNC >::type ResultType
Definition bdlf_bind.h:6771
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6768
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::Type
t_FUNC Type
Definition bdlf_bind.h:6746
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::ResultType
bslmf::MemberFunctionPointerTraits< t_FUNC >::ResultType ResultType
Definition bdlf_bind.h:6749
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::FuncArgumentList
bslmf::MemberFunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6751
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 0, 1 >::WrapperType
MemFn< t_FUNC > WrapperType
Definition bdlf_bind.h:6747
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::ResultType
bslmf::FunctionPointerTraits< t_FUNC >::ResultType ResultType
Definition bdlf_bind.h:6728
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6725
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6730
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 0, 1, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6726
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC * >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6709
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6704
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6705
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC, 1, 0, 0 >::ResultType
bslmf::FunctionPointerTraits< t_FUNC * >::ResultType ResultType
Definition bdlf_bind.h:6707
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::ResultType
Bind_FuncTraitsImp_OneResultTypeOrAnother< t_FUNC >::type ResultType
Definition bdlf_bind.h:6807
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6804
bdlf::Bind_FuncTraitsImp< bslmf::Nil, t_FUNC *, 0, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6805
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6669
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6670
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6671
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::FuncArgumentList
bslmf::MemberFunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6654
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::WrapperType
MemFn< t_FUNC > WrapperType
Definition bdlf_bind.h:6651
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6652
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 0, 1 >::Type
t_FUNC Type
Definition bdlf_bind.h:6650
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6632
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6634
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6630
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 0, 1, 0 >::WrapperType
t_FUNC WrapperType
Definition bdlf_bind.h:6631
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6611
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::FuncArgumentList
bslmf::FunctionPointerTraits< t_FUNC * >::ArgumentList FuncArgumentList
Definition bdlf_bind.h:6614
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::Type
t_FUNC * Type
Definition bdlf_bind.h:6610
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC, 1, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6612
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::WrapperType
t_FUNC * WrapperType
Definition bdlf_bind.h:6686
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::Type
t_FUNC Type
Definition bdlf_bind.h:6685
bdlf::Bind_FuncTraitsImp< t_RET, t_FUNC *, 0, 0, 0 >::ResultType
t_RET ResultType
Definition bdlf_bind.h:6687
bdlf::Bind_FuncTraitsImp_OneResultTypeOrAnother
Definition bdlf_bind.h:6494
bdlf::Bind_FuncTraitsImp_OneResultTypeOrAnother::type
Result< t_FUNC >::type type
Definition bdlf_bind.h:6570
bdlf::Bind_FuncTraitsImp
Definition bdlf_bind.h:6593
bdlf::Bind_FuncTraits
Definition bdlf_bind.h:6893
bdlf::Bind_ImplSelector
Definition bdlf_bind.h:6315
bdlf::Bind_ImplSelector::k_IS_EXPLICIT
@ k_IS_EXPLICIT
Definition bdlf_bind.h:6319
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:6326
bdlf::Bind_Invoker< t_RET, 0 >::invoke
t_RET invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE &) const
Definition bdlf_bind.h:8696
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:8956
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:8986
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:9018
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:9050
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:9084
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:8716
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:8740
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:8765
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:8790
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:8816
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:8843
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:8870
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:8898
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:8927
bdlf::Bind_Invoker< void, 0 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *, t_ARG_TUPLE &) const
Definition bdlf_bind.h:8706
bdlf::Bind_Invoker< void, 10 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8971
bdlf::Bind_Invoker< void, 11 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9003
bdlf::Bind_Invoker< void, 12 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9035
bdlf::Bind_Invoker< void, 13 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9068
bdlf::Bind_Invoker< void, 14 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:9102
bdlf::Bind_Invoker< void, 1 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8728
bdlf::Bind_Invoker< void, 2 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8753
bdlf::Bind_Invoker< void, 3 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8778
bdlf::Bind_Invoker< void, 4 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8803
bdlf::Bind_Invoker< void, 5 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8830
bdlf::Bind_Invoker< void, 6 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8857
bdlf::Bind_Invoker< void, 7 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8884
bdlf::Bind_Invoker< void, 8 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8913
bdlf::Bind_Invoker< void, 9 >::invoke
void invoke(t_FUNC *func, t_BOUND_TUPLE *boundList, t_ARG_TUPLE &argList) const
Definition bdlf_bind.h:8942
bdlf::Bind_Invoker
Definition bdlf_bind.h:982
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 0, t_IS_MEMBER_OFFSET >::Type
const bslmf::MatchAnyType & Type
Definition bdlf_bind.h:7110
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::ObjectType
Traits::ClassType ObjectType
Definition bdlf_bind.h:7098
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::Type
bslmf::ForwardingType< constBind_MemFnObjectWrapper< ObjectType > & >::Type Type
Definition bdlf_bind.h:7100
bdlf::Bind_MapParameter< t_FUNC, t_FUNC_ARGS, 1, 1 >::Traits
bslmf::MemberFunctionPointerTraits< t_FUNC > Traits
Definition bdlf_bind.h:7097
bdlf::Bind_MapParameter
Definition bdlf_bind.h:7079
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:7086
bdlf::Bind_PlaceHolderIndex
Definition bdlf_bind.h:6964
bdlf::Bind_PlaceHolderIndex::k_VAL
@ k_VAL
Definition bdlf_bind.h:6967
bdlf::Bind_PlaceHolderMask
Definition bdlf_bind.h:6911
bdlf::Bind_PlaceHolderMask::k_VAL
static const int k_VAL
Definition bdlf_bind.h:6912
bdlf::PlaceHolder
Definition bdlf_placeholder.h:77
bsl::conditional
Definition bslmf_conditional.h:123
bsl::integral_constant
Definition bslmf_integralconstant.h:261
bsl::is_nothrow_move_constructible
Definition bslmf_isnothrowmoveconstructible.h:361
bsl::remove_cv::type
remove_const< typenameremove_volatile< t_TYPE >::type >::type type
Definition bslmf_removecv.h:128
bslma::UsesBslmaAllocator
Definition bslma_usesbslmaallocator.h:344
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:147
bslmf::HasPointerSemantics
Definition bslmf_haspointersemantics.h:83
bslmf::IsBitwiseMoveable
Definition bslmf_isbitwisemoveable.h:718
bslmf::MatchAnyType
Definition bslmf_matchanytype.h:152
bslmf::MemberFunctionPointerTraits
Definition bslmf_memberfunctionpointertraits.h:150
bslmf::MovableRefUtil::IsReference
Definition bslmf_movableref.h:821
bslmf::MovableRefUtil_RemoveReference::type
t_TYPE type
Definition bslmf_movableref.h:1188
bslmf::MovableRefUtil
Definition bslmf_movableref.h:795
bslmf::MovableRefUtil::move
static MovableRef< t_TYPE > move(t_TYPE &reference) BSLS_KEYWORD_NOEXCEPT
Definition bslmf_movableref.h:1067
bslmf::Nil
Definition bslmf_nil.h:133
bslmf::ResultType_Fallback::type
t_FALLBACK type
Definition bslmf_resulttype.h:262
bslmf::Tag
Definition bslmf_tag.h:166
bslmf::TypeList0
Definition bslmf_typelist.h:1653
bslmf::TypeList10
Definition bslmf_typelist.h:1872
bslmf::TypeList11
Definition bslmf_typelist.h:1915
bslmf::TypeList12
Definition bslmf_typelist.h:1961
bslmf::TypeList13
Definition bslmf_typelist.h:2010
bslmf::TypeList14
Definition bslmf_typelist.h:2062
bslmf::TypeList1
Definition bslmf_typelist.h:1666
bslmf::TypeList2
Definition bslmf_typelist.h:1683
bslmf::TypeList3
Definition bslmf_typelist.h:1701
bslmf::TypeList4
Definition bslmf_typelist.h:1719
bslmf::TypeList5
Definition bslmf_typelist.h:1736
bslmf::TypeList6
Definition bslmf_typelist.h:1759
bslmf::TypeList7
Definition bslmf_typelist.h:1784
bslmf::TypeList8
Definition bslmf_typelist.h:1811
bslmf::TypeList9
Definition bslmf_typelist.h:1840
bslmf::TypeListTypeOf
Definition bslmf_typelist.h:1631