Trait toad_array::Indexed

pub trait Indexed<T>where
    Self: Len,{
    type Ref<'a>: Deref<Target = T>
       where Self: 'a,
             T: 'a;
    type RefMut<'a>: Deref<Target = T> + DerefMut
       where Self: 'a,
             T: 'a;

    // Required methods
    fn get<'a>(&'a self, ix: usize) -> Option<Self::Ref<'a>>;
    fn get_mut<'a>(&'a mut self, ix: usize) -> Option<Self::RefMut<'a>>;
    fn insert(&mut self, ix: usize, t: T);
    fn remove(&mut self, ix: usize) -> Option<T>;

    // Provided methods
    fn push(&mut self, t: T) { ... }
    fn append(&mut self, t: T) { ... }
    fn drop_front(&mut self, ct: usize) { ... }
    fn drop_back(&mut self, ct: usize) { ... }
    fn drop_while<F>(&mut self, f: F)
       where F: for<'a> Fn(&'a T) -> bool { ... }
}

Operations on ordered indexed collections

Required Associated Types

type Ref<'a>: Deref<Target = T> where Self: 'a, T: 'a

TODO

type RefMut<'a>: Deref<Target = T> + DerefMut where Self: 'a, T: 'a

TODO

Required Methods

fn get<'a>(&'a self, ix: usize) -> Option<Self::Ref<'a>>

Get an immutable reference to element at ix

fn get_mut<'a>(&'a mut self, ix: usize) -> Option<Self::RefMut<'a>>

Get a mutable reference to element at ix

fn insert(&mut self, ix: usize, t: T)

Insert a new element at ix, shifting all other elements to the right.

use toad_array::Indexed;

fn do_stuff<I: Indexed<u32> + AsRef<Vec<u32>>>(mut i: I) {
  i.insert(0, 2);
  assert_eq!(i.as_ref(), &vec![2]);

  i.insert(0, 1);
  assert_eq!(i.as_ref(), &vec![1, 2]);

  i.insert(2, 3);
  assert_eq!(i.as_ref(), &vec![1, 2, 3]);
}

do_stuff(vec![]);

fn remove(&mut self, ix: usize) -> Option<T>

Remove element at ix, shifting all other elements to the left.

use toad_array::Indexed;

fn do_stuff<I: Indexed<u32> + AsRef<Vec<u32>>>(mut i: I) {
  i.remove(1);
  assert_eq!(i.as_ref(), &vec![1]);

  i.remove(0);
  assert_eq!(i.as_ref(), &vec![]);

  i.remove(0);
  assert_eq!(i.as_ref(), &vec![]);
}

do_stuff(vec![1, 2]);

Provided Methods

fn push(&mut self, t: T)

Insert an element at the front of the collection

use toad_array::Indexed;

fn do_stuff<I: Indexed<u32> + AsRef<Vec<u32>>>(mut i: I) {
  i.push(3);
  assert_eq!(i.as_ref(), &vec![3]);

  i.push(2);
  assert_eq!(i.as_ref(), &vec![2, 3]);

  i.push(1);
  assert_eq!(i.as_ref(), &vec![1, 2, 3]);
}

do_stuff(vec![]);

fn append(&mut self, t: T)

Insert an element at the end of the collection

use toad_array::Indexed;

fn do_stuff<I: Indexed<u32> + AsRef<Vec<u32>>>(mut i: I) {
  i.append(3);
  assert_eq!(i.as_ref(), &vec![3]);

  i.append(2);
  assert_eq!(i.as_ref(), &vec![3, 2]);

  i.append(1);
  assert_eq!(i.as_ref(), &vec![3, 2, 1]);
}

do_stuff(vec![]);

fn drop_front(&mut self, ct: usize)

Drop ct elements from the front of the collection

use toad_array::Indexed;

let mut v: Vec<u32> = vec![1, 2, 3, 4];

v.drop_front(2);
assert_eq!(v, vec![3, 4]);

v.drop_front(3);
assert_eq!(v, vec![]);

v.drop_front(1);
assert_eq!(v, vec![]);

fn drop_back(&mut self, ct: usize)

Drop ct elements from the back of the collection

use toad_array::Indexed;

let mut v: Vec<u32> = vec![1, 2, 3, 4];

v.drop_back(2);
assert_eq!(v, vec![1, 2]);

v.drop_back(2);
assert_eq!(v, vec![]);

v.drop_back(1);
assert_eq!(v, vec![]);

fn drop_while<F>(&mut self, f: F)where F: for<'a> Fn(&'a T) -> bool,

Drop elements from the front of the collection until the collection is emptied or the predicate returns false.

use toad_array::Indexed;

let mut v: Vec<u32> = vec![2, 4, 6, 5];

v.drop_while(|n| n % 2 == 0);
assert_eq!(v, vec![5]);

Implementations on Foreign Types

impl<A: Array> Indexed<<A as Array>::Item> for ArrayVec<A>where Self: Filled<A::Item> + Trunc,

type Ref<'a> where A::Item: 'a, Self: 'a = &'a <A as Array>::Item

type RefMut<'a> where A::Item: 'a, Self: 'a = &'a mut <A as Array>::Item

fn get(&self, ix: usize) -> Option<&A::Item>

fn get_mut(&mut self, ix: usize) -> Option<&mut A::Item>

fn insert(&mut self, ix: usize, t: A::Item)

fn remove(&mut self, ix: usize) -> Option<A::Item>

impl<T> Indexed<T> for Vec<T>

type Ref<'a> where T: 'a = &'a T

type RefMut<'a> where T: 'a = &'a mut T

fn get(&self, ix: usize) -> Option<&T>

fn get_mut(&mut self, ix: usize) -> Option<&mut T>

fn insert(&mut self, index: usize, value: T)

fn remove(&mut self, index: usize) -> Option<T>

Implementors