Struct Slice2 

pub struct Slice2<'a, T>(/* private fields */);

An immutable rectangular view to a region of a Buf2, another Slice2, or in general any &[T] slice of memory. A two-dimensional analog to &[T].

A Slice2 may be discontiguous:

+------stride-----+
|    ____w____    |
|   |r0_______|   |
|   |r1_______| h |
|   |r2_______|   |
+-----------------+

TODO More documentation

Implementations

impl<'a, T> Slice2<'a, T>

pub fn new(dims: Dims, stride: u32, data: &'a [T]) -> Self

Returns a new Slice2 view to data with the given dimensions and stride.

Examples

let data = &[0, 1, 2, 3, 4, 5, 6];
let slice = Slice2::new((2, 2), 3, data);
assert_eq!(&slice[0usize], &[0, 1]);
assert_eq!(&slice[1usize], &[3, 4]);

Above, slice represents a 2×2 rectangle with stride 3, such that the first row maps to data[0..2] and the second to data[3..5]:

 slice[0]    slice[1]
    |           |
,---´---.   ,---´---.
+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+---+---+---+---+---+---+---+

Internally, this is implemented as the borrow &data[0..5]. Semantically, however, slice does not contain data[2] as an element, and attempting to access it eg. with slice[0][2] will panic, as expected.

Panics

if stride < width or if the slice would overflow data.

Trait Implementations

impl<T> AsSlice2<T> for Slice2<'_, T>

fn as_slice2(&self) -> Slice2<'_, T>

Returns a borrowed Slice2 view of Self.

impl<'a, T: Clone> Clone for Slice2<'a, T>

fn clone(&self) -> Slice2<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Slice2<'_, T>

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

Formats the value using the given formatter.

impl<'a, T> Deref for Slice2<'a, T>

type Target = Inner<T, &'a [T]>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, C> From<Slice2<'a, C>> for Texture<Slice2<'a, C>>

fn from(data: Slice2<'a, C>) -> Self

Creates a new texture from borrowed pixel data.

impl<'a, T: Copy> Copy for Slice2<'a, T>