Struct IntervalLimit 

pub struct IntervalLimit<T: Display + Clone + Hash + Ord> { /* private fields */ }

A struct that represents a “limit” in an interval.

In order to understand this struct, it is important to correctly recognize the distinction between limit and value. The limit is the value represented by this struct self, and the value represented by value is the limit value.

When a limit is “closed”, it means that the limit itself is not considered to be exceeded. An “open” limit means that it is considered to be exceeded.

An infinite limit is an unbounded limit, and we express this state by saying that value is Limitless. Infinite limits are always considered to be open. Conversely, a limit that is not an infinite limit (one whose value is not Limitless) is called a finite limit.

The lower limit represents the limit where values below (or below) the limit are considered to be exceeded, and the upper limit represents the limit where values above (or above) the limit are considered to be exceeded.

closed: if the limit is closed true lower: truefor the lower limit,false` for the upper limit value: limit value, in the case of Limitless, it indicates that there is no limit.

Implementations

impl<T: Display + Clone + Hash + Eq + Ord + PartialEq + PartialOrd> IntervalLimit<T>

pub fn is_closed(&self) -> bool

Verify whether this limit is closed or not.

• return: if it is closed, true, otherwise false.

pub fn is_open(&self) -> bool

Verify whether this limit is open or not.

• return: if it is open, true, otherwise false.

pub fn is_lower(&self) -> bool

Verify whether or not this limit is the lower side limit.

• return: true for an lower limit, false otherwise

pub fn is_upper(&self) -> bool

Verify whether or not this limit is the upper side limit.

• return: true for an upper limit, false otherwise

pub fn is_infinity(&self) -> bool

Verify whether this limit is an infinite limit.

• return: if it is an infinite limit, it is true, otherwise it is `false

pub fn is_finite(&self) -> bool

Verify whether this limit is an finite limit.

• return: if it is an finite limit, it is true, otherwise it is `false

pub fn as_value(&self) -> &LimitValue<T>

Get limit value.

• return: limit value

pub fn new(closed: bool, lower: bool, value: LimitValue<T>) -> Self

Generate a limit

• params
  • closed: if the limit is closed `true
  • lower: true for the lower limit, false for the upper limit
  • value: limit value, in the case of Limitless, it indicates that there is no limit.
• return: a new limit

pub fn lower(closed: bool, value: LimitValue<T>) -> Self

Generate a lower limit

• params
  • closed: if the limit is closed `true
  • value: limit value, in the case of Limitless, it indicates that there is no limit.
• return: a new limit

pub fn upper(closed: bool, value: LimitValue<T>) -> Self

Generate a upper limit

• params
  • closed: if the limit is closed `true
  • value: limit value, in the case of Limitless, it indicates that there is no limit.
• return: a new limit

Trait Implementations

impl<T: Clone + Display + Clone + Hash + Ord> Clone for IntervalLimit<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Display + Clone + Hash + Ord> Debug for IntervalLimit<T>

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

Formats the value using the given formatter.

impl<T: Display + Clone + Hash + Eq + Ord + PartialEq + PartialOrd> Display for IntervalLimit<T>

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

Formats the value using the given formatter.

impl<T: Hash + Display + Clone + Hash + Ord> Hash for IntervalLimit<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: Ord + Display + Clone + Hash + Ord> Ord for IntervalLimit<T>

fn cmp(&self, other: &IntervalLimit<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: Display + Clone + Hash + Eq + Ord + PartialEq + PartialOrd> PartialEq for IntervalLimit<T>

fn eq(&self, other: &Self) -> 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: Display + Clone + Hash + Eq + Ord + PartialEq + PartialOrd> PartialOrd for IntervalLimit<T>

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: Eq + Display + Clone + Hash + Ord> Eq for IntervalLimit<T>