michael/rust-dominator
michael
/
rust-dominator
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Renaming List to Vec

This commit is contained in:
Pauan 2018-02-28 01:42:36 -10:00
parent 05024a80b4
commit 1cc8c7e14f
1 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
signals/src/signal_vec.rs
View File

@ -28,7 +28,7 @@ fn decrement_indexes(indexes: &mut [Option<usize>]) {
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum ListChange<A> { pub enum VecChange<A> {
Replace { Replace {
values: Vec<A>, values: Vec<A>,
}, },
@ -62,27 +62,27 @@ pub enum ListChange<A> {
Clear {}, Clear {},
} }
impl<A> ListChange<A> { impl<A> VecChange<A> {
// TODO inline this ? // TODO inline this ?
fn map<B, F>(self, mut callback: F) -> ListChange<B> where F: FnMut(A) -> B { fn map<B, F>(self, mut callback: F) -> VecChange<B> where F: FnMut(A) -> B {
match self { match self {
// TODO figure out a more efficient way of implementing this // TODO figure out a more efficient way of implementing this
ListChange::Replace { values } => ListChange::Replace { values: values.into_iter().map(callback).collect() }, VecChange::Replace { values } => VecChange::Replace { values: values.into_iter().map(callback).collect() },
ListChange::InsertAt { index, value } => ListChange::InsertAt { index, value: callback(value) }, VecChange::InsertAt { index, value } => VecChange::InsertAt { index, value: callback(value) },
ListChange::UpdateAt { index, value } => ListChange::UpdateAt { index, value: callback(value) }, VecChange::UpdateAt { index, value } => VecChange::UpdateAt { index, value: callback(value) },
ListChange::RemoveAt { index } => ListChange::RemoveAt { index }, VecChange::RemoveAt { index } => VecChange::RemoveAt { index },
ListChange::Push { value } => ListChange::Push { value: callback(value) }, VecChange::Push { value } => VecChange::Push { value: callback(value) },
ListChange::Pop {} => ListChange::Pop {}, VecChange::Pop {} => VecChange::Pop {},
ListChange::Clear {} => ListChange::Clear {}, VecChange::Clear {} => VecChange::Clear {},
} }
} }
} }
pub trait SignalList { pub trait SignalVec {
type Item; type Item;
fn poll(&mut self) -> Async<Option<ListChange<Self::Item>>>; fn poll(&mut self) -> Async<Option<VecChange<Self::Item>>>;
#[inline] #[inline]
fn map<A, F>(self, callback: F) -> Map<Self, F> fn map<A, F>(self, callback: F) -> Map<Self, F>
@ -107,8 +107,8 @@ pub trait SignalList {
} }
#[inline] #[inline]
fn to_stream(self) -> SignalListStream<Self> where Self: Sized { fn to_stream(self) -> SignalVecStream<Self> where Self: Sized {
SignalListStream { SignalVecStream {
signal: self, signal: self,
} }
} }
@ -125,25 +125,25 @@ pub struct Map<A, B> {
callback: B, callback: B,
} }
impl<A, B, F> SignalList for Map<A, F> impl<A, B, F> SignalVec for Map<A, F>
where A: SignalList, where A: SignalVec,
F: FnMut(A::Item) -> B { F: FnMut(A::Item) -> B {
type Item = B; type Item = B;
// TODO should this inline ? // TODO should this inline ?
#[inline] #[inline]
fn poll(&mut self) -> Async<Option<ListChange<Self::Item>>> { fn poll(&mut self) -> Async<Option<VecChange<Self::Item>>> {
self.signal.poll().map(|some| some.map(|change| change.map(|value| (self.callback)(value)))) self.signal.poll().map(|some| some.map(|change| change.map(|value| (self.callback)(value))))
} }
} }
pub struct SignalListStream<A> { pub struct SignalVecStream<A> {
signal: A, signal: A,
} }
impl<A: SignalList> Stream for SignalListStream<A> { impl<A: SignalVec> Stream for SignalVecStream<A> {
type Item = ListChange<A::Item>; type Item = VecChange<A::Item>;
type Error = (); type Error = ();
#[inline] #[inline]
@ -163,23 +163,23 @@ pub struct FilterMap<A, B> {
callback: B, callback: B,
} }
impl<A, B, F> SignalList for FilterMap<A, F> impl<A, B, F> SignalVec for FilterMap<A, F>
where A: SignalList, where A: SignalVec,
F: FnMut(A::Item) -> Option<B> { F: FnMut(A::Item) -> Option<B> {
type Item = B; type Item = B;
// TODO figure out a faster implementation of this // TODO figure out a faster implementation of this
fn poll(&mut self) -> Async<Option<ListChange<Self::Item>>> { fn poll(&mut self) -> Async<Option<VecChange<Self::Item>>> {
loop { loop {
return match self.signal.poll() { return match self.signal.poll() {
Async::NotReady => return Async::NotReady, Async::NotReady => return Async::NotReady,
Async::Ready(None) => return Async::Ready(None), Async::Ready(None) => return Async::Ready(None),
Async::Ready(Some(change)) => match change { Async::Ready(Some(change)) => match change {
ListChange::Replace { values } => { VecChange::Replace { values } => {
self.length = 0; self.length = 0;
self.indexes = Vec::with_capacity(values.len()); self.indexes = Vec::with_capacity(values.len());
Async::Ready(Some(ListChange::Replace { Async::Ready(Some(VecChange::Replace {
values: values.into_iter().filter_map(|value| { values: values.into_iter().filter_map(|value| {
let value = (self.callback)(value); let value = (self.callback)(value);
@ -198,7 +198,7 @@ impl<A, B, F> SignalList for FilterMap<A, F>
})) }))
}, },
ListChange::InsertAt { index, value } => { VecChange::InsertAt { index, value } => {
match (self.callback)(value) { match (self.callback)(value) {
Some(value) => { Some(value) => {
let new_index = increment_indexes(&mut self.indexes[index..]).unwrap_or(self.length); let new_index = increment_indexes(&mut self.indexes[index..]).unwrap_or(self.length);
@ -206,7 +206,7 @@ impl<A, B, F> SignalList for FilterMap<A, F>
self.indexes.insert(index, Some(new_index)); self.indexes.insert(index, Some(new_index));
self.length += 1; self.length += 1;
Async::Ready(Some(ListChange::InsertAt { index: new_index, value })) Async::Ready(Some(VecChange::InsertAt { index: new_index, value }))
}, },
None => { None => {
self.indexes.insert(index, None); self.indexes.insert(index, None);
@ -215,12 +215,12 @@ impl<A, B, F> SignalList for FilterMap<A, F>
} }
}, },
ListChange::UpdateAt { index, value } => { VecChange::UpdateAt { index, value } => {
match (self.callback)(value) { match (self.callback)(value) {
Some(value) => { Some(value) => {
match self.indexes[index] { match self.indexes[index] {
Some(old_index) => { Some(old_index) => {
Async::Ready(Some(ListChange::UpdateAt { index: old_index, value })) Async::Ready(Some(VecChange::UpdateAt { index: old_index, value }))
}, },
None => { None => {
let new_index = increment_indexes(&mut self.indexes[(index + 1)..]).unwrap_or(self.length); let new_index = increment_indexes(&mut self.indexes[(index + 1)..]).unwrap_or(self.length);
@ -228,7 +228,7 @@ impl<A, B, F> SignalList for FilterMap<A, F>
self.indexes[index] = Some(new_index); self.indexes[index] = Some(new_index);
self.length += 1; self.length += 1;
Async::Ready(Some(ListChange::InsertAt { index: new_index, value })) Async::Ready(Some(VecChange::InsertAt { index: new_index, value }))
}, },
} }
}, },
@ -240,7 +240,7 @@ impl<A, B, F> SignalList for FilterMap<A, F>
decrement_indexes(&mut self.indexes[(index + 1)..]); decrement_indexes(&mut self.indexes[(index + 1)..]);
self.length -= 1; self.length -= 1;
Async::Ready(Some(ListChange::RemoveAt { index: old_index })) Async::Ready(Some(VecChange::RemoveAt { index: old_index }))
}, },
None => { None => {
continue; continue;
@ -250,13 +250,13 @@ impl<A, B, F> SignalList for FilterMap<A, F>
} }
}, },
ListChange::RemoveAt { index } => { VecChange::RemoveAt { index } => {
match self.indexes.remove(index) { match self.indexes.remove(index) {
Some(old_index) => { Some(old_index) => {
decrement_indexes(&mut self.indexes[index..]); decrement_indexes(&mut self.indexes[index..]);
self.length -= 1; self.length -= 1;
Async::Ready(Some(ListChange::RemoveAt { index: old_index })) Async::Ready(Some(VecChange::RemoveAt { index: old_index }))
}, },
None => { None => {
continue; continue;
@ -264,12 +264,12 @@ impl<A, B, F> SignalList for FilterMap<A, F>
} }
}, },
ListChange::Push { value } => { VecChange::Push { value } => {
match (self.callback)(value) { match (self.callback)(value) {
Some(value) => { Some(value) => {
self.indexes.push(Some(self.length)); self.indexes.push(Some(self.length));
self.length += 1; self.length += 1;
Async::Ready(Some(ListChange::Push { value })) Async::Ready(Some(VecChange::Push { value }))
}, },
None => { None => {
self.indexes.push(None); self.indexes.push(None);
@ -278,10 +278,10 @@ impl<A, B, F> SignalList for FilterMap<A, F>
} }
}, },
ListChange::Pop {} => { VecChange::Pop {} => {
match self.indexes.pop().expect("Cannot pop from empty vec") { match self.indexes.pop().expect("Cannot pop from empty vec") {
Some(_) => { Some(_) => {
Async::Ready(Some(ListChange::Pop {})) Async::Ready(Some(VecChange::Pop {}))
}, },
None => { None => {
continue; continue;
@ -289,10 +289,10 @@ impl<A, B, F> SignalList for FilterMap<A, F>
} }
}, },
ListChange::Clear {} => { VecChange::Clear {} => {
self.length = 0; self.length = 0;
self.indexes = vec![]; self.indexes = vec![];
Async::Ready(Some(ListChange::Clear {})) Async::Ready(Some(VecChange::Clear {}))
}, },
}, },
} }
@ -307,21 +307,21 @@ mod tests {
use super::*; use super::*;
struct Tester<A> { struct Tester<A> {
changes: Vec<Async<ListChange<A>>>, changes: Vec<Async<VecChange<A>>>,
} }
impl<A> Tester<A> { impl<A> Tester<A> {
#[inline] #[inline]
fn new(changes: Vec<Async<ListChange<A>>>) -> Self { fn new(changes: Vec<Async<VecChange<A>>>) -> Self {
Self { changes } Self { changes }
} }
} }
impl<A> SignalList for Tester<A> { impl<A> SignalVec for Tester<A> {
type Item = A; type Item = A;
#[inline] #[inline]
fn poll(&mut self) -> Async<Option<ListChange<Self::Item>>> { fn poll(&mut self) -> Async<Option<VecChange<Self::Item>>> {
if self.changes.len() > 0 { if self.changes.len() > 0 {
match self.changes.remove(0) { match self.changes.remove(0) {
Async::NotReady => { Async::NotReady => {
@ -339,20 +339,20 @@ mod tests {
struct TesterFuture<A, B> { struct TesterFuture<A, B> {
signal_list: A, signal: A,
callback: B, callback: B,
} }
impl<A: SignalList, B: FnMut(&mut A, ListChange<A::Item>)> TesterFuture<A, B> { impl<A: SignalVec, B: FnMut(&mut A, VecChange<A::Item>)> TesterFuture<A, B> {
#[inline] #[inline]
fn new(signal_list: A, callback: B) -> Self { fn new(signal: A, callback: B) -> Self {
Self { signal_list, callback } Self { signal, callback }
} }
} }
impl<A, B> Future for TesterFuture<A, B> impl<A, B> Future for TesterFuture<A, B>
where A: SignalList, where A: SignalVec,
B: FnMut(&mut A, ListChange<A::Item>) { B: FnMut(&mut A, VecChange<A::Item>) {
type Item = (); type Item = ();
type Error = (); type Error = ();
@ -360,9 +360,9 @@ mod tests {
#[inline] #[inline]
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop { loop {
return match self.signal_list.poll() { return match self.signal.poll() {
Async::Ready(Some(change)) => { Async::Ready(Some(change)) => {
(self.callback)(&mut self.signal_list, change); (self.callback)(&mut self.signal, change);
continue; continue;
}, },
Async::Ready(None) => Ok(Async::Ready(())), Async::Ready(None) => Ok(Async::Ready(())),
@ -372,10 +372,10 @@ mod tests {
} }
} }
fn run<A: SignalList, B: FnMut(&mut A, ListChange<A::Item>) -> C, C>(signal_list: A, mut callback: B) -> Vec<C> { fn run<A: SignalVec, B: FnMut(&mut A, VecChange<A::Item>) -> C, C>(signal: A, mut callback: B) -> Vec<C> {
let mut changes = vec![]; let mut changes = vec![];
TesterFuture::new(signal_list, |signal, change| { TesterFuture::new(signal, |signal, change| {
changes.push(callback(signal, change)); changes.push(callback(signal, change));
}).wait().unwrap(); }).wait().unwrap();
@ -389,40 +389,40 @@ mod tests {
struct Change { struct Change {
length: usize, length: usize,
indexes: Vec<Option<usize>>, indexes: Vec<Option<usize>>,
change: ListChange<u32>, change: VecChange<u32>,
} }
let input = Tester::new(vec![ let input = Tester::new(vec![
Async::Ready(ListChange::Replace { values: vec![0, 1, 2, 3, 4, 5] }), Async::Ready(VecChange::Replace { values: vec![0, 1, 2, 3, 4, 5] }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 0, value: 6 }), Async::Ready(VecChange::InsertAt { index: 0, value: 6 }),
Async::Ready(ListChange::InsertAt { index: 2, value: 7 }), Async::Ready(VecChange::InsertAt { index: 2, value: 7 }),
Async::NotReady, Async::NotReady,
Async::NotReady, Async::NotReady,
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 5, value: 8 }), Async::Ready(VecChange::InsertAt { index: 5, value: 8 }),
Async::Ready(ListChange::InsertAt { index: 7, value: 9 }), Async::Ready(VecChange::InsertAt { index: 7, value: 9 }),
Async::Ready(ListChange::InsertAt { index: 9, value: 10 }), Async::Ready(VecChange::InsertAt { index: 9, value: 10 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 11, value: 11 }), Async::Ready(VecChange::InsertAt { index: 11, value: 11 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 0, value: 0 }), Async::Ready(VecChange::InsertAt { index: 0, value: 0 }),
Async::NotReady, Async::NotReady,
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 1, value: 0 }), Async::Ready(VecChange::InsertAt { index: 1, value: 0 }),
Async::Ready(ListChange::InsertAt { index: 5, value: 0 }), Async::Ready(VecChange::InsertAt { index: 5, value: 0 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::InsertAt { index: 5, value: 12 }), Async::Ready(VecChange::InsertAt { index: 5, value: 12 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::RemoveAt { index: 0 }), Async::Ready(VecChange::RemoveAt { index: 0 }),
Async::Ready(ListChange::RemoveAt { index: 0 }), Async::Ready(VecChange::RemoveAt { index: 0 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::RemoveAt { index: 0 }), Async::Ready(VecChange::RemoveAt { index: 0 }),
Async::Ready(ListChange::RemoveAt { index: 1 }), Async::Ready(VecChange::RemoveAt { index: 1 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::RemoveAt { index: 0 }), Async::Ready(VecChange::RemoveAt { index: 0 }),
Async::NotReady, Async::NotReady,
Async::Ready(ListChange::RemoveAt { index: 0 }), Async::Ready(VecChange::RemoveAt { index: 0 }),
]); ]);
let output = input.filter_map(|x| { let output = input.filter_map(|x| {
@ -445,17 +445,17 @@ mod tests {
}); });
assert_eq!(changes, vec![ assert_eq!(changes, vec![
Change { length: 2, indexes: vec![None, None, None, Some(0), Some(1), None], change: ListChange::Replace { values: vec![103, 104] } }, Change { length: 2, indexes: vec![None, None, None, Some(0), Some(1), None], change: VecChange::Replace { values: vec![103, 104] } },
Change { length: 3, indexes: vec![Some(0), None, None, None, Some(1), Some(2), None], change: ListChange::InsertAt { index: 0, value: 106 } }, Change { length: 3, indexes: vec![Some(0), None, None, None, Some(1), Some(2), None], change: VecChange::InsertAt { index: 0, value: 106 } },
Change { length: 4, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), None], change: ListChange::InsertAt { index: 1, value: 107 } }, Change { length: 4, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), None], change: VecChange::InsertAt { index: 1, value: 107 } },
Change { length: 5, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), None], change: ListChange::InsertAt { index: 2, value: 108 } }, Change { length: 5, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), None], change: VecChange::InsertAt { index: 2, value: 108 } },
Change { length: 6, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), None], change: ListChange::InsertAt { index: 4, value: 109 } }, Change { length: 6, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), None], change: VecChange::InsertAt { index: 4, value: 109 } },
Change { length: 7, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None], change: ListChange::InsertAt { index: 6, value: 110 } }, Change { length: 7, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None], change: VecChange::InsertAt { index: 6, value: 110 } },
Change { length: 8, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None, Some(7)], change: ListChange::InsertAt { index: 7, value: 111 } }, Change { length: 8, indexes: vec![Some(0), None, Some(1), None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None, Some(7)], change: VecChange::InsertAt { index: 7, value: 111 } },
Change { length: 9, indexes: vec![None, None, Some(0), None, Some(1), Some(2), None, None, None, Some(3), Some(4), Some(5), Some(6), Some(7), None, Some(8)], change: ListChange::InsertAt { index: 2, value: 112 } }, Change { length: 9, indexes: vec![None, None, Some(0), None, Some(1), Some(2), None, None, None, Some(3), Some(4), Some(5), Some(6), Some(7), None, Some(8)], change: VecChange::InsertAt { index: 2, value: 112 } },
Change { length: 8, indexes: vec![None, Some(0), Some(1), None, None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None, Some(7)], change: ListChange::RemoveAt { index: 0 } }, Change { length: 8, indexes: vec![None, Some(0), Some(1), None, None, None, Some(2), Some(3), Some(4), Some(5), Some(6), None, Some(7)], change: VecChange::RemoveAt { index: 0 } },
Change { length: 7, indexes: vec![None, Some(0), None, None, None, Some(1), Some(2), Some(3), Some(4), Some(5), None, Some(6)], change: ListChange::RemoveAt { index: 0 } }, Change { length: 7, indexes: vec![None, Some(0), None, None, None, Some(1), Some(2), Some(3), Some(4), Some(5), None, Some(6)], change: VecChange::RemoveAt { index: 0 } },
Change { length: 6, indexes: vec![None, None, None, Some(0), Some(1), Some(2), Some(3), Some(4), None, Some(5)], change: ListChange::RemoveAt { index: 0 } }, Change { length: 6, indexes: vec![None, None, None, Some(0), Some(1), Some(2), Some(3), Some(4), None, Some(5)], change: VecChange::RemoveAt { index: 0 } },
]); ]);
} }
} }