Trait Overlap 

pub trait Overlap<RHS = Self> {
    // Required method
    fn overlap(&self, rhs: &RHS) -> bool;
}

Required Methods

fn overlap(&self, rhs: &RHS) -> bool

Implementations on Foreign Types

impl Overlap for i8

fn overlap(&self, value: &i8) -> bool

impl Overlap for i16

fn overlap(&self, value: &i16) -> bool

impl Overlap for i32

fn overlap(&self, value: &i32) -> bool

impl Overlap for i64

fn overlap(&self, value: &i64) -> bool

impl Overlap for isize

fn overlap(&self, value: &isize) -> bool

impl Overlap for u8

fn overlap(&self, value: &u8) -> bool

impl Overlap for u16

fn overlap(&self, value: &u16) -> bool

impl Overlap for u32

fn overlap(&self, value: &u32) -> bool

impl Overlap for u64

fn overlap(&self, value: &u64) -> bool

impl Overlap for usize

fn overlap(&self, value: &usize) -> bool

impl Overlap<Interval<i8>> for i8

fn overlap(&self, other: &Interval<i8>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as i8).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as i8).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as i8).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as i8).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as i8).overlap(&Interval::empty()), false);

impl Overlap<Interval<i16>> for i16

fn overlap(&self, other: &Interval<i16>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as i16).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as i16).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as i16).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as i16).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as i16).overlap(&Interval::empty()), false);

impl Overlap<Interval<i32>> for i32

fn overlap(&self, other: &Interval<i32>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as i32).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as i32).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as i32).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as i32).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as i32).overlap(&Interval::empty()), false);

impl Overlap<Interval<i64>> for i64

fn overlap(&self, other: &Interval<i64>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as i64).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as i64).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as i64).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as i64).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as i64).overlap(&Interval::empty()), false);

impl Overlap<Interval<isize>> for isize

fn overlap(&self, other: &Interval<isize>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as isize).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as isize).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as isize).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as isize).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as isize).overlap(&Interval::empty()), false);

impl Overlap<Interval<u8>> for u8

fn overlap(&self, other: &Interval<u8>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as u8).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as u8).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as u8).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as u8).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as u8).overlap(&Interval::empty()), false);

impl Overlap<Interval<u16>> for u16

fn overlap(&self, other: &Interval<u16>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as u16).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as u16).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as u16).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as u16).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as u16).overlap(&Interval::empty()), false);

impl Overlap<Interval<u32>> for u32

fn overlap(&self, other: &Interval<u32>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as u32).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as u32).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as u32).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as u32).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as u32).overlap(&Interval::empty()), false);

impl Overlap<Interval<u64>> for u64

fn overlap(&self, other: &Interval<u64>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as u64).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as u64).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as u64).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as u64).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as u64).overlap(&Interval::empty()), false);

impl Overlap<Interval<usize>> for usize

fn overlap(&self, other: &Interval<usize>) -> bool

Calculates whether a value is included in an interval.

assert_eq!((1 as usize).overlap(&Interval::new(8, 9)), false);
assert_eq!((3 as usize).overlap(&Interval::new(1, 5)), true);
assert_eq!((5 as usize).overlap(&Interval::new(3, 5)), true);
assert_eq!((3 as usize).overlap(&Interval::new(3, 3)), true);
assert_eq!((6 as usize).overlap(&Interval::empty()), false);

impl Overlap<IntervalSet<i8>> for i8

fn overlap(&self, other: &IntervalSet<i8>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<i8> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as i8).overlap(&interval_set));
assert!((8 as i8).overlap(&interval_set));
assert!((9 as i8).overlap(&interval_set));
///
assert!(!(1 as i8).overlap(&interval_set));
assert!(!(7 as i8).overlap(&interval_set));
assert!(!(10 as i8).overlap(&interval_set));

impl Overlap<IntervalSet<i16>> for i16

fn overlap(&self, other: &IntervalSet<i16>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<i16> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as i16).overlap(&interval_set));
assert!((8 as i16).overlap(&interval_set));
assert!((9 as i16).overlap(&interval_set));
///
assert!(!(1 as i16).overlap(&interval_set));
assert!(!(7 as i16).overlap(&interval_set));
assert!(!(10 as i16).overlap(&interval_set));

impl Overlap<IntervalSet<i32>> for i32

fn overlap(&self, other: &IntervalSet<i32>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<i32> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as i32).overlap(&interval_set));
assert!((8 as i32).overlap(&interval_set));
assert!((9 as i32).overlap(&interval_set));
///
assert!(!(1 as i32).overlap(&interval_set));
assert!(!(7 as i32).overlap(&interval_set));
assert!(!(10 as i32).overlap(&interval_set));

impl Overlap<IntervalSet<i64>> for i64

fn overlap(&self, other: &IntervalSet<i64>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<i64> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as i64).overlap(&interval_set));
assert!((8 as i64).overlap(&interval_set));
assert!((9 as i64).overlap(&interval_set));
///
assert!(!(1 as i64).overlap(&interval_set));
assert!(!(7 as i64).overlap(&interval_set));
assert!(!(10 as i64).overlap(&interval_set));

