Trait flatk::IsolateIndex

pub trait IsolateIndex<S> {
    type Output;
    fn try_isolate(self, set: S) -> Option<Self::Output>;
    unsafe fn isolate_unchecked(self, set: S) -> Self::Output;
}

A helper trait like GetIndex but for Isolate types.

Associated Types

type Output

Required methods

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

Implementations on Foreign Types

impl<O> IsolateIndex<ClumpedOffsets<O>> for usize where
    ClumpedOffsets<O>: GetOffset, 

type Output = usize

unsafe fn isolate_unchecked(
    self,
    clumped_offsets: ClumpedOffsets<O>
) -> Self::Output

fn try_isolate(self, clumped_offsets: ClumpedOffsets<O>) -> Option<Self::Output>

impl<O: Isolate<usize>> IsolateIndex<Offsets<O>> for usize

type Output = O::Output

unsafe fn isolate_unchecked(self, offsets: Offsets<O>) -> Self::Output

fn try_isolate(self, offsets: Offsets<O>) -> Option<Self::Output>

impl<O: Isolate<Range<usize>>> IsolateIndex<Offsets<O>> for Range<usize>

type Output = Offsets<O::Output>

unsafe fn isolate_unchecked(self, offsets: Offsets<O>) -> Self::Output

fn try_isolate(self, offsets: Offsets<O>) -> Option<Self::Output>

impl<S, N> IsolateIndex<UniChunked<S, U<N>>> for usize where
    S: Set + Isolate<StaticRange<N>>,
    N: Unsigned, 

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

Isolate a chunk of the given UniChunked collection.

type Output = S::Output

unsafe fn isolate_unchecked(self, chunked: UniChunked<S, U<N>>) -> Self::Output

impl<S, N> IsolateIndex<UniChunked<S, U<N>>> for Range<usize> where
    S: Set + Isolate<Range<usize>>,
    N: Unsigned + Default, 

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

Isolate a [begin..end) range of the given UniChunked collection.

type Output = UniChunked<S::Output, U<N>>

unsafe fn isolate_unchecked(self, chunked: UniChunked<S, U<N>>) -> Self::Output

impl<S> IsolateIndex<UniChunked<S, usize>> for usize where
    S: Set + Isolate<Range<usize>>, 

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

Isolate a chunk of the given ChunkedN collection.

type Output = S::Output

unsafe fn isolate_unchecked(self, chunked: ChunkedN<S>) -> Self::Output

impl<S> IsolateIndex<UniChunked<S, usize>> for Range<usize> where
    S: Set + Isolate<Range<usize>>, 

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

Isolate a [begin..end) range of the given ChunkedN collection.

type Output = ChunkedN<S::Output>

unsafe fn isolate_unchecked(self, chunked: ChunkedN<S>) -> Self::Output

impl<S, O> IsolateIndex<Chunked<S, O>> for usize where
    S: Set + Isolate<Range<usize>>,
    O: IndexRange, 

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

Isolate a single chunk of the given Chunked collection.

type Output = S::Output

unsafe fn isolate_unchecked(self, chunked: Chunked<S, O>) -> Self::Output

impl<S, O> IsolateIndex<Chunked<S, O>> for Range<usize> where
    S: Set + Isolate<Range<usize>>,
    <S as Isolate<Range<usize>>>::Output: Set,
    O: IndexRange + Isolate<Range<usize>>, 

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

Isolate a [begin..end) range of the given Chunked collection.

type Output = Chunked<S::Output, O::Output>

unsafe fn isolate_unchecked(self, chunked: Chunked<S, O>) -> Self::Output

impl<T: IntBound> IsolateIndex<Range<T>> for usize

type Output = T

unsafe fn isolate_unchecked(self, rng: Range<T>) -> Self::Output

fn try_isolate(self, rng: Range<T>) -> Option<Self::Output>

impl<T: IntBound> IsolateIndex<Range<T>> for Range<usize>

type Output = Range<T>

unsafe fn isolate_unchecked(self, rng: Range<T>) -> Self::Output

fn try_isolate(self, rng: Range<T>) -> Option<Self::Output>

impl<T: IntBound> IsolateIndex<RangeTo<T>> for usize

type Output = T

unsafe fn isolate_unchecked(self, _: RangeTo<T>) -> Self::Output

fn try_isolate(self, rng: RangeTo<T>) -> Option<Self::Output>

