qcollect-traits 0.4.1

use super::*;
use std::{cmp, slice};

// ++++++++++++++++++++ Boxed Slice ++++++++++++++++++++

impl<T> ImmutableCollection for [T] {
    fn len(&self) -> usize { (*self).len() }
}

impl<T> MutableCollection for [T] {}

impl<'a, T: 'a> ImmutableSequenceTypes<'a, T> for [T] {
    type Iter = slice::Iter<'a, T>;
}

impl<T: 'static> ImmutableSequence<T> for [T] {
    fn get<'a>(&'a self, idx: usize) -> Option<<Self as ImmutableSequenceTypes<'a, T>>::Output> { (*self).get(idx) }

    fn iter<'a>(&'a self) -> <Self as ImmutableSequenceTypes<'a, T>>::Iter { (*self).iter() }

}

impl<'a, T: 'a> MutableSequenceTypes<'a, T> for [T] {
    type IterMut = slice::IterMut<'a, T>;
}

impl<T: 'static> MutableSequence<T> for [T] {
    fn get_mut<'a>(&'a mut self, idx: usize) -> Option<&mut T>
        //FIXME_REMOVE where Self: ImmutableSequenceTypes<'a, T, Output = &'a T>
    {
        (*self).get_mut(idx)
    }

    fn iter_mut<'a>(&'a mut self) -> <Self as MutableSequenceTypes<'a, T>>::IterMut
        //FIXME_REMOVE where Self: ImmutableSequenceTypes<'a, T, Output = &'a T>
    {
        (*self).iter_mut()
    }

    fn swap(&mut self, a: usize, b: usize){
        (*self).swap(a, b);
    }

    fn sort_by<F>(&mut self, compare: F)
        where F: FnMut(&T, &T) -> cmp::Ordering
    {
        (*self).sort_by(compare);
    }
}

// ++++++++++++++++++++ Immutable Slice ++++++++++++++++++++

impl<'r, T> ImmutableCollection for &'r [T] {
    fn len(&self) -> usize { (**self).len() }
}

impl<'r, T> MutableCollection for &'r [T] {}

impl<'a, 'r, T: 'a> ImmutableSequenceTypes<'a, T> for &'r [T] {
    type Iter = slice::Iter<'a, T>;
}

impl<'r, T: 'static> ImmutableSequence<T> for &'r [T] {
    fn get<'a>(&'a self, idx: usize) -> Option<<Self as ImmutableSequenceTypes<'a, T>>::Output> { (**self).get(idx) }

    fn iter<'a>(&'a self) -> <Self as ImmutableSequenceTypes<'a, T>>::Iter { (**self).iter() }

}

// ++++++++++++++++++++ Mutable Slice ++++++++++++++++++++

impl<'r, T> ImmutableCollection for &'r mut [T] {
    fn len(&self) -> usize { (**self).len() }
}

impl<'r, T> MutableCollection for &'r mut [T] {}

impl<'a, 'r, T: 'a> ImmutableSequenceTypes<'a, T> for &'r mut [T] {
    type Iter = slice::Iter<'a, T>;
}

impl<'r, T: 'static> ImmutableSequence<T> for &'r mut [T] {
    fn get<'a>(&'a self, idx: usize) -> Option<<Self as ImmutableSequenceTypes<'a, T>>::Output> { (**self).get(idx) }

    fn iter<'a>(&'a self) -> <Self as ImmutableSequenceTypes<'a, T>>::Iter { (**self).iter() }

}

impl<'a, 'r, T: 'a> MutableSequenceTypes<'a, T> for &'r mut [T] {
    type IterMut = slice::IterMut<'a, T>;
}

impl<'r, T: 'static> MutableSequence<T> for &'r mut [T] {
    fn get_mut<'a>(&'a mut self, idx: usize) -> Option<&mut T>
        //FIXME_REMOVE where Self: ImmutableSequenceTypes<'a, T, Output = &'a T>
    {
        (**self).get_mut(idx)
    }

    fn iter_mut<'a>(&'a mut self) -> <Self as MutableSequenceTypes<'a, T>>::IterMut
        //FIXME_REMOVE where Self: ImmutableSequenceTypes<'a, T, Output = &'a T>
    {
        (**self).iter_mut()
    }

    fn swap(&mut self, a: usize, b: usize){
        (**self).swap(a, b);
    }

    fn sort_by<F>(&mut self, compare: F)
        where F: FnMut(&T, &T) -> cmp::Ordering
    {
        (**self).sort_by(compare);
    }
}