Struct nodit::interval::Interval

pub struct Interval<I> { /* private fields */ }

An inclusive interval, only valid intervals can be constructed.

This interval struct is used throughout this crate for the examples and tests but can also be used by library users if they don’t wish to create their own interval types.

To create an InclusiveInterval use one of the various contrutor functions which will all panic if you try to create an invalid interval. See Invalid Intervals for more details.

use nodit::interval::{ee, ii};

let inclusive_interval = ii(4, 4);
let exclusive_interval = ee(3, 5);

assert_eq!(inclusive_interval, exclusive_interval);

use nodit::interval::ee;

let invalid_interval = ee(4, 4);

Implementations

impl<I> Interval<I>

where I: PointType,

pub fn start(&self) -> I

The start of the interval, inclusive.

use nodit::interval::ii;

assert_eq!(ii(2, 4).start(), 2);

pub fn end(&self) -> I

The end of the interval, inclusive.

use nodit::interval::ii;

assert_eq!(ii(2, 4).end(), 4);

Trait Implementations

impl<I: Clone> Clone for Interval<I>

fn clone(&self) -> Interval<I>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug> Debug for Interval<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for Interval<I>

where I: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> From<Interval<I>> for Range<I>

where I: PointType,

fn from(value: Interval<I>) -> Self

Converts to this type from the input type.

impl<I> From<Interval<I>> for RangeInclusive<I>

fn from(value: Interval<I>) -> Self

Converts to this type from the input type.

impl<I> From<Range<I>> for Interval<I>

where I: PointType,

fn from(value: Range<I>) -> Self

Converts to this type from the input type.

impl<I> From<RangeInclusive<I>> for Interval<I>

where I: PointType,

fn from(value: RangeInclusive<I>) -> Self

Converts to this type from the input type.

impl<I: Hash> Hash for Interval<I>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I> InclusiveInterval<I> for Interval<I>

where I: PointType,

fn start(&self) -> I

The start of the interval, inclusive.

fn end(&self) -> I

The end of the interval, inclusive.

fn contains(&self, point: I) -> bool

where I: PointType,

Does the interval contain the given point?

fn is_valid(&self) -> bool

where I: PointType,

Is the interval is valid, which according to this crate means start() <= end()

fn touches_ordered(&self, other: &Self) -> bool

where I: PointType,

Requires that self comes before other and they don’t overlap

fn overlaps_ordered(&self, other: &Self) -> bool

where I: PointType,

Requires that self comes before other

fn intersect(&self, other: &Self) -> Option<Self>

where I: PointType, Self: From<Interval<I>>,

Intersect the interval with the other one, and return Some if the intersection is not empty.

fn merge_ordered(&self, other: &Self) -> Self

where Self: From<Interval<I>>,

Requires that self comes before other

impl<I: PartialEq> PartialEq for Interval<I>

fn eq(&self, other: &Interval<I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> RangeBounds<I> for Interval<I>

where I: PointType,

fn start_bound(&self) -> Bound<&I>

Start index bound.

fn end_bound(&self) -> Bound<&I>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

impl<I> Serialize for Interval<I>

where I: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Copy> Copy for Interval<I>

impl<I: Eq> Eq for Interval<I>

impl<I> StructuralEq for Interval<I>

impl<I> StructuralPartialEq for Interval<I>