Struct carboxyl::Sink
+
+ [−]
+
+ [src]
+pub struct Sink<A> {
+ // some fields omitted
+}An event sink.
+ +This primitive is a way of generating streams of events. One can send +input values into a sink and generate a stream that fires all these inputs +as events:
++// A new sink +let sink = Sink::new(); + +// Make an iterator over a stream. +let mut events = sink.stream().events(); + +// Send a value into the sink +sink.send(5); + +// The stream +assert_eq!(events.next(), Some(5)); ++ +
You can also feed a sink with an iterator:
++sink.feed(20..40); +assert_eq!(events.take(4).collect::<Vec<_>>(), vec![20, 21, 22, 23]); ++ +
Asynchronous calls
+It is possible to send events into the sink asynchronously using the methods
+send_async and feed_async. Note though, that this will void some
+guarantees on the order of events. In the following example, it is unclear,
+which event is the first in the stream:
+let sink = Sink::new(); +let mut events = sink.stream().events(); +sink.send_async(13); +sink.send_async(22); +let first = events.next().unwrap(); +assert!(first == 13 || first == 22); ++ +
feed_async provides a workaround, as it preserves the order of events from
+the iterator. However, any event sent into the sink after a call to it, may
+come at any point between the iterator events.
Methods
impl<A: Send + Sync> Sink<A>
fn new() -> Sink<A>
+Create a new sink.
+fn stream(&self) -> Stream<A>
+Generate a stream that fires all events sent into the sink.
+impl<A: Send + Sync + Clone + 'static> Sink<A>
fn send_async(&self, a: A)
+Asynchronous send.
+ +Same as send, but it spawns a new thread to process the updates to
+dependent streams and signals.
fn feed<I: IntoIterator<Item=A>>(&self, iterator: I)
+Feed values from an iterator into the sink.
+ +This method feeds events into the sink from an iterator.
+fn feed_async<I: IntoIterator<Item=A> + Send + 'static>(&self, iterator: I)
+Asynchronous feed.
+ +This is the same as feed, but it does not block, since it spawns the
+feeding as a new task. This is useful, if the provided iterator is large
+or even infinite (e.g. an I/O event loop).
fn send(&self, a: A)
+Send a value into the sink.
+ +When a value is sent into the sink, an event is fired in all dependent +streams.
+