Struct Sink 

pub struct Sink<T> { /* private fields */ }

A Sink is an object used to create a Stream. If you have ever visited a kitchen or bathroom you have probably observed this phenomena already. In more technical terms, Sinks are the ‘write’ part of functional reactive programming, and Streams are the ‘read’ part.

Examples

use std::sync::{Arc, Mutex};

let stream_host: epoxy_streams::Sink<i32> = epoxy_streams::Sink::new();
let stream = stream_host.get_stream();

let last_value = Arc::new(Mutex::new(0_i32));
let last_value_write = last_value.clone();

let subscription = stream.subscribe(move |val| {
    *last_value_write.lock().unwrap() = *val;
});

stream_host.emit(1);
assert_eq!(*last_value.lock().unwrap(), 1);

stream_host.emit(100);
assert_eq!(*last_value.lock().unwrap(), 100);

Implementations

impl<T> Sink<T>

pub fn new() -> Sink<T>

Examples found in repository

examples/event_stream.rs (line 15)

    pub fn new() -> MyButton {
        MyButton {
            click_host: epoxy::Sink::new(),
        }
    }

pub fn get_stream(&self) -> Stream<T>

Returns the Stream that emits values from this Sink. Usually the Stream will be exposed as a public API while the Sink will be kept private, however there are certainly exceptions to this pattern.

Examples found in repository

examples/event_stream.rs (line 20)

    pub fn get_clicks(&self) -> epoxy::Stream<MouseButton> {
        self.click_host.get_stream()
    }

pub fn emit(&self, value: T)

Emits a new value from this Sink, which will broadcast out to any Subscriber to the stream returned by the get_stream function.

Examples found in repository

examples/event_stream.rs (line 24)

    pub fn click(&self, button: MouseButton) {
        self.click_host.emit(button)
    }

pub fn emit_rc(&self, value: Arc<T>)

Same logic as emit, but takes an existing Arc pointer (Epoxy streams use Arc pointers internally, so this saves a Copy).

Trait Implementations

impl<T> Drop for Sink<T>

fn drop(&mut self)

Executes the destructor for this type.