Struct deranged::RangedIsize

pub struct RangedIsize<const MIN: isize, const MAX: isize>(/* private fields */);

An isize that is known to be in the range MIN..=MAX.

Implementations

impl RangedIsize<0, 0>

pub const fn exact<const VALUE: isize>() -> RangedIsize<VALUE, VALUE>

impl<const MIN: isize, const MAX: isize> RangedIsize<MIN, MAX>

pub const MIN: Self = _

The smallest value that can be represented by this type.

pub const MAX: Self = _

The largest value that can be represented by this type.

pub const unsafe fn new_unchecked(value: isize) -> Self

Creates a ranged integer without checking the value.

Safety

The value must be within the range MIN..=MAX.

pub const fn get(self) -> isize

Returns the value as a primitive type.

pub const fn new(value: isize) -> Option<Self>

Creates a ranged integer if the given value is in the range MIN..=MAX.

pub const fn new_static<const VALUE: isize>() -> Self

Creates a ranged integer with a statically known value. Fails to compile if the value is not in range.

pub const fn new_saturating(value: isize) -> Self

Creates a ranged integer with the given value, saturating if it is out of range.

pub const fn expand<const NEW_MIN: isize, const NEW_MAX: isize>( self, ) -> RangedIsize<NEW_MIN, NEW_MAX>

Expand the range that the value may be in. Fails to compile if the new range is not a superset of the current range.

pub const fn narrow<const NEW_MIN: isize, const NEW_MAX: isize>( self, ) -> Option<RangedIsize<NEW_MIN, NEW_MAX>>

Attempt to narrow the range that the value may be in. Returns None if the value is outside the new range. Fails to compile if the new range is not a subset of the current range.

pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError>

Converts a string slice in a given base to an integer.

The string is expected to be an optional + or - sign followed by digits. Leading and trailing whitespace represent an error. Digits are a subset of these characters, depending on radix:

• 0-9
• a-z
• A-Z

Panics

Panics if radix is not in the range 2..=36.

Examples

Basic usage:

assert_eq!(RangedIsize::<5, 10>::from_str_radix("A", 16), Ok(RangedIsize::new_static::<10>()));

pub const fn checked_add(self, rhs: isize) -> Option<Self>

Checked integer addition. Computes self + rhs, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_add(self, rhs: isize) -> Self

Unchecked integer addition. Computes self + rhs, assuming that the result is in range.

Safety

The result of self + rhs must be in the range MIN..=MAX.

pub const fn checked_sub(self, rhs: isize) -> Option<Self>

Checked integer addition. Computes self - rhs, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_sub(self, rhs: isize) -> Self

Unchecked integer subtraction. Computes self - rhs, assuming that the result is in range.

Safety

The result of self - rhs must be in the range MIN..=MAX.

pub const fn checked_mul(self, rhs: isize) -> Option<Self>

Checked integer addition. Computes self * rhs, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_mul(self, rhs: isize) -> Self

Unchecked integer multiplication. Computes self * rhs, assuming that the result is in range.

Safety

The result of self * rhs must be in the range MIN..=MAX.

pub const fn checked_div(self, rhs: isize) -> Option<Self>

Checked integer addition. Computes self / rhs, returning None if rhs == 0 or if the resulting value is out of range.

pub const unsafe fn unchecked_div(self, rhs: isize) -> Self

Unchecked integer division. Computes self / rhs, assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self / rhs must be in the range MIN..=MAX.

pub const fn checked_div_euclid(self, rhs: isize) -> Option<Self>

Checked Euclidean division. Computes self.div_euclid(rhs), returning None if rhs == 0 or if the resulting value is out of range.

pub const unsafe fn unchecked_div_euclid(self, rhs: isize) -> Self

Unchecked Euclidean division. Computes self.div_euclid(rhs), assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self.div_euclid(rhs) must be in the range MIN..=MAX.

pub const fn checked_rem(self, rhs: isize) -> Option<Self>

Checked integer remainder. Computes self % rhs, returning None if rhs == 0 or if the resulting value is out of range.

pub const unsafe fn unchecked_rem(self, rhs: isize) -> Self

Unchecked remainder. Computes self % rhs, assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self % rhs must be in the range MIN..=MAX.

pub const fn checked_rem_euclid(self, rhs: isize) -> Option<Self>

Checked Euclidean remainder. Computes self.rem_euclid(rhs), returning None if rhs == 0 or if the resulting value is out of range.

pub const unsafe fn unchecked_rem_euclid(self, rhs: isize) -> Self

Unchecked Euclidean remainder. Computes self.rem_euclid(rhs), assuming that rhs != 0 and that the result is in range.

Safety

self must not be zero and the result of self.rem_euclid(rhs) must be in the range MIN..=MAX.

pub const fn checked_neg(self) -> Option<Self>

Checked negation. Computes -self, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_neg(self) -> Self

Unchecked negation. Computes -self, assuming that -self is in range.

Safety

The result of -self must be in the range MIN..=MAX.

pub const fn neg(self) -> Self

Negation. Computes self.neg(), failing to compile if the result is not guaranteed to be in range.

