Struct ClosedRange 

pub struct ClosedRange<T> { /* private fields */ }

A non-empty closed range with an inclusive start value and a strictly-greater exclusive end value.

It includes all values that are greater than or equal to the start value and strictly less than the end value.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert_eq!(r.start(), &2);
assert_eq!(r.end(), &7);

assert!(ClosedRange::try_new(7, 2).is_err());
assert!(ClosedRange::try_new(2, 2).is_err());

Implementations

impl<T> ClosedRange<T>

where T: PartialOrd,

pub fn try_new(start: T, end: T) -> Result<Self, EmptyGrouping>

Creates a new closed range, or an EmptyGrouping error if start >= end.

use willow_data_model::prelude::*;

assert!(ClosedRange::try_new(2, 7).is_ok());
assert!(ClosedRange::try_new(7, 2).is_err());
assert!(ClosedRange::try_new(2, 2).is_err());

pub fn new(start: T, end: T) -> Self

Creates a new closed range, panicking if it would be empty.

use willow_data_model::prelude::*;

let yay = ClosedRange::new(2, 7);

use willow_data_model::prelude::*;

let nope = ClosedRange::new(7, 2);

pub fn includes_value(&self, t: &T) -> bool

Returns whether the given value is included in self.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert!(r.includes_value(&2));
assert!(!r.includes_value(&1));
assert!(!r.includes_value(&7));

pub fn includes_value_in_intersection(&self, other: &Self, t: &T) -> bool

Returns whether the given value is included in self and other.

use willow_data_model::prelude::*;

let r1 = ClosedRange::new(2, 7);
let r2 = ClosedRange::new(5, 9);
assert!(r1.includes_value_in_intersection(&r2, &5));
assert!(!r1.includes_value_in_intersection(&r2, &2));
assert!(!r1.includes_value_in_intersection(&r2, &7));
assert!(!r1.includes_value_in_intersection(&r2, &22));

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

Returns whether the given closed range is included in self.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert!(r.includes_closed_range(&ClosedRange::new(3, 6)));
assert!(r.includes_closed_range(&ClosedRange::new(2, 5)));
assert!(r.includes_closed_range(&ClosedRange::new(3, 7)));
assert!(r.includes_closed_range(&ClosedRange::new(2, 7)));
assert!(!r.includes_closed_range(&ClosedRange::new(1, 7)));
assert!(!r.includes_closed_range(&ClosedRange::new(2, 8)));
assert!(!r.includes_closed_range(&ClosedRange::new(9, 14)));

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

Returns whether the given closed range is strictly included in self.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert!(r.strictly_includes_closed_range(&ClosedRange::new(2, 6)));
assert!(r.strictly_includes_closed_range(&ClosedRange::new(3, 7)));
assert!(r.strictly_includes_closed_range(&ClosedRange::new(3, 6)));
assert!(!r.strictly_includes_closed_range(&ClosedRange::new(2, 7)));
assert!(!r.strictly_includes_closed_range(&ClosedRange::new(1, 7)));
assert!(!r.strictly_includes_closed_range(&ClosedRange::new(2, 8)));
assert!(!r.strictly_includes_closed_range(&ClosedRange::new(9, 14)));

impl<T> ClosedRange<T>

where T: PartialOrd + Clone,

pub fn intersection_closed_range( &self, other: &Self, ) -> Result<Self, EmptyGrouping>

Returns the intersection between self and other, or an EmptyGrouping error if it would be empty.

assert_eq!( ClosedRange::new(2, 7).intersection_closed_range(ClosedRange::new(5, 9)), Ok(ClosedRange::new(5, 7)), ); assert!( ClosedRange::new(2, 5).intersection_closed_range(ClosedRange::new(7, 9)).is_error(), );

impl<T> ClosedRange<T>

pub unsafe fn new_unchecked(start: T, end: T) -> Self

Creates a new closed range, without enforcing non-emptyness.

Safety

Calling this method with start >= end is undefined behaviour.

use willow_data_model::prelude::*;

let yay = unsafe { ClosedRange::new_unchecked(2, 7) };

pub fn start(&self) -> &T

Returns a reference to the start value of this closed range.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert_eq!(r.start(), &2);

pub fn end(&self) -> &T

Returns a reference to the end value of this closed range.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert_eq!(r.end(), &7);

pub fn into_parts(self) -> (T, T)

Takes ownership of a closed range and returns its start and end value.

use willow_data_model::prelude::*;

let r = ClosedRange::new(2, 7);
assert_eq!(r.into_parts(), (2, 7));

Trait Implementations

impl<'a, T> Arbitrary<'a> for ClosedRange<T>

where T: Arbitrary<'a> + PartialOrd,

Available on crate feature dev only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T: Clone> Clone for ClosedRange<T>

fn clone(&self) -> ClosedRange<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ClosedRange<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for ClosedRange<T>

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<T: PartialEq> PartialEq for ClosedRange<T>

fn eq(&self, other: &ClosedRange<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> PartialOrd for ClosedRange<T>

where T: PartialOrd,

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> RangeBounds<T> for ClosedRange<T>

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

Start index bound.

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

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.

fn is_empty(&self) -> bool

where T: PartialOrd,

🔬This is a nightly-only experimental API. (range_bounds_is_empty)

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T: Copy> Copy for ClosedRange<T>

impl<T: Eq> Eq for ClosedRange<T>

impl<T> StructuralPartialEq for ClosedRange<T>