Struct calc_lib::cache::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 be 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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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 unsafe fn get_unsafe(&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.

Safety

idx < self.len().

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

Adds val to the cache. In the event N values have already been cached, the oldest entry is overwritten. Returns a shared reference to the value it inserts.

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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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.