Trait moc::moc::NonOverlapping

pub trait NonOverlapping { }

Marker trait telling that something the implementor contains non-overlapping items.

Implementors

impl<'a, T, Q, U, R> NonOverlapping for CellRefMoc2Iter<'a, T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<'a, T, Q, U, R> NonOverlapping for CellOrCellRangeRefMoc2Iter<'a, T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<'a, T, Q, U, R> NonOverlapping for RangeRefMoc2Iter<'a, T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<'a, T: Idx> NonOverlapping for TimeSpaceRangesIter<'a, T>

impl<'a, T: Idx, Q: MocQty<T>> NonOverlapping for OrderedFixedDepthCellsToRanges<'a, T, Q>

impl<'a, T: Idx, Q: MocQty<T>> NonOverlapping for CellRefMocIter<'a, T, Q>

impl<'a, T: Idx, Q: MocQty<T>> NonOverlapping for CellOrCellRangeRefMocIter<'a, T, Q>

impl<'a, T: Idx, Q: MocQty<T>> NonOverlapping for RangeRefMocIter<'a, T, Q>

impl<Q1, T, Q, I> NonOverlapping for ConvertFromU64Iterator<Q1, T, Q, I> where
    Q1: MocQty<u64>,
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<u64, Qty = Q1>, 

impl<T, Q, I1, I2> NonOverlapping for AndRangeIter<T, Q, I1, I2> where
    T: Idx,
    Q: MocQty<T>,
    I1: RangeMOCIterator<T, Qty = Q>,
    I2: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I1, I2> NonOverlapping for MinusRangeIter<T, Q, I1, I2> where
    T: Idx,
    Q: MocQty<T>,
    I1: RangeMOCIterator<T, Qty = Q>,
    I2: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I1, I2> NonOverlapping for OrRangeIter<T, Q, I1, I2> where
    T: Idx,
    Q: MocQty<T>,
    I1: RangeMOCIterator<T, Qty = Q>,
    I2: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I1, I2> NonOverlapping for XorRangeIter<T, Q, I1, I2> where
    T: Idx,
    Q: MocQty<T>,
    I1: RangeMOCIterator<T, Qty = Q>,
    I2: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I> NonOverlapping for CheckedIterator<T, Q, I> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I> NonOverlapping for DegradeRangeIter<T, Q, I> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I> NonOverlapping for MergeIterator<T, Q, I> where
    T: Idx,
    Q: MocQty<T>,
    I: Iterator<Item = Range<T>>, 

impl<T, Q, I> NonOverlapping for NotRangeIter<T, Q, I> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>, 

impl<T, Q, I, R> NonOverlapping for ConvertToU64Iterator<T, Q, I, R> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>,
    R: MocQty<u64>, 

impl<T, Q, I, U, R> NonOverlapping for ConvertIterator<T, Q, I, U, R> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>,
    U: Idx + From<T>,
    R: MocQty<U>, 

impl<T, Q, I, U, R, J, K, L> NonOverlapping for CellCellRangeMOC2ToRangeMOC2<T, Q, I, U, R, J, K, L> where
    T: Idx,
    Q: MocQty<T>,
    I: CellOrCellRangeMOCIterator<T, Qty = Q>,
    U: Idx,
    R: MocQty<U>,
    J: CellOrCellRangeMOCIterator<U, Qty = R>,
    K: CellOrCellRangeMOC2ElemIt<T, Q, U, R, It1 = I, It2 = J>,
    L: CellOrCellRangeMOC2Iterator<T, Q, I, U, R, J, K>, 

impl<T, Q, I, U, R, J, K, L> NonOverlapping for CellMOC2ToRangeMOC2<T, Q, I, U, R, J, K, L> where
    T: Idx,
    Q: MocQty<T>,
    I: CellMOCIterator<T, Qty = Q>,
    U: Idx,
    R: MocQty<U>,
    J: CellMOCIterator<U, Qty = R>,
    K: CellMOC2ElemIt<T, Q, U, R, It1 = I, It2 = J>,
    L: CellMOC2Iterator<T, Q, I, U, R, J, K>, 

