Struct ArrayList

pub struct ArrayList<T> { /* private fields */ }

Implementations

impl<T: Debug + Clone + PartialEq> ArrayList<T>

pub fn new() -> Self

pub fn start_with(collection: &[T]) -> Self

pub fn push(&self, value: T) -> bool

pub fn push_on_index(&self, index: usize, value: T)

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

pub fn add_all(&self, collection: &[T])

pub fn add_all_at_index(&self, idx: usize, collection: &[T])

pub fn replace(&self, index: usize, value: T)

pub fn clear(&self)

pub fn clone(&self) -> Self

pub fn copy(&self) -> &Self

pub fn add(&mut self, value: T) -> &mut Self

pub fn finish(&self) -> Self

pub fn ensure_capacity(size: usize) -> Self

pub fn contains(&self, value: T) -> bool

pub fn cap(&self) -> usize

pub fn len(&self) -> usize

pub fn size(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn pop(&self) -> Option<T>

pub fn remove(&self, index: usize) -> T

pub fn remove_if(&self, f: fn(T) -> bool)

pub fn to_vec(&self) -> Vec<T>

pub fn from_slice(collection: &[T]) -> Self

pub fn for_each(&self, f: fn(T))

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

pub fn sub_list(&self, start: usize, stop: usize) -> Option<ArrayList<T>>

pub fn index_of(&self, value: T) -> Option<usize>

pub fn index_of_all(&self, value: T) -> Vec<usize>

pub fn index_in(&self, value: usize) -> Option<T>

pub fn print(&self)

pub fn swap(&self, first_idx: usize, second_idx: usize)

use arraylist::{arl::ArrayList, arraylist};

let langs = arraylist!["clojure", "golang", "kotlin", "groovy"];
langs.swap(0, 2);
assert_eq!(
   langs.to_vec(),
   ["kotlin", "golang", "clojure", "groovy"].to_vec()
);

Trait Implementations

impl<T: Debug> Debug for ArrayList<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Debug + Clone + PartialEq> Default for ArrayList<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Display + Clone> Display for ArrayList<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Clone + PartialEq + Debug> FromIterator<T> for ArrayList<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Clone> IntoIterator for ArrayList<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for ArrayList<T>

fn eq(&self, other: &ArrayList<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for ArrayList<T>