Struct IntervalsSingle 

pub struct IntervalsSingle<E, V> { /* private fields */ }

An Intervals stream containing a single Interval.

This is the simplest way to lift an Interval into the Intervals trait so it can participate in composition (&, |, etc.).

Implementations

impl<E, V> IntervalsSingle<E, V>

pub fn new(v: Interval<E, V>) -> Self

Wrap a single Interval.

Examples found in repository

examples/shift.rs (line 10)

fn main() {
    // [1, 4)
    let i = Interval::new(EndpointOC::Closed(1), EndpointOC::Open(4), ());
    let is = IntervalsSingle::new(i);

    // Shift everything by +5 → [6, 9)
    for iv in IntervalShift::new(is, 5).into_iter() {
        println!("{:?}", iv);
    }
}

examples/union.rs (line 16)

fn main() {
    // [1, 3] tagged "A"
    let ia = Interval::new(EndpointOC::Closed(1), EndpointOC::Closed(3), "A");
    // (2, 4) tagged "B"
    let ib = Interval::new(EndpointOC::Open(2), EndpointOC::Open(4), "B");

    let isa = IntervalsSingle::new(ia);
    let isb = IntervalsSingle::new(ib);

    // Union: [1,2] -> (Some("A"), None), (2,3] -> (Some("A"), Some("B")), (3,4) -> (None, Some("B"))
    for iv in or(isa, isb).into_iter() {
        println!("{:?}", iv);
    }
}

examples/intersection.rs (line 13)

fn main() {
    // [1, 3] tagged "A"
    let ia = Interval::new(EndpointOC::Closed(1), EndpointOC::Closed(3), "A");
    // (2, 4) tagged "B"
    let ib = Interval::new(EndpointOC::Open(2), EndpointOC::Open(4), "B");

    let isa = IntervalsSingle::new(ia);
    let isb = IntervalsSingle::new(ib);

    // Intersection: (2, 3] tagged ("A", "B")
    let result = and(isa, isb).into_iter().collect::<Vec<_>>();

    for iv in &result {
        println!("{:?}", iv);
    }

    assert_eq!(result.len(), 1);
    assert_eq!(
        result[0],
        Interval::new(EndpointOC::Open(2), EndpointOC::Closed(3), ("A", "B"))
    );
}

Trait Implementations

impl<T, V, Ic> BitAnd<Ic> for IntervalsSingle<T, V>

where Self: Intervals, Ic: Intervals<Endpoint = <Self as Intervals>::Endpoint>,

Available on crate feature operators only.

type Output = IntervalsWrap<IntervalsAnd<IntervalsSingle<T, V>, Ic>>

The resulting type after applying the & operator.

fn bitand(self, c: Ic) -> Self::Output

Performs the & operation.

impl<T, V, Ic> BitOr<Ic> for IntervalsSingle<T, V>

Available on crate feature operators only.

type Output = IntervalsWrap<IntervalsOr<IntervalsSingle<T, V>, Ic>>

The resulting type after applying the | operator.

fn bitor(self, c: Ic) -> Self::Output

Performs the | operation.

impl<E, V> Intervals for IntervalsSingle<E, V>

where E: Clone + EndpointToggle, LeftT<E>: Ord, V: Copy,

type Endpoint = E

The endpoint flavor — typically EndpointOC or EndpointSymmetric.

type Value = V

The value attached to each interval.

fn head( &mut self, pos: Option<LeftT<Self::Endpoint>>, ) -> Option<Interval<Self::Endpoint, Self::Value>>

Return the next interval whose right endpoint is greater than pos.