Struct ReversibleRange

pub struct ReversibleRange<S: Numeric> {
    pub start: S,
    pub end: S,
}

An inclusive total range that can be used in reverse order

Fields

start: S

The starting point of the range Does not need to be < end

end: S

The ending point of the range Does not need to be > start

Implementations

impl<S: Numeric> ReversibleRange<S>

pub const fn new(from: S, to: S) -> Self

Create a new range from a start and end value The values do not need to be in order

pub fn contains(&self, value: S) -> bool

Check if the range contains the given value Returns true if value is between the start and end values

pub fn is_empty(&self) -> bool

Check if the range is empty Returns true if the start and end values are the same

pub fn len(&self) -> S

Get the length of the range

pub fn is_reversed(&self) -> bool

Check if the range is reversed Returns true if the start value is greater than the end value

Trait Implementations

impl<S: Clone + Numeric> Clone for ReversibleRange<S>

fn clone(&self) -> ReversibleRange<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Numeric> Debug for ReversibleRange<S>

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

Formats the value using the given formatter.

impl<S> From<[S; 2]> for ReversibleRange<S>

where S: Numeric,

fn from(range: [S; 2]) -> Self

Converts to this type from the input type.

impl<S> From<(S, S)> for ReversibleRange<S>

where S: Numeric,

fn from(range: (S, S)) -> Self

Converts to this type from the input type.

impl<S: Numeric> From<RangeInclusive<S>> for ReversibleRange<S>

fn from(range: RangeInclusive<S>) -> Self

Converts to this type from the input type.

impl<S: Hash + Numeric> Hash for ReversibleRange<S>

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<S: PartialEq + Numeric> PartialEq for ReversibleRange<S>

fn eq(&self, other: &ReversibleRange<S>) -> 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<S: Eq + Numeric> Eq for ReversibleRange<S>

impl<S: Numeric> StructuralPartialEq for ReversibleRange<S>