use observer::Observer;
use observer::{NextObserver, CompletedObserver, ErrorObserver, OptionObserver, ResultObserver};
use std::fmt::Debug;
pub trait Observable {
type Item: Clone;
type Error: Clone;
type Subscription: Drop;
fn subscribe<O>(&mut self, observer: O) -> Self::Subscription
where O: Observer<Self::Item, Self::Error>;
fn subscribe_next<FnNext>(&mut self,
on_next: FnNext)
-> Self::Subscription
where Self::Error: Debug, FnNext: FnMut(Self::Item) {
let observer = NextObserver {
fn_next: on_next,
};
self.subscribe(observer)
}
fn subscribe_completed<FnNext, FnCompleted>(&mut self,
on_next: FnNext,
on_completed: FnCompleted)
-> Self::Subscription
where Self::Error: Debug, FnNext: FnMut(Self::Item), FnCompleted: FnOnce() {
let observer = CompletedObserver {
fn_next: on_next,
fn_completed: on_completed,
};
self.subscribe(observer)
}
fn subscribe_error<FnNext, FnCompleted, FnError>(&mut self,
on_next: FnNext,
on_completed: FnCompleted,
on_error: FnError)
-> Self::Subscription
where FnNext: FnMut(Self::Item), FnCompleted: FnOnce(), FnError: FnOnce(Self::Error) {
let observer = ErrorObserver {
fn_next: on_next,
fn_completed: on_completed,
fn_error: on_error,
};
self.subscribe(observer)
}
fn subscribe_option<FnOption>(&mut self,
on_next_or_completed: FnOption)
-> Self::Subscription
where Self::Error: Debug, FnOption: FnMut(Option<Self::Item>) {
let observer = OptionObserver {
fn_option: on_next_or_completed
};
self.subscribe(observer)
}
fn subscribe_result<FnResult>(&mut self,
on_next_or_completed_or_error: FnResult)
-> Self::Subscription
where FnResult: FnMut(Result<Option<Self::Item>, Self::Error>) {
let observer = ResultObserver {
fn_result: on_next_or_completed_or_error
};
self.subscribe(observer)
}
}