impl<T: IntBound> IsolateIndex<RangeTo<T>> for Range<usize>

type Output = Range<T>

unsafe fn isolate_unchecked(self, _: RangeTo<T>) -> Self::Output

fn try_isolate(self, rng: RangeTo<T>) -> Option<Self::Output>

impl<S, I> IsolateIndex<Select<S, I>> for usize where
    I: Isolate<usize>,
    <I as Isolate<usize>>::Output: Borrow<usize>,
    S: Isolate<usize>, 

type Output = (I::Output, S::Output)

unsafe fn isolate_unchecked(self, selection: Select<S, I>) -> Self::Output

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

impl<S, I> IsolateIndex<Select<S, I>> for Range<usize> where
    I: Isolate<Range<usize>>, 

Isolating a range from a selection will preserve the original target data set.

type Output = Select<S, I::Output>

unsafe fn isolate_unchecked(self, selection: Select<S, I>) -> Self::Output

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

impl<S, T, I> IsolateIndex<Sparse<S, T, I>> for usize where
    I: Isolate<usize>,
    <I as Isolate<usize>>::Output: Borrow<usize>,
    S: Isolate<usize>,
    T: Isolate<usize>, 

type Output = (<I as Isolate<usize>>::Output, <S as Isolate<usize>>::Output, <T as Isolate<usize>>::Output)

unsafe fn isolate_unchecked(self, sparse: Sparse<S, T, I>) -> Self::Output

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

impl<S, T, I> IsolateIndex<Sparse<S, T, I>> for Range<usize> where
    S: Isolate<Range<usize>>,
    I: Isolate<Range<usize>>, 

type Output = Sparse<S::Output, T, I::Output>

unsafe fn isolate_unchecked(self, sparse: Sparse<S, T, I>) -> Self::Output

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

impl<S, O> IsolateIndex<Subset<S, O>> for usize where
    O: AsRef<[usize]>,
    S: Isolate<usize>, 

type Output = <S as Isolate<usize>>::Output

unsafe fn isolate_unchecked(self, subset: Subset<S, O>) -> Self::Output

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

impl<'a, S, T> IsolateIndex<(S, T)> for usize where
    S: Isolate<usize>,
    T: Isolate<usize>, 

type Output = (S::Output, T::Output)

unsafe fn isolate_unchecked(self, (s, t): (S, T)) -> Self::Output

fn try_isolate(self, (s, t): (S, T)) -> Option<Self::Output>

impl<'a, S, T> IsolateIndex<(S, T)> for Range<usize> where
    S: Isolate<Range<usize>>,
    T: Isolate<Range<usize>>, 

type Output = (S::Output, T::Output)

unsafe fn isolate_unchecked(self, (s, t): (S, T)) -> Self::Output

fn try_isolate(self, (s, t): (S, T)) -> Option<Self::Output>

impl<S> IsolateIndex<S> for RangeFrom<usize> where
    S: Set + ValueType,
    Range<usize>: IsolateIndex<S>, 

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

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

impl<S: ValueType> IsolateIndex<S> for RangeTo<usize> where
    Range<usize>: IsolateIndex<S>, 

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

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

impl<S: ValueType> IsolateIndex<S> for RangeFull where
    S: Set,
    Range<usize>: IsolateIndex<S>, 

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

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

impl<S: ValueType> IsolateIndex<S> for RangeInclusive<usize> where
    S: Set,
    Range<usize>: IsolateIndex<S>, 

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

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

impl<S: ValueType> IsolateIndex<S> for RangeToInclusive<usize> where
    S: Set,
    Range<usize>: IsolateIndex<S>, 

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

unsafe fn isolate_unchecked(self, set: S) -> Self::Output

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

Implementors

impl<'a, T, I> IsolateIndex<&'a [T]> for I where
    I: SliceIndex<[T]>,
    <I as SliceIndex<[T]>>::Output: 'a, 

type Output = &'a <[T] as Index<I>>::Output

impl<'a, T, I> IsolateIndex<&'a mut [T]> for I where
    I: SliceIndex<[T]>,
    <I as SliceIndex<[T]>>::Output: 'a, 

type Output = &'a mut <[T] as Index<I>>::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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<S, N> IsolateIndex<S> for StaticRange<N> where
    S: Set + DynamicRangeIndexType,
    N: Unsigned,
    Range<usize>: IsolateIndex<S>, 

type Output = <Range<usize> as IsolateIndex<S>>::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>>

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