pub fn generic_oneshot_broadcast_channel<MutexType, T>() ->
            (GenericOneshotBroadcastSender<MutexType, T>, GenericOneshotBroadcastReceiver<MutexType, T>)
        where MutexType: RawMutex, T: Send + Clone {
            let inner = std::sync::Arc::new(
                GenericOneshotChannelSharedState {
                    channel: GenericOneshotBroadcastChannel::new(),
                });

            let sender = GenericOneshotBroadcastSender {
                inner: inner.clone(),
            };
            let receiver = GenericOneshotBroadcastReceiver {
                inner,
            };

            (sender, receiver)
        }
/// Creates a new oneshot broadcast channel which can be used to exchange values
/// of type `T` between concurrent tasks.
/// The ends of the Channel are represented through
/// the returned `Sender` and `Receiver`. The `Receiver` can be cloned.
///
/// As soon es either the senders or all receivers is closed, the channel
/// itself will be closed.
///
/// Example for creating a channel to transmit an integer value:
///
/// ```
/// # use futures_intrusive::channel::shared::oneshot_broadcast_channel;
/// let (sender, receiver) = oneshot_broadcast_channel::<i32>();
/// ```
Creates a new oneshot broadcast channel which can be used to exchange values
of type `T` between concurrent tasks.
The ends of the Channel are represented through
the returned `Sender` and `Receiver`. The `Receiver` can be cloned.

As soon es either the senders or all receivers is closed, the channel
itself will be closed.

Example for creating a channel to transmit an integer value.


Creates a new oneshot broadcast channel which can be used to exchange values of type ` T ` between concurrent tasks . The ends of the Channel are represented through the returned ` Sender ` and ` Receiver ` . The ` Receiver ` can be cloned . As soon es either the senders or all receivers is closed the channel itself will be closed . Example for creating a channel to transmit an integer value .
pub fn generic_oneshot_broadcast_channel<MutexType, T>() ->
            (GenericOneshotBroadcastSender<MutexType, T>, GenericOneshotBroadcastReceiver<MutexType, T>)
        where MutexType: RawMutex, T: Send + Clone {
            let inner = std::sync::Arc::new(
                GenericOneshotChannelSharedState {
                    channel: GenericOneshotBroadcastChannel::new(),
                });
            let sender = GenericOneshotBroadcastSender {
                inner: inner.clone(),
            };
            let receiver = GenericOneshotBroadcastReceiver {
                inner,
            };
            (sender, receiver)
        }
pub fn generic_oneshot_broadcast_channel < MutexType , T > ( ) -> ( GenericOneshotBroadcastSender < MutexType , T > , GenericOneshotBroadcastReceiver < MutexType , T > ) where MutexType : RawMutex , T : Send + Clone { let inner = std :: sync :: Arc :: new ( GenericOneshotChannelSharedState { channel : GenericOneshotBroadcastChannel :: new ( ) , } ) ; let sender = GenericOneshotBroadcastSender { inner : inner . clone ( ) , } ; let receiver = GenericOneshotBroadcastReceiver { inner , } ; ( sender , receiver ) }
Creates a new oneshot broadcast channel which can be used to exchange values
of type `T` between concurrent tasks.
Creates a new oneshot broadcast channel which can be used to exchange values of type ` T ` between concurrent tasks .
use futures_intrusive::channel::shared::oneshot_broadcast_channel;
let (sender, receiver) = oneshot_broadcast_channel::();
```
let ( sender receiver ) = oneshot_broadcast_channel :: () ; ` ` `