Struct flatk::StaticRange

pub struct StaticRange<N> {
    pub start: usize,
    pub phantom: PhantomData<N>,
}

A type of range whose size is determined at compile time. This represents a range [start..start + N::value()]. This aids UniChunked types when indexing.

Fields

start: usize

phantom: PhantomData<N>

Trait Implementations

impl<N: Unsigned> BoundedRange for StaticRange<N>

type Index = usize

fn start(&self) -> usize

fn end(&self) -> usize

fn distance(&self) -> Self::Index

impl<N: Clone> Clone for StaticRange<N>

fn clone(&self) -> StaticRange<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Copy> Copy for StaticRange<N>

impl<N: Debug> Debug for StaticRange<N>

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

Formats the value using the given formatter.

impl<'a, T, N> GetIndex<'a, &'a [T; 1]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 1]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 10]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 10]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 11]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 11]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 12]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 12]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 13]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 13]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 14]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 14]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 15]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 15]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 16]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 16]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 2]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 2]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 3]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 3]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 4]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 4]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 5]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 5]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 6]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 6]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 7]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 7]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 8]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 8]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T; 9]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T; 9]) -> Option<Self::Output>

impl<'a, T, N> GetIndex<'a, &'a [T]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn get(self, set: &&'a [T]) -> Option<Self::Output>

impl<'a, S, N> GetIndex<'a, S> for StaticRange<N> where
    S: Set + ValueType,
    N: Unsigned,
    Range<usize>: GetIndex<'a, S>, 

type Output = <Range<usize> as GetIndex<'a, S>>::Output

fn get(self, set: &S) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 1]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 1]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 10]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 10]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 11]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 11]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 12]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 12]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 13]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 13]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 14]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 14]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 15]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 15]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 16]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 16]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 2]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 2]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 3]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 3]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 4]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 4]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 5]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 5]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 6]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 6]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 7]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 7]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 8]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 8]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T; 9]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T; 9]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a [T]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a N::Array

fn try_isolate(self, set: &'a [T]) -> Option<Self::Output>

impl<'a, T, N> IsolateIndex<&'a mut [T]> for StaticRange<N> where
    N: Unsigned + Array<T>,
    <N as Array<T>>::Array: 'a, 

type Output = &'a mut N::Array

fn try_isolate(self, set: &'a mut [T]) -> Option<Self::Output>

impl<S, O, N: Unsigned> IsolateIndex<Chunked<S, O>> for StaticRange<N> where
    Range<usize>: IsolateIndex<Chunked<S, O>>, 

type Output = <Range<usize> as IsolateIndex<Chunked<S, O>>>::Output

fn try_isolate(self, set: Chunked<S, O>) -> Option<Self::Output>

impl<S, I, N: Unsigned> IsolateIndex<Select<S, I>> for StaticRange<N> where
    Range<usize>: IsolateIndex<Select<S, I>>, 

type Output = <Range<usize> as IsolateIndex<Select<S, I>>>::Output

fn try_isolate(self, set: Select<S, I>) -> Option<Self::Output>

impl<S, T, I, N: Unsigned> IsolateIndex<Sparse<S, T, I>> for StaticRange<N> where
    Range<usize>: IsolateIndex<Sparse<S, T, I>>, 

type Output = <Range<usize> as IsolateIndex<Sparse<S, T, I>>>::Output

fn try_isolate(self, set: Sparse<S, T, I>) -> Option<Self::Output>

impl<S, O, N: Unsigned> IsolateIndex<Subset<S, O>> for StaticRange<N> where
    Range<usize>: IsolateIndex<Subset<S, O>>, 

type Output = <Range<usize> as IsolateIndex<Subset<S, O>>>::Output

fn try_isolate(self, set: Subset<S, O>) -> Option<Self::Output>

impl<S, N, M> IsolateIndex<UniChunked<S, U<M>>> for StaticRange<N> where
    S: Set,
    M: Unsigned,
    N: Unsigned + Mul<M>,
    StaticRange<<N as Mul<M>>::Output>: IsolateIndex<S>, 

type Output = UniChunked<<StaticRange<N::Output> as IsolateIndex<S>>::Output, U<M>>

fn try_isolate(self, set: UniChunked<S, U<M>>) -> Option<Self::Output>

impl<S, N: Unsigned> IsolateIndex<UniChunked<S, usize>> for StaticRange<N> where
    Range<usize>: IsolateIndex<ChunkedN<S>>, 

type Output = <Range<usize> as IsolateIndex<ChunkedN<S>>>::Output

fn try_isolate(self, set: ChunkedN<S>) -> Option<Self::Output>

impl<N: PartialEq> PartialEq<StaticRange<N>> for StaticRange<N>

fn eq(&self, other: &StaticRange<N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &StaticRange<N>) -> bool

This method tests for !=.

impl<N: Unsigned> Set for StaticRange<N>

type Elem = usize

Owned element of the set.

type Atom = usize

The most basic element contained by this collection. If this collection contains other collections, this type should be different than Elem.

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl<N> StructuralPartialEq for StaticRange<N>