Struct Bounds 

pub struct Bounds<I> {
    pub offset: I,
    pub extent: I,
}

Bounds associated with an index type.

This is a description of the bounds of a multidimensional array, through the definition of an offset and an extent. Bounds can also be used to describe the bounds of an index list, which can be used to ensure that a collection of indices are all in bounds, and therefore bounds checks can be eliminated up front, prior to iteration.

In general, Bounds is expected to be used with either integers like usize for one-dimensional arrays or tuples like (usize, usize) for multidimensional arrays. For data structures, the offset is typically zero along each dimension, and the extent describes the “length” of the array along each dimension.

Offset primarily exists in order for index lists to more tightly describe their bounds, which can be used, for example, to ensure that index lists with disjoint bounds contain disjoint indices. However, a data structure can have non-zero offset.

Fields

offset: I

The offset of the bounds.

extent: I

The extent of the bounds.

Implementations

impl<I> Bounds<I>

pub fn zip<I2>(self, other: Bounds<I2>) -> Bounds<(I, I2)>

Zips the offset and extent of two Bounds instances.

impl<I: RecordIndex> Bounds<I>

pub fn contains_bounds(&self, other: &Bounds<I>) -> bool

Check if these bounds contain other.

pub fn contains_index(&self, index: I) -> bool

Check if these bounds contain the given index.

pub fn enclose_index(&mut self, index: I)

Expand these bounds — if needed — so that the given index is contained in the updated bounds.

pub fn new_empty() -> Self

Constructs empty bounds (zero extent along each dimension).

pub fn bounds_for_index(index: I) -> Self

Constructs bounds large enough to hold only exactly the given index.

Trait Implementations

impl<I: Clone> Clone for Bounds<I>

fn clone(&self) -> Bounds<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Bounds<I>

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

Formats the value using the given formatter.

impl<I: PartialEq> PartialEq for Bounds<I>

fn eq(&self, other: &Bounds<I>) -> bool

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

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

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

impl<I: Copy> Copy for Bounds<I>

impl<I: Eq> Eq for Bounds<I>

impl<I> StructuralPartialEq for Bounds<I>