impl Overlap<IntervalSet<isize>> for isize

fn overlap(&self, other: &IntervalSet<isize>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<isize> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as isize).overlap(&interval_set));
assert!((8 as isize).overlap(&interval_set));
assert!((9 as isize).overlap(&interval_set));
///
assert!(!(1 as isize).overlap(&interval_set));
assert!(!(7 as isize).overlap(&interval_set));
assert!(!(10 as isize).overlap(&interval_set));

impl Overlap<IntervalSet<u8>> for u8

fn overlap(&self, other: &IntervalSet<u8>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<u8> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as u8).overlap(&interval_set));
assert!((8 as u8).overlap(&interval_set));
assert!((9 as u8).overlap(&interval_set));
///
assert!(!(1 as u8).overlap(&interval_set));
assert!(!(7 as u8).overlap(&interval_set));
assert!(!(10 as u8).overlap(&interval_set));

impl Overlap<IntervalSet<u16>> for u16

fn overlap(&self, other: &IntervalSet<u16>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<u16> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as u16).overlap(&interval_set));
assert!((8 as u16).overlap(&interval_set));
assert!((9 as u16).overlap(&interval_set));
///
assert!(!(1 as u16).overlap(&interval_set));
assert!(!(7 as u16).overlap(&interval_set));
assert!(!(10 as u16).overlap(&interval_set));

impl Overlap<IntervalSet<u32>> for u32

fn overlap(&self, other: &IntervalSet<u32>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<u32> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as u32).overlap(&interval_set));
assert!((8 as u32).overlap(&interval_set));
assert!((9 as u32).overlap(&interval_set));
///
assert!(!(1 as u32).overlap(&interval_set));
assert!(!(7 as u32).overlap(&interval_set));
assert!(!(10 as u32).overlap(&interval_set));

impl Overlap<IntervalSet<u64>> for u64

fn overlap(&self, other: &IntervalSet<u64>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<u64> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as u64).overlap(&interval_set));
assert!((8 as u64).overlap(&interval_set));
assert!((9 as u64).overlap(&interval_set));
///
assert!(!(1 as u64).overlap(&interval_set));
assert!(!(7 as u64).overlap(&interval_set));
assert!(!(10 as u64).overlap(&interval_set));

impl Overlap<IntervalSet<usize>> for usize

fn overlap(&self, other: &IntervalSet<usize>) -> bool

Calculates whether a value is included in an interval set.

let interval_set: IntervalSet<usize> = [(3, 5), (8, 9)].to_interval_set();
assert!((3 as usize).overlap(&interval_set));
assert!((8 as usize).overlap(&interval_set));
assert!((9 as usize).overlap(&interval_set));
///
assert!(!(1 as usize).overlap(&interval_set));
assert!(!(7 as usize).overlap(&interval_set));
assert!(!(10 as usize).overlap(&interval_set));

impl<T> Overlap<Optional<T>> for bool

where T: Overlap<bool>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for char

where T: Overlap<char>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for f32

where T: Overlap<f32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for f64

where T: Overlap<f64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i8

where T: Overlap<i8>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i16

where T: Overlap<i16>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i32

where T: Overlap<i32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for i64

where T: Overlap<i64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for isize

where T: Overlap<isize>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u8

where T: Overlap<u8>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u16

where T: Overlap<u16>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u32

where T: Overlap<u32>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for u64

where T: Overlap<u64>,

fn overlap(&self, other: &Optional<T>) -> bool

impl<T> Overlap<Optional<T>> for usize

where T: Overlap<usize>,

fn overlap(&self, other: &Optional<T>) -> bool

Implementors

impl Overlap<Interval<i8>> for Optional<i8>

impl Overlap<Interval<i16>> for Optional<i16>

impl Overlap<Interval<i32>> for Optional<i32>

impl Overlap<Interval<i64>> for Optional<i64>

impl Overlap<Interval<isize>> for Optional<isize>

impl Overlap<Interval<u8>> for Optional<u8>

impl Overlap<Interval<u16>> for Optional<u16>

impl Overlap<Interval<u32>> for Optional<u32>

impl Overlap<Interval<u64>> for Optional<u64>

impl Overlap<Interval<usize>> for Optional<usize>

impl<Bound> Overlap for Interval<Bound>

where Bound: Width + Num,

impl<Bound> Overlap<Optional<Bound>> for Interval<Bound>

where Bound: Width + Num,

impl<Bound> Overlap<Bound> for Interval<Bound>

where Bound: Width + Num,

impl<Bound: Width + Num> Overlap for IntervalSet<Bound>

impl<Bound: Width + Num> Overlap<Optional<Bound>> for IntervalSet<Bound>

impl<Bound: Width + Num> Overlap<Bound> for IntervalSet<Bound>

impl<T, U> Overlap<Optional<U>> for Optional<T>

where T: Overlap<U>,

impl<T, U> Overlap<U> for Optional<T>

where T: Overlap<U>, U: GroundType,