impl<T, Q, I, U, R, J, K, L> NonOverlapping for RangeMOC2ToCellCellRangeMOC2<T, Q, I, U, R, J, K, L> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>,
    U: Idx,
    R: MocQty<U>,
    J: RangeMOCIterator<U, Qty = R>,
    K: RangeMOC2ElemIt<T, Q, U, R, It1 = I, It2 = J>,
    L: RangeMOC2Iterator<T, Q, I, U, R, J, K>, 

impl<T, Q, I, U, R, J, K, L> NonOverlapping for RangeMOC2ToCellMOC2<T, Q, I, U, R, J, K, L> where
    T: Idx,
    Q: MocQty<T>,
    I: RangeMOCIterator<T, Qty = Q>,
    U: Idx,
    R: MocQty<U>,
    J: RangeMOCIterator<U, Qty = R>,
    K: RangeMOC2ElemIt<T, Q, U, R, It1 = I, It2 = J>,
    L: RangeMOC2Iterator<T, Q, I, U, R, J, K>, 

impl<T, Q, U, R> NonOverlapping for CellMoc2Iter<T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<T, Q, U, R> NonOverlapping for CellOrCellRangeMoc2Iter<T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<T, Q, U, R> NonOverlapping for RangeMOC2<T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<T, Q, U, R> NonOverlapping for RangeMoc2Iter<T, Q, U, R> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>, 

impl<T, Q, U, R, I1, J1, K1, L1, I2, J2, K2, L2> NonOverlapping for OrRange2Iter<T, Q, U, R, I1, J1, K1, L1, I2, J2, K2, L2> where
    T: Idx,
    Q: MocQty<T>,
    U: Idx,
    R: MocQty<U>,
    I1: RangeMOCIterator<T, Qty = Q>,
    J1: RangeMOCIterator<U, Qty = R>,
    K1: RangeMOC2ElemIt<T, Q, U, R, It1 = I1, It2 = J1>,
    L1: RangeMOC2Iterator<T, Q, I1, U, R, J1, K1>,
    I2: RangeMOCIterator<T, Qty = Q>,
    J2: RangeMOCIterator<U, Qty = R>,
    K2: RangeMOC2ElemIt<T, Q, U, R, It1 = I2, It2 = J2>,
    L2: RangeMOC2Iterator<T, Q, I2, U, R, J2, K2>, 

impl<T: Idx, Q: MocQty<T>> NonOverlapping for CellMOC<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for CellMocIter<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for CellOrCellRangeMOC<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for CellOrCellRangeMocIter<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for RangeMOC<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for RangeMocIter<T, Q>

impl<T: Idx, Q: MocQty<T>> NonOverlapping for EmptyRangeMOCIterator<T, Q>

impl<T: Idx, Q: MocQty<T>, I: Iterator<Item = u64>> NonOverlapping for OwnedOrderedFixedDepthCellsToRangesFromU64<T, Q, I>

impl<T: Idx, Q: MocQty<T>, I: Iterator<Item = T>> NonOverlapping for OwnedOrderedFixedDepthCellsToRanges<T, Q, I>

impl<T: Idx, Q: MocQty<T>, R: BufRead> NonOverlapping for MOCFromAsciiStream<T, Q, R>

impl<T: Idx, Q: MocQty<T>, R: BufRead> NonOverlapping for RangeMocIterFromFits<T, Q, R>

impl<T: Idx, Q: MocQty<T>, R: CellMOCIterator<T, Qty = Q>> NonOverlapping for CellOrCellRangeMOCIteratorFromCells<T, Q, R>

impl<T: Idx, Q: MocQty<T>, R: CellMOCIterator<T, Qty = Q>> NonOverlapping for RangeMOCIteratorFromCells<T, Q, R>

impl<T: Idx, Q: MocQty<T>, R: CellOrCellRangeMOCIterator<T, Qty = Q>> NonOverlapping for RangeMOCIteratorFromCellOrCellRanges<T, Q, R>

impl<T: Idx, Q: MocQty<T>, R: RangeMOCIterator<T, Qty = Q>> NonOverlapping for CellMOCIteratorFromRanges<T, Q, R>

impl<T: Idx, R: BufRead> NonOverlapping for RangeMoc2DIterFromFits<T, R>

impl<T: Idx, R: BufRead> NonOverlapping for RangeMoc2DPreV2IterFromFits<T, R>