[#BloombergLP-bdlf]
= xref:BloombergLP.adoc[BloombergLP]::bdlf
:relfileprefix: ../
:mrdocs:

Namespace for function&hyphen;binding utilities&period;

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlf/PlaceHolders.adoc[`PlaceHolders`] 
| Namespace containing placeholder objects `&lowbar;1` through `&lowbar;14` for use with `bdlf&colon;&colon;BindUtil&colon;&colon;bind`&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlf/Bind.adoc[`Bind`] 
| This bind class select the implementation for the given template arguments&period; Note that instances of this class should not be created explicitly, instead use the `BindUtil` factory methods&period;
| xref:BloombergLP/bdlf/BindUtil.adoc[`BindUtil`] 
| This `struct` provides a namespace for utility functions used to construct `Bind` and `BindWrapper` objects&period; Four families of factory methods are provided&colon; `bind`, `bindR`, `bindS`, and `bindSR`&period; All factory methods accept an invocable object, optionally followed by up to fourteen additional arguments&period; Each argument can be either a literal value, a place&hyphen;holder, or another `Bind` or `BindWrapper` object&period;
| xref:BloombergLP/bdlf/BindWrapper.adoc[`BindWrapper`] 
| This wrapper class provides a binder with shared pointer semantics to a non&hyphen;modifiable binder (both `operator&ast;` and `operator&hyphen;&gt;` accessors) and forward its construction arguments to the underlying binder&period; Note that instances of this class should not be created explicitly, instead use the `BindUtil` factory methods&period; Note also that instances of this class can be invoked directly, in order to meet user expectations that the result of `BindUtil&colon;&colon;bind` be an invocable just as the result of `bdlf&colon;&colon;BindUtil&colon;&colon;bind` is&semi; in that case, the invocation parameters are simply forwarded to the shared binder&period; Note finally that even though this wrapper has pointer semantics for the `operator&ast;` and `operator&hyphen;&gt;`, it has value semantics for the invocation&colon; invoking a non&hyphen;modifiable wrapper will forward the invocation to the non&hyphen;modifiable binder shared by that wrapper, even though pointer semantics have it &period;
| xref:BloombergLP/bdlf/Bind_ArgTuple0.adoc[`Bind&lowbar;ArgTuple0`] 
| This `struct` provides the creators for a list of zero arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple1.adoc[`Bind&lowbar;ArgTuple1`] 
| This `struct` stores a list of one argument&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple10.adoc[`Bind&lowbar;ArgTuple10`] 
| This `struct` stores a list of ten arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple11.adoc[`Bind&lowbar;ArgTuple11`] 
| This `struct` stores a list of eleven arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple12.adoc[`Bind&lowbar;ArgTuple12`] 
| This `struct` stores a list of twelve arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple13.adoc[`Bind&lowbar;ArgTuple13`] 
| This `struct` stores a list of thirteen arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple14.adoc[`Bind&lowbar;ArgTuple14`] 
| This `struct` stores a list of fourteen arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple2.adoc[`Bind&lowbar;ArgTuple2`] 
| This `struct` stores a list of two arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple3.adoc[`Bind&lowbar;ArgTuple3`] 
| This `struct` stores a list of three arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple4.adoc[`Bind&lowbar;ArgTuple4`] 
| This `struct` stores a list of four arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple5.adoc[`Bind&lowbar;ArgTuple5`] 
| This `struct` stores a list of five arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple6.adoc[`Bind&lowbar;ArgTuple6`] 
| This `struct` stores a list of six arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple7.adoc[`Bind&lowbar;ArgTuple7`] 
| This `struct` stores a list of seven arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple8.adoc[`Bind&lowbar;ArgTuple8`] 
| This `struct` stores a list of eight arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTuple9.adoc[`Bind&lowbar;ArgTuple9`] 
| This `struct` stores a list of nine arguments&period;
| xref:BloombergLP/bdlf/Bind_ArgTupleValue-0d8.adoc[`Bind&lowbar;ArgTupleValue`] 
| This local class provides storage for a value of the specified `TYPE` suitable for storing an argument value in one of the `Bind&lowbar;ArgTuple&lsqb;0&hyphen;14&rsqb;` local classes&period; `TYPE` must already be a `bslmf&colon;&colon;ForwardingType`, meaning no extra copies will be made (unless the type is a fundamental type, which is meant to be copied for efficiency)&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple0.adoc[`Bind&lowbar;BoundTuple0`] 
| This `struct` provides the creators for a list of zero arguments&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple1.adoc[`Bind&lowbar;BoundTuple1`] 
| This `struct` stores a list of one argument&period; It does _not_ use the const&hyphen;forwarding type of its argument, unlike `Bind&lowbar;ArgTuple1` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple10.adoc[`Bind&lowbar;BoundTuple10`] 
| This `struct` stores a list of ten arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple10` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple11.adoc[`Bind&lowbar;BoundTuple11`] 
| This `struct` stores a list of eleven arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple11` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple12.adoc[`Bind&lowbar;BoundTuple12`] 
| This `struct` stores a list of twelve arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple12` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple13.adoc[`Bind&lowbar;BoundTuple13`] 
| This `struct` stores a list of thirteen arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple13` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple14.adoc[`Bind&lowbar;BoundTuple14`] 
| This `struct` stores a list of fourteen arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple14` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple2.adoc[`Bind&lowbar;BoundTuple2`] 
| This `struct` stores a list of two arguments&period; It does _not_ use the const&hyphen;forwarding type of its argument, unlike `Bind&lowbar;ArgTuple2` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple3.adoc[`Bind&lowbar;BoundTuple3`] 
| This `struct` stores a list of three arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple3` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple4.adoc[`Bind&lowbar;BoundTuple4`] 
| This `struct` stores a list of four arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple4` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple5.adoc[`Bind&lowbar;BoundTuple5`] 
| This `struct` stores a list of five arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple5` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple6.adoc[`Bind&lowbar;BoundTuple6`] 
| This `struct` stores a list of six arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple6` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple7.adoc[`Bind&lowbar;BoundTuple7`] 
| This `struct` stores a list of seven arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple7` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple8.adoc[`Bind&lowbar;BoundTuple8`] 
| This `struct` stores a list of eight arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple8` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTuple9.adoc[`Bind&lowbar;BoundTuple9`] 
| This `struct` stores a list of nine arguments&period; It does _not_ use the const&hyphen;forwarding type of its arguments, unlike `Bind&lowbar;ArgTuple9` which applies that optimization to avoid unnecessary copying&period;
| xref:BloombergLP/bdlf/Bind_BoundTupleValue.adoc[`Bind&lowbar;BoundTupleValue`] 
| This local class provides storage for a value of the specified `TYPE` suitable for storing an argument value in one of the `Bind&lowbar;BoundTuple&ast;` local classes&period; This general template definition ensures that the allocator passed to the creators is passed through to the value if it uses an allocator, using the `bslalg&colon;&colon;ConstructorProxy` mechanism&period;
| xref:BloombergLP/bdlf/Bind_CalcParameterMask.adoc[`Bind&lowbar;CalcParameterMask`] 
| This meta&hyphen;function is used to calculate a mask that indicates which parameters in `t&lowbar;BOUND&lowbar;TUPLE` are place&hyphen;holders and which ones are literal values&period; It is used by `Bind&lowbar;ImplExplicit`&period;
| xref:BloombergLP/bdlf/Bind_Evaluator-0b.adoc[`Bind&lowbar;Evaluator`] 
| Component&hyphen;private utility for evaluating a bound function call&period;
| xref:BloombergLP/bdlf/Bind_FuncTraits.adoc[`Bind&lowbar;FuncTraits`] 
| This `struct` provides various traits of the functor type `t&lowbar;FUNC` documented below&period; If `t&lowbar;RET` is `bslmf&colon;&colon;Nil`, then the return type is inferred by using either `bslmf&colon;&colon;FunctionPointerTraits`, `bslmf&colon;&colon;MemberFunctionPointerTraits`, or `typename t&lowbar;FUNC&colon;&colon;result&lowbar;type` as appropriate&period; &grave; &sol;&sol; ENUMERATIONS enum &lcub; k&lowbar;IS&lowbar;EXPLICIT &sol;&sol; An invocable object is explicit if &period;&period;&period; &sol;&sol; (see &apos;Bind&lowbar;ImplExplicit&apos;)
| xref:BloombergLP/bdlf/Bind_FuncTraitsHasNoEllipsis-0a.adoc[`Bind&lowbar;FuncTraitsHasNoEllipsis`] 
| Determines whether a function type has the ellipsis as an argument&period; This is needed for making the binder non&hyphen;explicit in case of a function pointer, reference, or member function pointer&period; By default, a function does not take an ellipsis unless specialized below&period; This traits class is used in the `Bind&lowbar;FuncTraitsImp` below&period; Note that this meta function is not supported on sun studio 8&period;
| xref:BloombergLP/bdlf/Bind_FuncTraitsImp-05.adoc[`Bind&lowbar;FuncTraitsImp`] 
| This `struct` provides a mechanism for inferring various traits of the function object type `t&lowbar;FUNC`&period; The return type is given by `t&lowbar;RET` unless it is `bslmf&colon;&colon;Nil` in which case it is inferred from `t&lowbar;FUNC`&period; The last three parameters `IS&lowbar;FUNCTION`, `IS&lowbar;FUNCTION&lowbar;POINTER` and `IS&lowbar;MEMBER&lowbar;FUNCTION&lowbar;POINTER` specify whether `t&lowbar;FUNC` is a free function type (either a reference&hyphen;to&hyphen;function or plain function type), a pointer to function type, or a pointer to member function type, respectively&period;
| xref:BloombergLP/bdlf/Bind_FuncTraitsImp_OneResultTypeOrAnother.adoc[`Bind&lowbar;FuncTraitsImp&lowbar;OneResultTypeOrAnother`] 
| Define the type variable `type` to be `t&lowbar;FUNC&colon;&colon;result&lowbar;type` if that exists and `t&lowbar;FUNC&colon;&colon;ResultType` otherwise&period; Additionally, for C&plus;&plus;11 and above, if `t&lowbar;FUNC` has an `operator()` member (such as lambda functions), define `type` to be the return type of that operator&period;
| xref:BloombergLP/bdlf/Bind_Invoker-046.adoc[`Bind&lowbar;Invoker`] 
| Component&hyphen;private invoker for bound function calls&period;
| xref:BloombergLP/bdlf/Bind_MapParameter-0f.adoc[`Bind&lowbar;MapParameter`] 
| This meta&hyphen;function is used to select the type at `t&lowbar;OFFSET` positions of the `t&lowbar;INDEX` position in an argument list type `t&lowbar;FUNC&lowbar;ARGS`, which is of type `bslmf&colon;&colon;TypeList` denoting the arguments of `t&lowbar;FUNC`&period; Note that this class is used by `Bind&lowbar;ImplExplicit`&period;
| xref:BloombergLP/bdlf/Bind_MemFnObjectWrapper.adoc[`Bind&lowbar;MemFnObjectWrapper`] 
| This local class is used to wrap an object used to invoke a member functions bound to a `Bind` binder&period; In explicit binding, the argument types of operator() are determined during `Bind` instantiation&period; If a member function is bound to the binder, and the object to invoke the member function on is passed as an invocation argument (instead of a bound argument), the exact type of the object &hyphen; whether it is a pointer or reference &hyphen; cannot be determined based on the method signature&period; This wrapper serve as an intermediate type to wrap around the object pointer or reference&period; This class is declared to have pointer semantics, such that `MemFn` will properly dereference the object to invoke the member function&period;
| xref:BloombergLP/bdlf/Bind_PlaceHolderIndex-01.adoc[`Bind&lowbar;PlaceHolderIndex`] 
| This template, passed the type of one of the bound arguments to a function object, yields&colon; &ast; if the specified `t&lowbar;BOUND&lowbar;TYPE` is a place holder, the index of the place holder object &ast; zero otherwise
| xref:BloombergLP/bdlf/Bind_PlaceHolderMask-05.adoc[`Bind&lowbar;PlaceHolderMask`] 
| This template, passed the type of one of the bound arguments to a function object, yields&colon; &ast; If the specified `t&lowbar;BOUND&lowbar;TYPE` is a place holder, a mask with the bit at the index of the place holder set&period; &ast; If the specified `t&lowbar;BOUND&lowbar;TYPE` is a `Bind` or `BindWrapper`, a mask with bit 24 set&period; &ast; Zero otherwise&period;
| xref:BloombergLP/bdlf/MemFn.adoc[`MemFn`] 
| This class encapsulates a member function pointer having the parameterized `PROTOTYPE`, such that the member function pointer can be invoked in syntactically the same manner as a free function pointer&period; When invoking a member function through this wrapper, the first argument must be a pointer or reference to the instance on which to invoke the member function pointer&period; Zero to fourteen additional arguments may be specified depending on `PROTOTYPE`&period;
| xref:BloombergLP/bdlf/MemFnInstance.adoc[`MemFnInstance`] 
| This class encapsulates a member function pointer having the parameterized `PROTOTYPE` and a value of the parameterized `INSTANCE` type, which can be either be the type of object referred to by the `PROTOTYPE`, or a pointer to one, such that the member function pointer can be invoked on the wrapped instance in syntactically the same manner as a free function pointer&period; Zero to fourteen additional arguments may be specified depending on the `PROTOTYPE`&period; Note that whether `INSTANCE` is a pointer or an object is determined by whether it has pointer semantics or not (as determined by the `bslmf&colon;&colon;HasPointerSemantics` type trait)&period; Also note that if `INSTANCE` is an object that does not have pointer semantics, `PROTOTYPE` must be const&hyphen;qualified&period;
| xref:BloombergLP/bdlf/MemFnUtil.adoc[`MemFnUtil`] 
| The methods provided in this utility are used for constructing `MemFn` and `MemFnInstance` objects from function pointers&period;
| xref:BloombergLP/bdlf/MemFn_Dereference.adoc[`MemFn&lowbar;Dereference`] 
| This utility is used to convert user supplied values to references to `OBJTYPE` for object references that are directly convertible to `OBJTYPE`, the reference is returned directly&period; For pointers and objects that are not directly convertible (e&period;g&period;, &quot;smart pointers to `OBJTYPE`&quot;), the result of `&ast;OBJECT` is returned, where `OBJECT` is the pointer or object reference&period;
| xref:BloombergLP/bdlf/NoOp-02.adoc[`NoOp`] 
| This functor class provides a function&hyphen;call operator that accepts any number of arguments of any type, does nothing (leaving the arguments unmodified), and returns `void`&period;
| xref:BloombergLP/bdlf/Overloaded-03.adoc[`Overloaded`] 
| `Overloaded` is a structure that holds a series of objects that have an `operator()`, and provides the ability to call one of them determined by the parameters that are passed to the operator&period;
| xref:BloombergLP/bdlf/Overloaded_ConstMemberFunctionPointer.adoc[`Overloaded&lowbar;ConstMemberFunctionPointer`] 
| The class Overloaded&lowbar;ConstMemberFunctionPointer wraps a member function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` that takes an object of the appropriate type and other arguments, and forwards them on to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_ConstNoexceptMemberFunctionPointer.adoc[`Overloaded&lowbar;ConstNoexceptMemberFunctionPointer`] 
| The class Overloaded&lowbar;ConstNoexceptMemberFunctionPointer wraps a member function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` that takes an object of the appropriate type and other arguments, and forwards them on to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_FunctionPointer.adoc[`Overloaded&lowbar;FunctionPointer`] 
| Overloaded&lowbar;FunctionPointer wraps a function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` method that calls through to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_MemberFunctionPointer.adoc[`Overloaded&lowbar;MemberFunctionPointer`] 
| The class Overloaded&lowbar;MemberFunctionPointer wraps a member function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` that takes an object of the appropriate type and other arguments, and forwards them on to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_NoexceptFunctionPointer.adoc[`Overloaded&lowbar;NoexceptFunctionPointer`] 
| Overloaded&lowbar;NoexceptFunctionPointer wraps a function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` method that calls through to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_NoexceptMemberFunctionPointer.adoc[`Overloaded&lowbar;NoexceptMemberFunctionPointer`] 
| The class Overloaded&lowbar;NoexceptMemberFunctionPointer wraps a member function pointer&period; It is implicitly constructible from the pointer, and provides an `operator()` that takes an object of the appropriate type and other arguments, and forwards them on to the underlying function&period;
| xref:BloombergLP/bdlf/Overloaded_Wrapper-073.adoc[`Overloaded&lowbar;Wrapper`] 
| Metafunction that selects the appropriate wrapper type for a callable&period;
| xref:BloombergLP/bdlf/PlaceHolder.adoc[`PlaceHolder`] 
| Placeholder type for the `bdlf&colon;&colon;Bind` argument&hyphen;binding facility&period;
|===


== Variables

[cols="1"]
|===
| Name
| xref:BloombergLP/bdlf/noOp-01.adoc[`noOp`] 
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
