Struct arranged::Ranged

pub struct Ranged<TRange>(_)
 where
    TRange: IRange;

Implementations

impl<TRange> Ranged<TRange> where
    TRange: IRange + IRangeFrom + IRangeToInclusive,
    ErrInt: From<TRange::ValueType>, 

pub const fn from(value: TRange::ValueType) -> Self where
    TRange: IRange + IRangeFrom + IRangeTo, 

Constructor This constructor is intended to be called from const context. This way, if the value passed in is out of bounds, the compilation will fail. If the code runs, it means the value passed in was within bounds and therefore the function signature is infallible (at runtime). NOTE: Rust does not provide a way to only provide a (const) method at compile-time, thus, this function can also be called with a runtime value. In such a case, it will panic if the provided value is out of bounds. When writing panic-free code, use the try_from() constructor instead.

Returns

Self, if value is within TRange’s range bounds.

Panics

If value is not within TRange’s range bounds: * fails to compile if value is const (or a literal), or * panics at runtime if value is not const (prefer try_from() constructor instead).

pub const fn try_from(value: TRange::ValueType) -> Result<Self> where
    TRange: IRange + IRangeFrom + IRangeTo, 

Constructor

Returns

Returns Some(Self) when value is within bounds or None otherwise.

pub const unsafe fn unchecked_from(value: TRange::ValueType) -> Self

Constructor For orthogonality with this type’s other constructors, this constructor may be called from const context.

Returns

Self, unconditionally.

Safety

This constructor is unsafe because the value being passed in is not verified to be within the bounds of TRange. It is the caller’s responsibility to ensure that this contract is upheld–violating it is Undefined Behavior.

Trait Implementations

impl<TRange: Clone> Clone for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Clone, 

fn clone(&self) -> Ranged<TRange>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TRange: Debug> Debug for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Debug, 

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

Formats the value using the given formatter.

impl<TRange: Default> Default for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Default, 

fn default() -> Ranged<TRange>

Returns the “default value” for a type.

impl<TRange: Hash> Hash for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Hash, 

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, 

Feeds a slice of this type into the given Hasher.

impl<TRange> IMinMax<Ranged<TRange>> for Ranged<TRange> where
    Self: PartialOrd,
    TRange: IRangeFrom + IRangeTo + IRangeToInclusive, 

const MAX: Self = Self(TRange::end())

const MIN: Self = Self(TRange::start())

impl<TRangeLhs> IUnaryWrappingOps for Ranged<TRangeLhs> where
    Self: PartialOrd,
    TRangeLhs: Clone + IMinMax<TRangeLhs::ValueType> + IRangeFrom + IRangeToInclusive,
    TRangeLhs::ValueType: PartialOrd + IWrappingOps,
    <TRangeLhs as IRange>::WidenedValueType: IWrappingOps<Output = <TRangeLhs as IRange>::WidenedValueType> + Clone + NumOps<<TRangeLhs as IRange>::WidenedValueType, <TRangeLhs as IRange>::WidenedValueType> + One + PartialOrd + Zero, 

type Output = Ranged<TRangeLhs>

fn wrapping_abs(self) -> Self::Output

fn wrapping_neg(self) -> Self::Output

fn wrapping_pow(self, _rhs: u32) -> Self::Output

fn wrapping_shl(self, _rhs: u32) -> Self::Output

fn wrapping_shr(self, _rhs: u32) -> Self::Output

impl<TRangeLhs, TRangeRhs> IWrappingOps<Ranged<TRangeRhs>> for Ranged<TRangeLhs> where
    ErrInt: From<TRangeLhs::ValueType>,
    Self: PartialOrd,
    TRangeLhs: Clone + IMinMax<TRangeLhs::ValueType> + IRangeFrom + IRangeToInclusive + PartialOrd,
    TRangeLhs::ValueType: Debug + PartialOrd + IWrappingOps,
    TRangeLhs::WidenedValueType: Add<TRangeRhs::WidenedValueType, Output = TRangeLhs::WidenedValueType> + Clone + Debug + Div<Output = TRangeLhs::WidenedValueType> + IWrappingOps<Output = <TRangeLhs as IRange>::WidenedValueType> + NumOps<<TRangeLhs as IRange>::WidenedValueType, <TRangeLhs as IRange>::WidenedValueType> + One + PartialOrd + Sub<TRangeRhs::WidenedValueType, Output = TRangeLhs::WidenedValueType> + Zero,
    TRangeRhs: IRangeFrom + IRangeToInclusive, 

fn wrapping_add(self, rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_div(self, _rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_div_euclid(self, _rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_mul(self, _rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_rem(self, _rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_rem_euclid(self, _rhs: Ranged<TRangeRhs>) -> Self::Output

fn wrapping_sub(self, rhs: Ranged<TRangeRhs>) -> Self::Output

impl<TRange: Ord> Ord for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Ord, 

fn cmp(&self, other: &Ranged<TRange>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<TRange: PartialEq> PartialEq<Ranged<TRange>> for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: PartialEq, 

fn eq(&self, other: &Ranged<TRange>) -> bool

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

fn ne(&self, other: &Ranged<TRange>) -> bool

This method tests for !=.

impl<TRange: PartialOrd> PartialOrd<Ranged<TRange>> for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: PartialOrd, 

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<TRange: Copy> Copy for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Copy, 

impl<TRange: Eq> Eq for Ranged<TRange> where
    TRange: IRange,
    TRange::ValueType: Eq, 

impl<TRange> StructuralEq for Ranged<TRange> where
    TRange: IRange, 

impl<TRange> StructuralPartialEq for Ranged<TRange> where
    TRange: IRange,