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

Provides the implementation of a signaler. This object has a 1‐1 relationship with the `Signaler`, which has a shared pointer to it. This allows other objects to refer to it via shared and weak pointers. This allows `SignalerConnection` objects to outlive the `Signaler ‐ Signaler_Node` pair, since they can test or lock weak pointers to see if the `Signaler_Node` still exists when they are trying to disconnect themselves.

== Synopsis

Declared in `<bdlmt_signaler.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<class t_PROT>
class Signaler_Node
    : public xref:bsl/enable_shared_from_this.adoc[bsl::enable_shared_from_this<Signaler_Node<t_PROT>>]
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:bsl/enable_shared_from_this.adoc[bsl::enable_shared_from_this<Signaler_Node<t_PROT>>]`
| This class allows an object that is currently managed by a `shared_ptr` to safely generate a copy of the managing `shared_ptr` object. Inheriting from `enable_shared_from_this<ELEMENT_TYPE>` provides the (template parameter) `ELEMENT_TYPE` type with a member function `shared_from_this`. If an object of type `ELEMENT_TYPE` is managed by a `shared_ptr` then calling `shared_from_this` will return a `shared_ptr<ELEMENT_TYPE>` that shares ownership of that object. It is undefined behavior to call `shared_from_this` on an object unless that object is managed by a `shared_ptr`.
|===

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlmt/Signaler_Node/2constructor.adoc[`Signaler_Node`]         [.small]#[constructor]#
| Create a `Signaler_Node` object having no connected slots. Specify an `allocator` used to supply memory. Note that the supplied allocator must remain valid until all connection objects associated with this signaler are destroyed.
| xref:BloombergLP/bdlmt/Signaler_Node/connect.adoc[`connect`] 
| Implements `Signaler::connect`. Connect the specified `slot`, a callable object which must meet the `Slot Object Requirements` described in the component documentation, to this signaler. Specify a `group` used to order slots upon invocation. Return an instance of `SignalerConnection` representing the created connection. This function meets the strong exception guarantee. Note that the connected slot may be called by a signal emitted from another thread before this function completes. Also note that it is unspecified whether connecting a slot while the signaler is emitting will result in the slot being called immediately. Note that `t_FUNC` may have a return type other than `void`, but in that case, when the slot is called, the return value will be discarded.
| xref:BloombergLP/bdlmt/Signaler_Node/disconnectAllSlots.adoc[`disconnectAllSlots`] 
| Implements `Signaler::disconnectAllSlots()`. Disconnect all slots, if any, connected to this signaler. Any signals emitted on the corresponding signaler that happen after this call to disconnect completes will not call any slots that were connected prior to this call. Throws nothing. Note that this function does not block the calling thread pending completion of ongoing signals emitted on the signaler. Also note that it is unspecified how many slots, if any, will be called by any invocation on the signaler that begins before this function completes. Also note that if a slot is connected to this signaler during a call to this function, it is unspecified whether that slot will be disconnected.
| xref:BloombergLP/bdlmt/Signaler_Node/disconnectAllSlotsAndWait.adoc[`disconnectAllSlotsAndWait`] 
| Implements `Signaler::disconnectAllSlotsAndWait`. Disconnect all slots, if any, connected to this signaler. Any signals emitted on the corresponding signaler that happens after this call to disconnect completes will not call any slots that were connected prior to this call. This function blocks the calling thread pending completion of all ongoing signals being emitted on the signaler. Throws nothing. The behavior is undefined if this method is called from a slot connected to the signaler. Note that it is unspecified how many slots, if any, will be called by any invocation on the signaler that begins before this function completes. Also note that if a slot is connected to this signaler during a call to this function, it is unspecified whether that slot will be disconnected.
| xref:BloombergLP/bdlmt/Signaler_Node/disconnectGroup.adoc[`disconnectGroup`] 
| Implements `Signaler::disconnectGroup()`. Disconnect all slots, if any, connected to this signaler in the specified `group`. Any signal emitted on the corresponding signaler that happens after this call to disconnect completes will not call any slots in `group` that were connected prior to this call. Throws nothing. Note that this function does not block the calling thread pending completion of ongoing signals emitted on the signaler. Also note that it is unspecified how many affected slots, if any, will be signalled to by any invocation on the signaler that begins before this function completes. Also note that if a slot in `group` is connected to this signaler during a call to this function, it is unspecified whether that slot will be disconnected.
| xref:BloombergLP/bdlmt/Signaler_Node/disconnectGroupAndWait.adoc[`disconnectGroupAndWait`] 
| Implements `Signaler::disconnectGroupAndWait()`. Disconnect all slots, if any, connected to this signaler in the specified `group`. Any signal emitted on the corresponding signaler that happens after this call to disconnect completes will not call any slots in `group` that were connected prior to this call. This function blocks the calling thread pending completion of ongoing signals being emitted on the signaler. Throws nothing. The behavior is undefined if this method is called from a slot connected to the signaler. Note that it is unspecified how many affected slots, if any, will be signaled to by any emission on the signaler that begins before this function completes. Also note that if a slot in `group` is connected to this signaler during a call to this function, it is unspecified whether that slot will be disconnected.
| xref:BloombergLP/bdlmt/Signaler_Node/invoke.adoc[`invoke`] 
| Called by `Signaler_Invocable`s call operators, passing the specified `arg1`, `arg2`, `arg3`, `arg4`, `arg5`, `arg6`, `arg7`, `arg8` and `arg9` on to the slots.
| xref:BloombergLP/bdlmt/Signaler_Node/notifyDisconnected.adoc[`notifyDisconnected`] 
| Notify this signaler that a slot with the specified `slotMapKey` was disconnected. Throws nothing.
| xref:bsl/enable_shared_from_this/shared_from_this-0a2.adoc[`shared_from_this`] 
| `shared_from_this` overloads
| xref:BloombergLP/bdlmt/Signaler_Node/slotCount.adoc[`slotCount`] 
| Implements `Signaler::slotCount()`. Return the number of slots connected to this signaler. Note that in multithreaded environment, the value returned by `slotCount()` is approximate.
| xref:BloombergLP/bdlmt/Signaler_Node/synchronizeWait.adoc[`synchronizeWait`] 
| Block until all signals currently being emitted on the signaler have completed.
| xref:bsl/enable_shared_from_this/weak_from_this-0e.adoc[`weak_from_this`] 
| `weak_from_this` overloads
|===


== Protected Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:bsl/enable_shared_from_this/operator_assign.adoc[`operator=`] 
| Return `*this`. This object is unchanged. Note that the specified `rhs` is not used.
|===



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