slicetools 0.3.0

#[cfg(test)] mod tests;

use ::StreamerMut;

/* GroupMut */

pub struct GroupMut<'a, T: 'a> {
    slice: &'a mut [T],
    start: usize,
}

impl<'a, 'it, T> StreamerMut<'it, &'it mut [T]> for GroupMut<'a, T> where T: PartialEq {
    fn next(&'it mut self) -> Option<&'it mut [T]> {
        let end = {
            let first = self.slice.get(self.start)?;
            self.start + self.slice[self.start..].iter().take_while(|i| *i == first).count()
        };
        let result = &mut self.slice[self.start..end];
        self.start = end;
        Some(result)
    }
}

impl<'a, T> GroupMut<'a, T> {
    pub fn new(slice: &'a mut [T]) -> GroupMut<'a, T> {
        GroupMut{ slice, start: 0 }
    }
}

/* GroupByMut */

pub struct GroupByMut<'a, T: 'a, F> where F: Fn(&T, &T) -> bool {
    slice: &'a mut [T],
    start: usize,
    condition: F,
}

impl<'a, 'it, T, F> StreamerMut<'it, &'it mut [T]> for GroupByMut<'a, T, F>
    where T: PartialEq, F: Fn(&T, &T) -> bool
{
    fn next(&'it mut self) -> Option<&'it mut [T]> {
        let end = {
            let first = self.slice.get(self.start)?;
            self.start + self.slice[self.start..].iter().take_while(|i| (self.condition)(i, &first)).count()
        };
        let result = &mut self.slice[self.start..end];
        self.start = end;
        Some(result)
    }
}

impl<'a, T, F> GroupByMut<'a, T, F> where F: Fn(&T, &T) -> bool {
    pub fn new(slice: &'a mut [T], condition: F) -> GroupByMut<'a, T, F> {
        GroupByMut{ slice, start: 0, condition }
    }
}

/* GroupByKeyMut */

pub struct GroupByKeyMut<'a, T: 'a, K, F> where F: Fn(&T) -> K {
    slice: &'a mut [T],
    start: usize,
    condition: F,
}

impl<'a, 'it, T, K, F> StreamerMut<'it, &'it mut [T]> for GroupByKeyMut<'a, T, K, F>
    where K: PartialEq, F: Fn(&T) -> K
{
    fn next(&'it mut self) -> Option<&'it mut [T]> {
        let end = {
            let first = (self.condition)(self.slice.get(self.start)?);
            self.start + self.slice[self.start..].iter().take_while(|i| (self.condition)(i) == first).count()
        };
        let result = &mut self.slice[self.start..end];
        self.start = end;
        Some(result)
    }
}

impl<'a, T, K, F> GroupByKeyMut<'a, T, K, F> where F: Fn(&T) -> K {
    pub fn new(slice: &'a mut [T], condition: F) -> GroupByKeyMut<'a, T, K, F> {
        GroupByKeyMut{ slice, start: 0, condition }
    }
}