Struct yata::core::Window

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

Window is a circular buffer where both start and end pointers always point to a single element.

When push new value into it, it remembers that value and returns the oldest pushed value.

Also you can iterate over remembered values inside the Window

Examples

use yata::core::Window;

let mut w = Window::new(3, 1); // [1, 1, 1]

assert_eq!(w.push(2), 1); // [1, 1, 2]
assert_eq!(w.push(3), 1); // [1, 2, 3]
assert_eq!(w.push(4), 1); // [2, 3, 4]
assert_eq!(w.push(5), 2); // [3, 4, 5]
assert_eq!(w.push(6), 3); // [4, 5, 6]

use yata::core::Window;

let mut w = Window::new(3, 0);

w.push(1);
w.push(2);
assert_eq!(w[0], 2);
assert_eq!(w[1], 1);
assert_eq!(w[2], 0);

w.push(3);
assert_eq!(w[0], 3);
assert_eq!(w[1], 2);
assert_eq!(w[2], 1);

w.push(4);
assert_eq!(w[0], 4);
assert_eq!(w[1], 3);
assert_eq!(w[2], 2);

See also

Past

Windows

Implementations

impl<T> Window<T>

pub fn new(size: PeriodType, value: T) -> Self

where T: Clone,

Creates new Window object of size size with filled values value

Panics

When in development mode, this method may panic if size is equal to PeriodType::MAX

pub fn from_parts(slice: Box<[T]>, index: PeriodType) -> Self

Creates new Window object from raw slice and index of the oldest inserted element in that slice.

index must be an index of the most oldest value in the slice. In most cases it should be zero.

Panics

This method will panic if length of the slice is greater or equal to PeriodType::MAX. This method will also panic if provided index is greater or equal to slice’s length.

pub fn empty() -> Self

Creates an empty Window instance (no buffer allocated)

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

Pushes the value into the Window.

Returns an oldest pushed value.

Panics

This method panics if try to push into empty Window (when size = 0).

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

Returns an iterator over the Window’s values (by copy) (from the newest to the oldest).

Examples

use yata::core::Window;

let mut w = Window::new(3, 1);

w.push(2);
w.push(3);
w.push(4);
w.push(5);

let p: Vec<_> = w.iter().copied().collect();
assert_eq!(p, [5, 4, 3]);

pub const fn iter_rev(&self) -> ReversedWindowIterator<'_, T>

Returns a reversed iterator over the Window’s values (by copy) (from the oldest value to the newest).

Examples

use yata::core::Window;

let mut w = Window::new(3, 1);

w.push(2);
w.push(3);
w.push(4);
w.push(5);

let p: Vec<_> = w.iter_rev().copied().collect();
assert_eq!(p, [3, 4, 5]);

pub fn newest(&self) -> &T

Returns a last pushed value

Examples

use yata::core::Window;
let mut w = Window::new(3, 1);

assert_eq!(w.newest(), &1);
w.push(2);
assert_eq!(w.newest(), &2);
w.push(3);
assert_eq!(w.newest(), &3);
w.push(4);
assert_eq!(w.newest(), &4);
w.push(5);
assert_eq!(w.newest(), &5);
w.push(6);
assert_eq!(w.newest(), &6);

pub fn oldest(&self) -> &T

Returns an oldest value

pub const fn is_empty(&self) -> bool

Checks if Window is empty (length == 0). Returns true if Window is empty or false otherwise.

pub const fn as_slice(&self) -> &[T]

Casts Window as a raw slice of T

Important!

The sequence of elements is not preserved.

pub const fn len(&self) -> PeriodType

Returns the length (elements count) of the Window

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

Returns an element at index starting from the newest

Trait Implementations

impl<T> AsRef<[T]> for Window<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Window<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Window<T>

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

Formats the value using the given formatter.

impl<T> Default for Window<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Window<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<Box<[T]>> for Window<T>

fn from(slice: Box<[T]>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for Window<T>

fn from(v: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> Index<u8> for Window<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a Window<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = WindowIterator<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Serialize for Window<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.