Struct ShiftArray 

pub struct ShiftArray<T> {
    pub start: usize,
    pub lst: Vec<T>,
}

The ShiftArray type represents an array that can be shifted to the left or right without copying or moving its elements.

Properties:

• start: The start property represents the index of the first element in the ShiftArray. It indicates the starting point from which elements are accessed or shifted.
• lst: The lst property is a vector that holds the elements of the ShiftArray. It is of type Vec<T>, where T is a generic type parameter that can be replaced with any type.

Fields

start: usize

lst: Vec<T>

Implementations

impl<T> ShiftArray<T>

pub fn new(lst: Vec<T>) -> Self

The function “new” initializes a new instance of a struct with a starting index of 0 and a given list.

Arguments:

• lst: The lst parameter is a Vec<T>, which is a vector of elements of type T.

Returns:

The new function is returning an instance of the struct that it is defined in.

Examples:

use mywheel_rs::array_like::ShiftArray;

let mut shift_array = ShiftArray::new(vec![1, 2, 3]);
assert_eq!(shift_array.start, 0);
assert_eq!(shift_array.lst, vec![1, 2, 3]);
assert_eq!(shift_array.len(), 3);
assert_eq!(shift_array[0], 1);

pub fn set_start(&mut self, start: usize)

The function sets the start value of a variable.

Arguments:

• start: The start parameter is of type usize, which represents an unsigned integer that can hold the size of any object in memory. It is used to set the value of the start field in the struct or object that this method belongs to.

Examples

use mywheel_rs::array_like::ShiftArray;

let mut shift_array = ShiftArray::new(vec![1, 2, 3]);
shift_array.set_start(1);
assert_eq!(shift_array.start, 1);
assert_eq!(shift_array.len(), 3);

pub fn items(&self) -> impl Iterator<Item = (usize, &T)>

The items function returns an iterator that yields the index and reference to each element in the lst vector, with the index adjusted by the start value.

Examples

use mywheel_rs::array_like::ShiftArray;
let mut shift_array = ShiftArray::new(vec![1, 2, 3]);
shift_array.set_start(1);
for (i, v) in shift_array.items() {
    assert_eq!(i, *v as usize);
}

pub fn iter(&self) -> ShiftArrayIterator<'_, T>

pub fn len(&self) -> usize

Trait Implementations

impl<T: Clone> Clone for ShiftArray<T>

fn clone(&self) -> ShiftArray<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ShiftArray<T>

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

Formats the value using the given formatter.

impl<T> Index<usize> for ShiftArray<T>

fn index(&self, key: usize) -> &Self::Output

The index function returns a reference to an element in a list based on a given key.

Arguments:

• key: The key parameter is of type usize and represents the index of the element to be accessed in the lst field.

Returns:

The method index returns a reference to an element of self.lst at the specified index key - self.start.

Examples

use mywheel_rs::array_like::ShiftArray;
let mut shift_array = ShiftArray::new(vec![1, 2, 3]);
assert_eq!(shift_array[2], 3);
shift_array.set_start(1);
assert_eq!(shift_array[2], 2);

type Output = T

The returned type after indexing.

impl<T> IndexMut<usize> for ShiftArray<T>

fn index_mut(&mut self, key: usize) -> &mut Self::Output

The function index_mut returns a mutable reference to an element in a list based on a given key.

Arguments:

• key: The key parameter is of type usize and represents the index of the element to be accessed in the lst vector.

Returns:

A mutable reference to an element in the lst vector, located at the index key - self.start.

Examples

use mywheel_rs::array_like::ShiftArray;
let mut shift_array = ShiftArray::new(vec![1, 2, 3]);
assert_eq!(shift_array[2], 3);
shift_array.set_start(1);
assert_eq!(shift_array[2], 2);
shift_array[2] = 4;
assert_eq!(shift_array[2], 4);

impl<T: PartialEq> PartialEq for ShiftArray<T>

fn eq(&self, other: &ShiftArray<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: Eq> Eq for ShiftArray<T>

impl<T> StructuralPartialEq for ShiftArray<T>