Trait flatk::IsolateIndex

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

A helper trait like GetIndex but for Isolate types.

Associated Types

type Output

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

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

type Output = Offsets<O::Output>

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

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

type Output = SortedChunks<O::Output>

fn try_isolate(self, sorted_chunks: SortedChunks<O>) -> Option<Self::Output>

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

type Output = S::Output

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

Isolate a single chunk of the given Chunked collection.

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>>, 

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

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

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

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

type Output = T

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

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

type Output = Range<T>

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

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

type Output = T

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

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

type Output = Range<T>

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)

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>

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)

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>

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

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)

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)

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

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

type Output = S::Output

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

Isolate a chunk of the given UniChunked collection.

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

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

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

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

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

type Output = S::Output

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

Isolate a chunk of the given ChunkedN collection.

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

type Output = ChunkedN<S::Output>

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

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

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

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

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

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

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

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

Loading content...

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

fn try_isolate(self, set: &'a [T]) -> Option<&'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

fn try_isolate(
    self,
    set: &'a mut [T]
) -> Option<&'a mut <[T] as Index<I>>::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; 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; 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, 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, 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<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, 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, 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>

Loading content...