pub const fn checked_shl(self, rhs: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_shl(self, rhs: u32) -> Self

Unchecked shift left. Computes self << rhs, assuming that the result is in range.

Safety

The result of self << rhs must be in the range MIN..=MAX.

pub const fn checked_shr(self, rhs: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if the resulting value is out of range.

pub const unsafe fn unchecked_shr(self, rhs: u32) -> Self

Unchecked shift right. Computes self >> rhs, assuming that the result is in range.

Safety

The result of self >> rhs must be in the range MIN..=MAX.

pub const fn checked_abs(self) -> Option<Self>

Checked absolute value. Computes self.abs(), returning None if the resulting value is out of range.

pub const unsafe fn unchecked_abs(self) -> Self

Unchecked absolute value. Computes self.abs(), assuming that the result is in range.

Safety

The result of self.abs() must be in the range MIN..=MAX.

pub const fn abs(self) -> Self

Absolute value. Computes self.abs(), failing to compile if the result is not guaranteed to be in range.

pub const fn checked_pow(self, exp: u32) -> Option<Self>

Checked exponentiation. Computes self.pow(exp), returning None if the resulting value is out of range.

pub const unsafe fn unchecked_pow(self, exp: u32) -> Self

Unchecked exponentiation. Computes self.pow(exp), assuming that the result is in range.

Safety

The result of self.pow(exp) must be in the range MIN..=MAX.

pub const fn saturating_add(self, rhs: isize) -> Self

Saturating integer addition. Computes self + rhs, saturating at the numeric bounds.

pub const fn saturating_sub(self, rhs: isize) -> Self

Saturating integer subtraction. Computes self - rhs, saturating at the numeric bounds.

pub const fn saturating_neg(self) -> Self

Saturating integer negation. Computes self - rhs, saturating at the numeric bounds.

pub const fn saturating_abs(self) -> Self

Saturating absolute value. Computes self.abs(), saturating at the numeric bounds.

pub const fn saturating_mul(self, rhs: isize) -> Self

Saturating integer multiplication. Computes self * rhs, saturating at the numeric bounds.

pub const fn saturating_pow(self, exp: u32) -> Self

Saturating integer exponentiation. Computes self.pow(exp), saturating at the numeric bounds.

pub const fn wrapping_add(self, rhs: isize) -> Self

Wrapping integer addition. Computes self + rhs, wrapping around the numeric bounds.

pub const fn wrapping_sub(self, rhs: isize) -> Self

Wrapping integer subtraction. Computes self - rhs, wrapping around the numeric bounds.

Trait Implementations

impl<const MIN: isize, const MAX: isize> AsRef<isize> for RangedIsize<MIN, MAX>

fn as_ref(&self) -> &isize

Converts this type into a shared reference of the (usually inferred) input type.

impl<const MIN: isize, const MAX: isize> Binary for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Borrow<isize> for RangedIsize<MIN, MAX>

fn borrow(&self) -> &isize

Immutably borrows from an owned value.

impl<const MIN: isize, const MAX: isize> Clone for RangedIsize<MIN, MAX>

fn clone(&self) -> RangedIsize<MIN, MAX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const MIN: isize, const MAX: isize> Debug for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Display for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> From<RangedIsize<MIN, MAX>> for OptionRangedIsize<MIN, MAX>

fn from(value: RangedIsize<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: isize, const MAX: isize> From<RangedIsize<MIN, MAX>> for isize

fn from(value: RangedIsize<MIN, MAX>) -> Self

Converts to this type from the input type.

impl<const MIN: isize, const MAX: isize> FromStr for RangedIsize<MIN, MAX>

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const MIN: isize, const MAX: isize> Hash for RangedIsize<MIN, MAX>

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<const MIN: isize, const MAX: isize> LowerExp for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> LowerHex for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Octal for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Ord for RangedIsize<MIN, MAX>

fn cmp(&self, other: &RangedIsize<MIN, MAX>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<const MIN_A: isize, const MAX_A: isize, const MIN_B: isize, const MAX_B: isize> PartialEq<RangedIsize<MIN_B, MAX_B>> for RangedIsize<MIN_A, MAX_A>

fn eq(&self, other: &RangedIsize<MIN_B, MAX_B>) -> 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<const MIN_A: isize, const MAX_A: isize, const MIN_B: isize, const MAX_B: isize> PartialOrd<RangedIsize<MIN_B, MAX_B>> for RangedIsize<MIN_A, MAX_A>

fn partial_cmp(&self, other: &RangedIsize<MIN_B, MAX_B>) -> 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<const MIN: isize, const MAX: isize> SmartDisplay for RangedIsize<MIN, MAX>

type Metadata = <isize as SmartDisplay>::Metadata

User-provided metadata type.

fn metadata(&self, f: FormatterOptions) -> Metadata<'_, Self>

Compute any information needed to format the value. This must, at a minimum, determine the width of the value before any padding is added by the formatter.

fn fmt_with_metadata( &self, f: &mut Formatter<'_>, metadata: Metadata<'_, Self>, ) -> Result

Format the value using the given formatter and metadata. The formatted output should have the width indicated by the metadata. This is before any padding is added by the formatter.

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

Format the value using the given formatter. This is the same as Display::fmt.

impl<const MIN: isize, const MAX: isize> TryFrom<isize> for RangedIsize<MIN, MAX>

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<const MIN: isize, const MAX: isize> UpperExp for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> UpperHex for RangedIsize<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: isize, const MAX: isize> Copy for RangedIsize<MIN, MAX>

impl<const MIN: isize, const MAX: isize> Eq for RangedIsize<MIN, MAX>