Struct grid_trait::grid3::combinate::slice::Grid3Slice

pub struct Grid3Slice<G, X, Y, Z> where
    G: Grid3,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone,  { /* fields omitted */ }

Sub-view of a Grid3.

The valid coordinates in this grid are a subset of the valid coordinates in the inner grid.

Methods

impl<G, X, Y, Z> Grid3Slice<G, X, Y, Z> where
    G: Grid3,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

pub fn try_new(inner: G, new_x: X, new_y: Y, new_z: Z) -> Result<Self, G>

Fails if the new bounds are not a subset of the old ones.

pub fn new(inner: G, new_x: X, new_y: Y, new_z: Z) -> Self where
    X: Debug,
    Y: Debug,
    Z: Debug,
    <G as Grid3>::XBound: Debug,
    <G as Grid3>::YBound: Debug,
    <G as Grid3>::ZBound: Debug, 

Panics if the new bounds are not a subset of the old ones.

Trait Implementations

impl<G, X, Y, Z> Grid3 for Grid3Slice<G, X, Y, Z> where
    G: Grid3,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

type Item = <G as Grid3>::Item

type XBound = X

type YBound = Y

type ZBound = Z

fn x_bound(&self) -> Self::XBound

fn y_bound(&self) -> Self::YBound

fn z_bound(&self) -> Self::ZBound

fn in_bounds<I>(&self, coord: I) -> bool where
    I: Into<Vector3<i32>>, 

fn map<F, T>(self, func: F) -> Grid3Map<Self, F, T> where
    Self: Sized,
    F: Fn(Self::Item) -> T, 

Element by-value mapping.

fn enumap<I, F, T>(self, func: F) -> Grid3EnuMap<Self, F, T, I> where
    Self: Sized,
    I: From<Vector3<i32>>,
    F: Fn(I, Self::Item) -> T, 

Element by-value+coord mapping.

fn flatten<I>(self, stride: I) -> Grid3Flat<Self> where
    Self: Sized,
    Self::Item: Grid3,
    Self::XBound: Clone + RangeBoundsTimes,
    Self::YBound: Clone + RangeBoundsTimes,
    Self::ZBound: Clone + RangeBoundsTimes,
    I: Into<Vector3<i32>>, 

Flattening a grid of grids with a regular stride.

fn new_origin<I>(self, new_origin: I) -> Grid3NewOrigin<Self> where
    Self: Sized,
    Self::XBound: RangeBoundsPlus,
    Self::YBound: RangeBoundsPlus,
    Self::ZBound: RangeBoundsPlus,
    I: Into<Vector3<i32>>, 

<0, 0> in this grid becomes new_origin in resultant grid.

fn oob_handler<I, F>(self, handler: F) -> Grid3OobHandler<Self, I, F> where
    Self: Sized,
    I: From<Vector3<i32>>,
    F: Fn(I) -> Self::Item, 

Provide function to provide elments at out-of-bounds coordinates.

fn subview<X, Y, Z>(
    self,
    new_x: X,
    new_y: Y,
    new_z: Z
) -> Grid3Slice<Self, X, Y, Z> where
    Self: Sized,
    Self::XBound: Debug,
    Self::YBound: Debug,
    Self::ZBound: Debug,
    X: RangeBounds<i32> + Clone + Debug,
    Y: RangeBounds<i32> + Clone + Debug,
    Z: RangeBounds<i32> + Clone + Debug, 

View a sub-rectangle of this grid.

fn try_subview<X, Y, Z>(
    self,
    new_x: X,
    new_y: Y,
    new_z: Z
) -> Result<Grid3Slice<Self, X, Y, Z>, Self> where
    Self: Sized,
    Self::XBound: Debug,
    Self::YBound: Debug,
    X: RangeBounds<i32> + Clone + Debug,
    Y: RangeBounds<i32> + Clone + Debug,
    Z: RangeBounds<i32> + Clone + Debug, 

View a sub-rectangle of this grid.

fn subview_0to(
    self,
    new_x_len: i32,
    new_y_len: i32,
    new_z_len: i32
) -> Grid3Slice<Self, Range0To, Range0To, Range0To> where
    Self: Sized,
    Self::XBound: Debug,
    Self::YBound: Debug,
    Self::ZBound: Debug, 

View a sub-rectangle of this grid, beginning at origin.

fn try_subview_0to(
    self,
    new_x_len: i32,
    new_y_len: i32,
    new_z_len: i32
) -> Result<Grid3Slice<Self, Range0To, Range0To, Range0To>, Self> where
    Self: Sized,
    Self::XBound: Debug,
    Self::YBound: Debug,
    Self::ZBound: Debug, 

View a sub-rectangle of this grid, beginning at origin.

fn wrapping(self) -> Grid3Wrapping<Self> where
    Self: Sized,
    Self::XBound: BoundRange,
    Self::YBound: BoundRange,
    Self::ZBound: BoundRange, 

View of this grid which wraps around the edges.

fn collect(&self) -> ArrayGrid3<Self::Item> where
    Self: Grid3Get,
    Self::XBound: Into<Range0To>,
    Self::YBound: Into<Range0To>,
    Self::ZBound: Into<Range0To>, 

Collect a grid's elements into a heap allocation.

impl<G, X, Y, Z> Grid3Get for Grid3Slice<G, X, Y, Z> where
    G: Grid3 + Grid3Get,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

fn get<I>(&self, coord: I) -> Self::Item where
    I: Into<Vector3<i32>>, 

fn try_get<I>(&self, coord: I) -> Option<Self::Item> where
    I: Into<Vector3<i32>>, 

impl<G> Grid3Len for Grid3Slice<G, Range0To, Range0To, Range0To> where
    G: Grid3, 

fn x_len(&self) -> i32

fn y_len(&self) -> i32

fn z_len(&self) -> i32

impl<G, X, Y, Z> Grid3Mut for Grid3Slice<G, X, Y, Z> where
    G: Grid3 + Grid3Mut,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

fn midx<I>(&mut self, coord: I) -> &mut Self::Item where
    I: Into<Vector3<i32>>, 

fn try_midx<I>(&mut self, coord: I) -> Option<&mut Self::Item> where
    I: Into<Vector3<i32>>, 

impl<G, X, Y, Z> Grid3Ref for Grid3Slice<G, X, Y, Z> where
    G: Grid3 + Grid3Ref,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

fn idx<I>(&self, coord: I) -> &Self::Item where
    I: Into<Vector3<i32>>, 

fn try_idx<I>(&self, coord: I) -> Option<&Self::Item> where
    I: Into<Vector3<i32>>, 

impl<G, X, Y, Z> Grid3Set for Grid3Slice<G, X, Y, Z> where
    G: Grid3 + Grid3Set,
    X: RangeBounds<i32> + Clone,
    Y: RangeBounds<i32> + Clone,
    Z: RangeBounds<i32> + Clone, 

fn set<I>(&mut self, coord: I, elem: Self::Item) where
    I: Into<Vector3<i32>>, 

fn try_set<I>(&mut self, coord: I, elem: Self::Item) -> Result<(), Self::Item> where
    I: Into<Vector3<i32>>,