Struct RangedU128

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

A u128 that is known to be in the range MIN..=MAX.

Implementations

impl RangedU128<0, 0>

pub const fn exact<const VALUE: u128>() -> RangedU128<VALUE, VALUE>

impl<const MIN: u128, const MAX: u128> RangedU128<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: u128) -> Self

Creates a ranged integer without checking the value.

Safety

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

pub const fn get(self) -> u128

Returns the value as a primitive type.

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

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

pub const fn new_static<const VALUE: u128>() -> 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: u128) -> Self

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

pub const fn expand<const NEW_MIN: u128, const NEW_MAX: u128>( self, ) -> RangedU128<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: u128, const NEW_MAX: u128>( self, ) -> Option<RangedU128<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!(RangedU128::<5, 10>::from_str_radix("A", 16), Ok(RangedU128::new_static::<10>()));

pub const fn checked_add(self, rhs: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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 rem<const RHS_VALUE: u128>( self, rhs: RangedU128<RHS_VALUE, RHS_VALUE>, ) -> RangedU128<0, RHS_VALUE>

Remainder. Computes self % rhs, statically guaranteeing that the returned value is in range.

pub const fn checked_rem(self, rhs: u128) -> 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: u128) -> 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: u128) -> 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: u128) -> 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_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: u128) -> Self

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

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

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

pub const fn saturating_mul(self, rhs: u128) -> 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: u128) -> Self

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

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

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

Trait Implementations

impl<const MIN: u128, const MAX: u128> Arbitrary for RangedU128<MIN, MAX>

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl<const MIN: u128, const MAX: u128> AsRef<u128> for RangedU128<MIN, MAX>

fn as_ref(&self) -> &u128

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

impl<const MIN: u128, const MAX: u128> Binary for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> Borrow<u128> for RangedU128<MIN, MAX>

fn borrow(&self) -> &u128

Immutably borrows from an owned value.

impl<const MIN: u128, const MAX: u128> Clone for RangedU128<MIN, MAX>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const MIN: u128, const MAX: u128> Debug for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<'de, const MIN: u128, const MAX: u128> Deserialize<'de> for RangedU128<MIN, MAX>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

#[doc(hidden)] fn deserialize_in_place<D>( deserializer: D, place: &mut Self, ) -> Result<(), <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserializes a value into self from the given Deserializer.

impl<const MIN: u128, const MAX: u128> Display for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> Distribution<RangedU128<MIN, MAX>> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> RangedU128<MIN, MAX>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<const MIN: u128, const MAX: u128> Eq for RangedU128<MIN, MAX>

#[doc(hidden)] fn assert_receiver_is_total_eq(&self)

impl<const MIN: u128, const MAX: u128> From<RangedU128<MIN, MAX>> for OptionRangedU128<MIN, MAX>

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

Converts to this type from the input type.

impl<const MIN: u128, const MAX: u128> From<RangedU128<MIN, MAX>> for u128

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

Converts to this type from the input type.

impl<const MIN: u128, const MAX: u128> FromStr for RangedU128<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: u128, const MAX: u128> Hash for RangedU128<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: u128, const MAX: u128> LowerExp for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> LowerHex for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> Octal for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> Ord for RangedU128<MIN, MAX>

fn cmp(&self, other: &RangedU128<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,

Restrict a value to a certain interval.

impl<const MIN_A: u128, const MAX_A: u128, const MIN_B: u128, const MAX_B: u128> PartialEq<RangedU128<MIN_B, MAX_B>> for RangedU128<MIN_A, MAX_A>

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

fn partial_cmp(&self, other: &RangedU128<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: u128, const MAX: u128> Serialize for RangedU128<MIN, MAX>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const MIN: u128, const MAX: u128> SmartDisplay for RangedU128<MIN, MAX>

type Metadata = <u128 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: u128, const MAX: u128> TryFrom<u128> for RangedU128<MIN, MAX>

type Error = TryFromIntError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const MIN: u128, const MAX: u128> UpperExp for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> UpperHex for RangedU128<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: u128, const MAX: u128> Copy for RangedU128<MIN, MAX>