1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
//! A multi-producer, single-consumer queue for sending values across //! asynchronous tasks. //! //! Similar to `std`, channel creation provides [`Receiver`] and [`Sender`] //! handles. [`Receiver`] implements `Stream` and allows a task to read values //! out of the channel. If there is no message to read, the current task will be //! notified when a new value is sent. [`Sender`] implements the `Sink` trait //! and allows sending messages into the channel. If the channel is at capacity, //! the send is rejected and the task will be notified when additional capacity //! is available. In other words, the channel provides backpressure. //! //! Unbounded channels are also available using the `unbounded_channel` //! constructor. //! //! # Disconnection //! //! When all [`Sender`] handles have been dropped, it is no longer //! possible to send values into the channel. This is considered the termination //! event of the stream. As such, `Receiver::poll` returns `Ok(Ready(None))`. //! //! If the [`Receiver`] handle is dropped, then messages can no longer //! be read out of the channel. In this case, all further attempts to send will //! result in an error. //! //! # Clean Shutdown //! //! When the [`Receiver`] is dropped, it is possible for unprocessed messages to //! remain in the channel. Instead, it is usually desirable to perform a "clean" //! shutdown. To do this, the receiver first calls `close`, which will prevent //! any further messages to be sent into the channel. Then, the receiver //! consumes the channel to completion, at which point the receiver can be //! dropped. //! //! [`Sender`]: struct.Sender.html //! [`Receiver`]: struct.Receiver.html mod block; mod bounded; mod chan; mod list; mod unbounded; pub use self::bounded::{channel, Receiver, Sender}; pub use self::unbounded::{unbounded_channel, UnboundedReceiver, UnboundedSender}; pub mod error { //! Channel error types pub use super::bounded::{RecvError, SendError, TrySendError}; pub use super::unbounded::{UnboundedRecvError, UnboundedSendError, UnboundedTrySendError}; } /// The number of values a block can contain. /// /// This value must be a power of 2. It also must be smaller than the number of /// bits in `usize`. #[cfg(target_pointer_width = "64")] const BLOCK_CAP: usize = 32; #[cfg(not(target_pointer_width = "64"))] const BLOCK_CAP: usize = 16;