Struct Cache

pub struct Cache<T, const N: usize> { /* private fields */ }

A cache of N Ts. When the cache is filled up, a new entry overwrites the oldest entry. Cache<T, N> cannot be expanded or shrunk.

Implementations

impl<T, const N: usize> Cache<T, N>

pub const fn len(&self) -> usize

Returns the number of items cached. This will always return N once at least N items have been cached.

pub const fn is_empty(&self) -> bool

Returns true iff no items have been cached.

impl<T> Cache<T, 0x1>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x2>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x4>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x8>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x10>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x20>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x40>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x80>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x100>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x200>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x400>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x800>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x1000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x2000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x4000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x8000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0001_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0002_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0004_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0008_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0010_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0020_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0040_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0080_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0100_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0200_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0400_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0800_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x1000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x2000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x4000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x8000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0001_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0002_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0004_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0008_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0010_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0020_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0040_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0080_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0100_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0200_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0400_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0800_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x1000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x2000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x4000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x8000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0001_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0002_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0004_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0008_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0010_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0020_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0040_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0080_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0100_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0200_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0400_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x0800_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x1000_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x2000_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x4000_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T> Cache<T, 0x8000_0000_0000_0000>

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

Returns Some(&T) iff there is an item located at index idx. Indexing begins at the newest entry (i.e., self.get(0) will return the most recent entry iff at least one item has been cached).

pub fn get_unchecked(&self, idx: usize) -> &T

Returns a &T at index position idx % N. In the event (idx % N) >= self.len(), then &T references the default value of T that was inserted at creation but not actually inserted via push.

Correctness

idx < self.len(); otherwise a value that was not actually inserted will be returned.

pub fn push(&mut self, val: T)

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten.

impl<T, const N: usize> Cache<T, N>

where [T; N]: Default,

pub fn new() -> Self

Returns an instance of itself pre-loaded with the N instances of the default value of T. Note these default instances are treated as though they don’t exist (i.e., self.is_empty() will return true).

Trait Implementations

impl<T: Debug, const N: usize> Debug for Cache<T, N>

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

Formats the value using the given formatter.

impl<T, const N: usize> Default for Cache<T, N>

where [T; N]: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Index<usize> for Cache<T, 0x1>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x400>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0010_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x4000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0100_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0004_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x1000_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x80>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0002_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0800_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0020_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x8000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0200_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x10>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x4000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0100_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0004_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x1000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0040_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x2>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x800>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0020_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x8000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0200_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0008_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x2000_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x100>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0004_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x1000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0040_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0001_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0400_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x20>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x8000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0200_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0008_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x2000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0080_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x4>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x1000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0040_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0001_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0400_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0010_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x4000_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x200>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0008_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x2000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0080_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0002_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0800_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x40>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0001_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0400_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0010_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x4000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0100_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x8>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x2000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0080_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0002_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0800_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x0020_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for Cache<T, 0x8000_0000_0000_0000>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.