| #![cfg_attr(docs_rs, feature(doc_auto_cfg))] |
| #![cfg_attr(not(feature = "std"), no_std)] |
| #![deny( |
| anonymous_parameters, |
| clippy::all, |
| clippy::missing_safety_doc, |
| clippy::missing_safety_doc, |
| clippy::undocumented_unsafe_blocks, |
| illegal_floating_point_literal_pattern, |
| late_bound_lifetime_arguments, |
| patterns_in_fns_without_body, |
| rust_2018_idioms, |
| trivial_casts, |
| trivial_numeric_casts, |
| unreachable_pub, |
| unsafe_op_in_unsafe_fn, |
| unused_extern_crates |
| )] |
| #![warn( |
| clippy::dbg_macro, |
| clippy::decimal_literal_representation, |
| clippy::get_unwrap, |
| clippy::nursery, |
| clippy::pedantic, |
| clippy::todo, |
| clippy::unimplemented, |
| clippy::unwrap_used, |
| clippy::use_debug, |
| missing_copy_implementations, |
| missing_debug_implementations, |
| unused_qualifications, |
| variant_size_differences |
| )] |
| #![allow( |
| path_statements, // used for static assertions |
| clippy::inline_always, |
| clippy::missing_errors_doc, |
| clippy::must_use_candidate, |
| clippy::redundant_pub_crate, |
| )] |
| #![doc(test(attr(deny(warnings))))] |
| |
| #[cfg(test)] |
| mod tests; |
| mod traits; |
| mod unsafe_wrapper; |
| |
| #[cfg(feature = "alloc")] |
| #[allow(unused_extern_crates)] |
| extern crate alloc; |
| |
| use core::borrow::Borrow; |
| use core::cmp::Ordering; |
| use core::fmt; |
| use core::num::IntErrorKind; |
| use core::str::FromStr; |
| #[cfg(feature = "std")] |
| use std::error::Error; |
| |
| #[cfg(feature = "powerfmt")] |
| use powerfmt::smart_display; |
| |
| use crate::unsafe_wrapper::Unsafe; |
| |
| #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
| pub struct TryFromIntError; |
| |
| impl fmt::Display for TryFromIntError { |
| #[inline] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.write_str("out of range integral type conversion attempted") |
| } |
| } |
| #[cfg(feature = "std")] |
| impl Error for TryFromIntError {} |
| |
| #[derive(Debug, Clone, PartialEq, Eq)] |
| pub struct ParseIntError { |
| kind: IntErrorKind, |
| } |
| |
| impl ParseIntError { |
| /// Outputs the detailed cause of parsing an integer failing. |
| // This function is not const because the counterpart of stdlib isn't |
| #[allow(clippy::missing_const_for_fn)] |
| #[inline(always)] |
| pub fn kind(&self) -> &IntErrorKind { |
| &self.kind |
| } |
| } |
| |
| impl fmt::Display for ParseIntError { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| match self.kind { |
| IntErrorKind::Empty => "cannot parse integer from empty string", |
| IntErrorKind::InvalidDigit => "invalid digit found in string", |
| IntErrorKind::PosOverflow => "number too large to fit in target type", |
| IntErrorKind::NegOverflow => "number too small to fit in target type", |
| IntErrorKind::Zero => "number would be zero for non-zero type", |
| _ => "Unknown Int error kind", |
| } |
| .fmt(f) |
| } |
| } |
| |
| #[cfg(feature = "std")] |
| impl Error for ParseIntError {} |
| |
| macro_rules! const_try_opt { |
| ($e:expr) => { |
| match $e { |
| Some(value) => value, |
| None => return None, |
| } |
| }; |
| } |
| |
| macro_rules! if_signed { |
| (true $($x:tt)*) => { $($x)*}; |
| (false $($x:tt)*) => {}; |
| } |
| |
| macro_rules! if_unsigned { |
| (true $($x:tt)*) => {}; |
| (false $($x:tt)*) => { $($x)* }; |
| } |
| |
| macro_rules! article { |
| (true) => { |
| "An" |
| }; |
| (false) => { |
| "A" |
| }; |
| } |
| |
| macro_rules! unsafe_unwrap_unchecked { |
| ($e:expr) => {{ |
| let opt = $e; |
| debug_assert!(opt.is_some()); |
| match $e { |
| Some(value) => value, |
| None => core::hint::unreachable_unchecked(), |
| } |
| }}; |
| } |
| |
| /// Informs the optimizer that a condition is always true. If the condition is false, the behavior |
| /// is undefined. |
| /// |
| /// # Safety |
| /// |
| /// `b` must be `true`. |
| #[inline] |
| const unsafe fn assume(b: bool) { |
| debug_assert!(b); |
| if !b { |
| // Safety: The caller must ensure that `b` is true. |
| unsafe { core::hint::unreachable_unchecked() } |
| } |
| } |
| |
| macro_rules! impl_ranged { |
| ($( |
| $type:ident { |
| mod_name: $mod_name:ident |
| internal: $internal:ident |
| signed: $is_signed:ident |
| unsigned: $unsigned_type:ident |
| optional: $optional_type:ident |
| } |
| )*) => {$( |
| #[doc = concat!( |
| article!($is_signed), |
| " `", |
| stringify!($internal), |
| "` that is known to be in the range `MIN..=MAX`.", |
| )] |
| #[repr(transparent)] |
| #[derive(Clone, Copy, Eq, Ord, Hash)] |
| pub struct $type<const MIN: $internal, const MAX: $internal>( |
| Unsafe<$internal>, |
| ); |
| |
| #[doc = concat!( |
| "A `", |
| stringify!($type), |
| "` that is optional. Equivalent to [`Option<", |
| stringify!($type), |
| ">`] with niche value optimization.", |
| )] |
| /// |
| #[doc = concat!( |
| "If `MIN` is [`", |
| stringify!($internal), |
| "::MIN`] _and_ `MAX` is [`", |
| stringify!($internal) |
| ,"::MAX`] then compilation will fail. This is because there is no way to represent \ |
| the niche value.", |
| )] |
| /// |
| /// This type is useful when you need to store an optional ranged value in a struct, but |
| /// do not want the overhead of an `Option` type. This reduces the size of the struct |
| /// overall, and is particularly useful when you have a large number of optional fields. |
| /// Note that most operations must still be performed on the [`Option`] type, which is |
| #[doc = concat!("obtained with [`", stringify!($optional_type), "::get`].")] |
| #[repr(transparent)] |
| #[derive(Clone, Copy, Eq, Hash)] |
| pub struct $optional_type<const MIN: $internal, const MAX: $internal>( |
| $internal, |
| ); |
| |
| impl $type<0, 0> { |
| #[inline(always)] |
| pub const fn exact<const VALUE: $internal>() -> $type<VALUE, VALUE> { |
| // Safety: The value is the only one in range. |
| unsafe { $type::new_unchecked(VALUE) } |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> $type<MIN, MAX> { |
| /// The smallest value that can be represented by this type. |
| // Safety: `MIN` is in range by definition. |
| pub const MIN: Self = Self::new_static::<MIN>(); |
| |
| /// The largest value that can be represented by this type. |
| // Safety: `MAX` is in range by definition. |
| pub const MAX: Self = Self::new_static::<MAX>(); |
| |
| /// Creates a ranged integer without checking the value. |
| /// |
| /// # Safety |
| /// |
| /// The value must be within the range `MIN..=MAX`. |
| #[inline(always)] |
| pub const unsafe fn new_unchecked(value: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the value is in range. |
| unsafe { |
| $crate::assume(MIN <= value && value <= MAX); |
| Self(Unsafe::new(value)) |
| } |
| } |
| |
| /// Returns the value as a primitive type. |
| #[inline(always)] |
| pub const fn get(self) -> $internal { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: A stored value is always in range. |
| unsafe { $crate::assume(MIN <= *self.0.get() && *self.0.get() <= MAX) }; |
| *self.0.get() |
| } |
| |
| #[inline(always)] |
| pub(crate) const fn get_ref(&self) -> &$internal { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| let value = self.0.get(); |
| // Safety: A stored value is always in range. |
| unsafe { $crate::assume(MIN <= *value && *value <= MAX) }; |
| value |
| } |
| |
| /// Creates a ranged integer if the given value is in the range `MIN..=MAX`. |
| #[inline(always)] |
| pub const fn new(value: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| if value < MIN || value > MAX { |
| None |
| } else { |
| // Safety: The value is in range. |
| Some(unsafe { Self::new_unchecked(value) }) |
| } |
| } |
| |
| /// Creates a ranged integer with a statically known value. **Fails to compile** if the |
| /// value is not in range. |
| #[inline(always)] |
| pub const fn new_static<const VALUE: $internal>() -> Self { |
| <($type<MIN, VALUE>, $type<VALUE, MAX>) as $crate::traits::StaticIsValid>::ASSERT; |
| // Safety: The value is in range. |
| unsafe { Self::new_unchecked(VALUE) } |
| } |
| |
| /// Creates a ranged integer with the given value, saturating if it is out of range. |
| #[inline] |
| pub const fn new_saturating(value: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| if value < MIN { |
| Self::MIN |
| } else if value > MAX { |
| Self::MAX |
| } else { |
| // Safety: The value is in range. |
| unsafe { Self::new_unchecked(value) } |
| } |
| } |
| |
| /// 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 expand<const NEW_MIN: $internal, const NEW_MAX: $internal>( |
| self, |
| ) -> $type<NEW_MIN, NEW_MAX> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<NEW_MIN, NEW_MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| <($type<MIN, MAX>, $type<NEW_MIN, NEW_MAX>) as $crate::traits::ExpandIsValid> |
| ::ASSERT; |
| // Safety: The range is widened. |
| unsafe { $type::new_unchecked(self.get()) } |
| } |
| |
| /// 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 const fn narrow< |
| const NEW_MIN: $internal, |
| const NEW_MAX: $internal, |
| >(self) -> Option<$type<NEW_MIN, NEW_MAX>> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<NEW_MIN, NEW_MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| <($type<MIN, MAX>, $type<NEW_MIN, NEW_MAX>) as $crate::traits::NarrowIsValid> |
| ::ASSERT; |
| $type::<NEW_MIN, NEW_MAX>::new(self.get()) |
| } |
| |
| /// 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: |
| /// |
| /// ```rust |
| #[doc = concat!("# use deranged::", stringify!($type), ";")] |
| #[doc = concat!( |
| "assert_eq!(", |
| stringify!($type), |
| "::<5, 10>::from_str_radix(\"A\", 16), Ok(", |
| stringify!($type), |
| "::new_static::<10>()));", |
| )] |
| /// ``` |
| #[inline] |
| pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| match $internal::from_str_radix(src, radix) { |
| Ok(value) if value > MAX => { |
| Err(ParseIntError { kind: IntErrorKind::PosOverflow }) |
| } |
| Ok(value) if value < MIN => { |
| Err(ParseIntError { kind: IntErrorKind::NegOverflow }) |
| } |
| // Safety: If the value was out of range, it would have been caught in a |
| // previous arm. |
| Ok(value) => Ok(unsafe { Self::new_unchecked(value) }), |
| Err(e) => Err(ParseIntError { kind: e.kind().clone() }), |
| } |
| } |
| |
| /// Checked integer addition. Computes `self + rhs`, returning `None` if the resulting |
| /// value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_add(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_add(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_add(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_add(rhs))) |
| } |
| } |
| |
| /// Checked integer addition. Computes `self - rhs`, returning `None` if the resulting |
| /// value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_sub(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_sub(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_sub(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_sub(rhs))) |
| } |
| } |
| |
| /// Checked integer addition. Computes `self * rhs`, returning `None` if the resulting |
| /// value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_mul(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_mul(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_mul(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_mul(rhs))) |
| } |
| } |
| |
| /// Checked integer addition. Computes `self / rhs`, returning `None` if `rhs == 0` or |
| /// if the resulting value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_div(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_div(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_div(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range and that `rhs` is not |
| // zero. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_div(rhs))) |
| } |
| } |
| |
| /// Checked Euclidean division. Computes `self.div_euclid(rhs)`, returning `None` if |
| /// `rhs == 0` or if the resulting value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_div_euclid(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_div_euclid(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_div_euclid(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range and that `rhs` is not |
| // zero. |
| unsafe { |
| Self::new_unchecked( |
| unsafe_unwrap_unchecked!(self.get().checked_div_euclid(rhs)) |
| ) |
| } |
| } |
| |
| if_unsigned!($is_signed |
| /// Remainder. Computes `self % rhs`, statically guaranteeing that the returned value |
| /// is in range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn rem<const RHS_VALUE: $internal>( |
| self, |
| rhs: $type<RHS_VALUE, RHS_VALUE>, |
| ) -> $type<0, RHS_VALUE> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The result is guaranteed to be in range due to the nature of remainder on |
| // unsigned integers. |
| unsafe { $type::new_unchecked(self.get() % rhs.get()) } |
| }); |
| |
| /// Checked integer remainder. Computes `self % rhs`, returning `None` if `rhs == 0` or |
| /// if the resulting value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_rem(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_rem(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_rem(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range and that `rhs` is not |
| // zero. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_rem(rhs))) |
| } |
| } |
| |
| /// Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`, returning `None` if |
| /// `rhs == 0` or if the resulting value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_rem_euclid(self, rhs: $internal) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_rem_euclid(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_rem_euclid(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range and that `rhs` is not |
| // zero. |
| unsafe { |
| Self::new_unchecked( |
| unsafe_unwrap_unchecked!(self.get().checked_rem_euclid(rhs)) |
| ) |
| } |
| } |
| |
| /// Checked negation. Computes `-self`, returning `None` if the resulting value is out |
| /// of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_neg(self) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_neg())) |
| } |
| |
| /// Unchecked negation. Computes `-self`, assuming that `-self` is in range. |
| /// |
| /// # Safety |
| /// |
| /// The result of `-self` must be in the range `MIN..=MAX`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_neg(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_neg())) } |
| } |
| |
| /// Negation. Computes `self.neg()`, **failing to compile** if the result is not |
| /// guaranteed to be in range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const fn neg(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| <Self as $crate::traits::NegIsSafe>::ASSERT; |
| // Safety: The compiler asserts that the result is in range. |
| unsafe { self.unchecked_neg() } |
| } |
| |
| /// Checked shift left. Computes `self << rhs`, returning `None` if the resulting value |
| /// is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_shl(self, rhs: u32) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_shl(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_shl(self, rhs: u32) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_shl(rhs))) |
| } |
| } |
| |
| /// Checked shift right. Computes `self >> rhs`, returning `None` if |
| /// the resulting value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_shr(self, rhs: u32) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_shr(rhs))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_shr(self, rhs: u32) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_shr(rhs))) |
| } |
| } |
| |
| if_signed!($is_signed |
| /// Checked absolute value. Computes `self.abs()`, returning `None` if the resulting |
| /// value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_abs(self) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_abs())) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_abs(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_abs())) } |
| } |
| |
| /// Absolute value. Computes `self.abs()`, **failing to compile** if the result is not |
| /// guaranteed to be in range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const fn abs(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| <Self as $crate::traits::AbsIsSafe>::ASSERT; |
| // Safety: The compiler asserts that the result is in range. |
| unsafe { self.unchecked_abs() } |
| }); |
| |
| /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if the resulting |
| /// value is out of range. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn checked_pow(self, exp: u32) -> Option<Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(const_try_opt!(self.get().checked_pow(exp))) |
| } |
| |
| /// 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`. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline(always)] |
| pub const unsafe fn unchecked_pow(self, exp: u32) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the result is in range. |
| unsafe { |
| Self::new_unchecked(unsafe_unwrap_unchecked!(self.get().checked_pow(exp))) |
| } |
| } |
| |
| /// Saturating integer addition. Computes `self + rhs`, saturating at the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_add(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_add(rhs)) |
| } |
| |
| /// Saturating integer subtraction. Computes `self - rhs`, saturating at the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_sub(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_sub(rhs)) |
| } |
| |
| if_signed!($is_signed |
| /// Saturating integer negation. Computes `self - rhs`, saturating at the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_neg(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_neg()) |
| }); |
| |
| if_signed!($is_signed |
| /// Saturating absolute value. Computes `self.abs()`, saturating at the numeric bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_abs(self) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_abs()) |
| }); |
| |
| /// Saturating integer multiplication. Computes `self * rhs`, saturating at the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_mul(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_mul(rhs)) |
| } |
| |
| /// Saturating integer exponentiation. Computes `self.pow(exp)`, saturating at the |
| /// numeric bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| pub const fn saturating_pow(self, exp: u32) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new_saturating(self.get().saturating_pow(exp)) |
| } |
| |
| /// Compute the `rem_euclid` of this type with its unsigned type equivalent |
| // Not public because it doesn't match stdlib's "method_unsigned implemented only for signed type" tradition. |
| // Also because this isn't implemented for normal types in std. |
| // TODO maybe make public anyway? It is useful. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| #[allow(trivial_numeric_casts)] // needed since some casts have to send unsigned -> unsigned to handle signed -> unsigned |
| const fn rem_euclid_unsigned( |
| rhs: $internal, |
| range_len: $unsigned_type |
| ) -> $unsigned_type { |
| #[allow(unused_comparisons)] |
| if rhs >= 0 { |
| (rhs as $unsigned_type) % range_len |
| } else { |
| // Let ux refer to an n bit unsigned and ix refer to an n bit signed integer. |
| // Can't write -ux or ux::abs() method. This gets around compilation error. |
| // `wrapping_sub` is to handle rhs = ix::MIN since ix::MIN = -ix::MAX-1 |
| let rhs_abs = ($internal::wrapping_sub(0, rhs)) as $unsigned_type; |
| // Largest multiple of range_len <= type::MAX is lowest if range_len * 2 > ux::MAX -> range_len >= ux::MAX / 2 + 1 |
| // Also = 0 in mod range_len arithmetic. |
| // Sub from this large number rhs_abs (same as sub -rhs = -(-rhs) = add rhs) to get rhs % range_len |
| // ix::MIN = -2^(n-1) so 0 <= rhs_abs <= 2^(n-1) |
| // ux::MAX / 2 + 1 = 2^(n-1) so this subtraction will always be a >= 0 after subtraction |
| // Thus converting rhs signed negative to equivalent positive value in mod range_len arithmetic |
| ((($unsigned_type::MAX / range_len) * range_len) - (rhs_abs)) % range_len |
| } |
| } |
| |
| /// Wrapping integer addition. Computes `self + rhs`, wrapping around the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| #[allow(trivial_numeric_casts)] // needed since some casts have to send unsigned -> unsigned to handle signed -> unsigned |
| pub const fn wrapping_add(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Forward to internal type's impl if same as type. |
| if MIN == $internal::MIN && MAX == $internal::MAX { |
| // Safety: std's wrapping methods match ranged arithmetic when the range is the internal datatype's range. |
| return unsafe { Self::new_unchecked(self.get().wrapping_add(rhs)) } |
| } |
| |
| let inner = self.get(); |
| |
| // Won't overflow because of std impl forwarding. |
| let range_len = MAX.abs_diff(MIN) + 1; |
| |
| // Calculate the offset with proper handling for negative rhs |
| let offset = Self::rem_euclid_unsigned(rhs, range_len); |
| |
| let greater_vals = MAX.abs_diff(inner); |
| // No wrap |
| if offset <= greater_vals { |
| // Safety: |
| // if inner >= 0 -> No overflow beyond range (offset <= greater_vals) |
| // if inner < 0: Same as >=0 with caveat: |
| // `(signed as unsigned).wrapping_add(unsigned) as signed` is the same as |
| // `signed::checked_add_unsigned(unsigned).unwrap()` or `wrapping_add_unsigned` |
| // (the difference doesn't matter since it won't overflow), |
| // but unsigned integers don't have either method so it won't compile that way. |
| unsafe { Self::new_unchecked( |
| ((inner as $unsigned_type).wrapping_add(offset)) as $internal |
| ) } |
| } |
| // Wrap |
| else { |
| // Safety: |
| // - offset < range_len by rem_euclid (MIN + ... safe) |
| // - offset > greater_vals from if statement (offset - (greater_vals + 1) safe) |
| // |
| // again using `(signed as unsigned).wrapping_add(unsigned) as signed` = `checked_add_unsigned` trick |
| unsafe { Self::new_unchecked( |
| ((MIN as $unsigned_type).wrapping_add( |
| offset - (greater_vals + 1) |
| )) as $internal |
| ) } |
| } |
| } |
| |
| /// Wrapping integer subtraction. Computes `self - rhs`, wrapping around the numeric |
| /// bounds. |
| #[must_use = "this returns the result of the operation, without modifying the original"] |
| #[inline] |
| #[allow(trivial_numeric_casts)] // needed since some casts have to send unsigned -> unsigned to handle signed -> unsigned |
| pub const fn wrapping_sub(self, rhs: $internal) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Forward to internal type's impl if same as type. |
| if MIN == $internal::MIN && MAX == $internal::MAX { |
| // Safety: std's wrapping methods match ranged arithmetic when the range is the internal datatype's range. |
| return unsafe { Self::new_unchecked(self.get().wrapping_sub(rhs)) } |
| } |
| |
| let inner = self.get(); |
| |
| // Won't overflow because of std impl forwarding. |
| let range_len = MAX.abs_diff(MIN) + 1; |
| |
| // Calculate the offset with proper handling for negative rhs |
| let offset = Self::rem_euclid_unsigned(rhs, range_len); |
| |
| let lesser_vals = MIN.abs_diff(inner); |
| // No wrap |
| if offset <= lesser_vals { |
| // Safety: |
| // if inner >= 0 -> No overflow beyond range (offset <= greater_vals) |
| // if inner < 0: Same as >=0 with caveat: |
| // `(signed as unsigned).wrapping_sub(unsigned) as signed` is the same as |
| // `signed::checked_sub_unsigned(unsigned).unwrap()` or `wrapping_sub_unsigned` |
| // (the difference doesn't matter since it won't overflow below 0), |
| // but unsigned integers don't have either method so it won't compile that way. |
| unsafe { Self::new_unchecked( |
| ((inner as $unsigned_type).wrapping_sub(offset)) as $internal |
| ) } |
| } |
| // Wrap |
| else { |
| // Safety: |
| // - offset < range_len by rem_euclid (MAX - ... safe) |
| // - offset > lesser_vals from if statement (offset - (lesser_vals + 1) safe) |
| // |
| // again using `(signed as unsigned).wrapping_sub(unsigned) as signed` = `checked_sub_unsigned` trick |
| unsafe { Self::new_unchecked( |
| ((MAX as $unsigned_type).wrapping_sub( |
| offset - (lesser_vals + 1) |
| )) as $internal |
| ) } |
| } |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> $optional_type<MIN, MAX> { |
| /// The value used as the niche. Must not be in the range `MIN..=MAX`. |
| const NICHE: $internal = match (MIN, MAX) { |
| ($internal::MIN, $internal::MAX) => panic!("type has no niche"), |
| ($internal::MIN, _) => $internal::MAX, |
| (_, _) => $internal::MIN, |
| }; |
| |
| /// An optional ranged value that is not present. |
| #[allow(non_upper_case_globals)] |
| pub const None: Self = Self(Self::NICHE); |
| |
| /// Creates an optional ranged value that is present. |
| #[allow(non_snake_case)] |
| #[inline(always)] |
| pub const fn Some(value: $type<MIN, MAX>) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Self(value.get()) |
| } |
| |
| /// Returns the value as the standard library's [`Option`] type. |
| #[inline(always)] |
| pub const fn get(self) -> Option<$type<MIN, MAX>> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| if self.0 == Self::NICHE { |
| None |
| } else { |
| // Safety: A stored value that is not the niche is always in range. |
| Some(unsafe { $type::new_unchecked(self.0) }) |
| } |
| } |
| |
| /// Creates an optional ranged integer without checking the value. |
| /// |
| /// # Safety |
| /// |
| /// The value must be within the range `MIN..=MAX`. As the value used for niche |
| /// value optimization is unspecified, the provided value must not be the niche |
| /// value. |
| #[inline(always)] |
| pub const unsafe fn some_unchecked(value: $internal) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The caller must ensure that the value is in range. |
| unsafe { $crate::assume(MIN <= value && value <= MAX) }; |
| Self(value) |
| } |
| |
| /// Obtain the inner value of the struct. This is useful for comparisons. |
| #[inline(always)] |
| pub(crate) const fn inner(self) -> $internal { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| self.0 |
| } |
| |
| #[inline(always)] |
| pub const fn get_primitive(self) -> Option<$internal> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Some(const_try_opt!(self.get()).get()) |
| } |
| |
| /// Returns `true` if the value is the niche value. |
| #[inline(always)] |
| pub const fn is_none(self) -> bool { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().is_none() |
| } |
| |
| /// Returns `true` if the value is not the niche value. |
| #[inline(always)] |
| pub const fn is_some(self) -> bool { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().is_some() |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::Debug for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::Debug for $optional_type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::Display for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| #[cfg(feature = "powerfmt")] |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > smart_display::SmartDisplay for $type<MIN, MAX> { |
| type Metadata = <$internal as smart_display::SmartDisplay>::Metadata; |
| |
| #[inline(always)] |
| fn metadata( |
| &self, |
| f: smart_display::FormatterOptions, |
| ) -> smart_display::Metadata<'_, Self> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get_ref().metadata(f).reuse() |
| } |
| |
| #[inline(always)] |
| fn fmt_with_metadata( |
| &self, |
| f: &mut fmt::Formatter<'_>, |
| metadata: smart_display::Metadata<'_, Self>, |
| ) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt_with_metadata(f, metadata.reuse()) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> Default for $optional_type<MIN, MAX> { |
| #[inline(always)] |
| fn default() -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Self::None |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> AsRef<$internal> for $type<MIN, MAX> { |
| #[inline(always)] |
| fn as_ref(&self) -> &$internal { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| &self.get_ref() |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> Borrow<$internal> for $type<MIN, MAX> { |
| #[inline(always)] |
| fn borrow(&self) -> &$internal { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| &self.get_ref() |
| } |
| } |
| |
| impl< |
| const MIN_A: $internal, |
| const MAX_A: $internal, |
| const MIN_B: $internal, |
| const MAX_B: $internal, |
| > PartialEq<$type<MIN_B, MAX_B>> for $type<MIN_A, MAX_A> { |
| #[inline(always)] |
| fn eq(&self, other: &$type<MIN_B, MAX_B>) -> bool { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<MIN_B, MAX_B> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get() == other.get() |
| } |
| } |
| |
| impl< |
| const MIN_A: $internal, |
| const MAX_A: $internal, |
| const MIN_B: $internal, |
| const MAX_B: $internal, |
| > PartialEq<$optional_type<MIN_B, MAX_B>> for $optional_type<MIN_A, MAX_A> { |
| #[inline(always)] |
| fn eq(&self, other: &$optional_type<MIN_B, MAX_B>) -> bool { |
| <$type<MIN_A, MAX_A> as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<MIN_B, MAX_B> as $crate::traits::RangeIsValid>::ASSERT; |
| self.inner() == other.inner() |
| } |
| } |
| |
| impl< |
| const MIN_A: $internal, |
| const MAX_A: $internal, |
| const MIN_B: $internal, |
| const MAX_B: $internal, |
| > PartialOrd<$type<MIN_B, MAX_B>> for $type<MIN_A, MAX_A> { |
| #[inline(always)] |
| fn partial_cmp(&self, other: &$type<MIN_B, MAX_B>) -> Option<Ordering> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<MIN_B, MAX_B> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().partial_cmp(&other.get()) |
| } |
| } |
| |
| impl< |
| const MIN_A: $internal, |
| const MAX_A: $internal, |
| const MIN_B: $internal, |
| const MAX_B: $internal, |
| > PartialOrd<$optional_type<MIN_B, MAX_B>> for $optional_type<MIN_A, MAX_A> { |
| #[inline] |
| fn partial_cmp(&self, other: &$optional_type<MIN_B, MAX_B>) -> Option<Ordering> { |
| <$type<MIN_A, MAX_A> as $crate::traits::RangeIsValid>::ASSERT; |
| <$type<MIN_B, MAX_B> as $crate::traits::RangeIsValid>::ASSERT; |
| if self.is_none() && other.is_none() { |
| Some(Ordering::Equal) |
| } else if self.is_none() { |
| Some(Ordering::Less) |
| } else if other.is_none() { |
| Some(Ordering::Greater) |
| } else { |
| self.inner().partial_cmp(&other.inner()) |
| } |
| } |
| } |
| |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > Ord for $optional_type<MIN, MAX> { |
| #[inline] |
| fn cmp(&self, other: &Self) -> Ordering { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| if self.is_none() && other.is_none() { |
| Ordering::Equal |
| } else if self.is_none() { |
| Ordering::Less |
| } else if other.is_none() { |
| Ordering::Greater |
| } else { |
| self.inner().cmp(&other.inner()) |
| } |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::Binary for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::LowerHex for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::UpperHex for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::LowerExp for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::UpperExp for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> fmt::Octal for $type<MIN, MAX> { |
| #[inline(always)] |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().fmt(f) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> From<$type<MIN, MAX>> for $internal { |
| #[inline(always)] |
| fn from(value: $type<MIN, MAX>) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| value.get() |
| } |
| } |
| |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > From<$type<MIN, MAX>> for $optional_type<MIN, MAX> { |
| #[inline(always)] |
| fn from(value: $type<MIN, MAX>) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Self::Some(value) |
| } |
| } |
| |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > From<Option<$type<MIN, MAX>>> for $optional_type<MIN, MAX> { |
| #[inline(always)] |
| fn from(value: Option<$type<MIN, MAX>>) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| match value { |
| Some(value) => Self::Some(value), |
| None => Self::None, |
| } |
| } |
| } |
| |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > From<$optional_type<MIN, MAX>> for Option<$type<MIN, MAX>> { |
| #[inline(always)] |
| fn from(value: $optional_type<MIN, MAX>) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| value.get() |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> TryFrom<$internal> for $type<MIN, MAX> { |
| type Error = TryFromIntError; |
| |
| #[inline] |
| fn try_from(value: $internal) -> Result<Self, Self::Error> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::new(value).ok_or(TryFromIntError) |
| } |
| } |
| |
| impl<const MIN: $internal, const MAX: $internal> FromStr for $type<MIN, MAX> { |
| type Err = ParseIntError; |
| |
| #[inline] |
| fn from_str(s: &str) -> Result<Self, Self::Err> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| let value = s.parse::<$internal>().map_err(|e| ParseIntError { |
| kind: e.kind().clone() |
| })?; |
| if value < MIN { |
| Err(ParseIntError { kind: IntErrorKind::NegOverflow }) |
| } else if value > MAX { |
| Err(ParseIntError { kind: IntErrorKind::PosOverflow }) |
| } else { |
| // Safety: The value was previously checked for validity. |
| Ok(unsafe { Self::new_unchecked(value) }) |
| } |
| } |
| } |
| |
| #[cfg(feature = "serde")] |
| impl<const MIN: $internal, const MAX: $internal> serde::Serialize for $type<MIN, MAX> { |
| #[inline(always)] |
| fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().serialize(serializer) |
| } |
| } |
| |
| #[cfg(feature = "serde")] |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > serde::Serialize for $optional_type<MIN, MAX> { |
| #[inline(always)] |
| fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| self.get().serialize(serializer) |
| } |
| } |
| |
| #[cfg(feature = "serde")] |
| impl< |
| 'de, |
| const MIN: $internal, |
| const MAX: $internal, |
| > serde::Deserialize<'de> for $type<MIN, MAX> { |
| #[inline] |
| fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| let internal = <$internal>::deserialize(deserializer)?; |
| Self::new(internal).ok_or_else(|| <D::Error as serde::de::Error>::invalid_value( |
| serde::de::Unexpected::Other("integer"), |
| #[cfg(feature = "std")] { |
| &format!("an integer in the range {}..={}", MIN, MAX).as_ref() |
| }, |
| #[cfg(not(feature = "std"))] { |
| &"an integer in the valid range" |
| } |
| )) |
| } |
| } |
| |
| #[cfg(feature = "serde")] |
| impl< |
| 'de, |
| const MIN: $internal, |
| const MAX: $internal, |
| > serde::Deserialize<'de> for $optional_type<MIN, MAX> { |
| #[inline] |
| fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Ok(Self::Some($type::<MIN, MAX>::deserialize(deserializer)?)) |
| } |
| } |
| |
| #[cfg(feature = "rand")] |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > rand::distributions::Distribution<$type<MIN, MAX>> for rand::distributions::Standard { |
| #[inline] |
| fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> $type<MIN, MAX> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| $type::new(rng.gen_range(MIN..=MAX)).expect("rand failed to generate a valid value") |
| } |
| } |
| |
| #[cfg(feature = "rand")] |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > rand::distributions::Distribution<$optional_type<MIN, MAX>> |
| for rand::distributions::Standard { |
| #[inline] |
| fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> $optional_type<MIN, MAX> { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| rng.gen::<Option<$type<MIN, MAX>>>().into() |
| } |
| } |
| |
| #[cfg(feature = "num")] |
| impl<const MIN: $internal, const MAX: $internal> num_traits::Bounded for $type<MIN, MAX> { |
| #[inline(always)] |
| fn min_value() -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::MIN |
| } |
| |
| #[inline(always)] |
| fn max_value() -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| Self::MAX |
| } |
| } |
| |
| #[cfg(feature = "quickcheck")] |
| impl<const MIN: $internal, const MAX: $internal> quickcheck::Arbitrary for $type<MIN, MAX> { |
| #[inline] |
| fn arbitrary(g: &mut quickcheck::Gen) -> Self { |
| <Self as $crate::traits::RangeIsValid>::ASSERT; |
| // Safety: The `rem_euclid` call and addition ensure that the value is in range. |
| unsafe { |
| Self::new_unchecked($internal::arbitrary(g).rem_euclid(MAX - MIN + 1) + MIN) |
| } |
| } |
| |
| #[inline] |
| fn shrink(&self) -> ::alloc::boxed::Box<dyn Iterator<Item = Self>> { |
| ::alloc::boxed::Box::new( |
| self.get() |
| .shrink() |
| .filter_map(Self::new) |
| ) |
| } |
| } |
| |
| #[cfg(feature = "quickcheck")] |
| impl< |
| const MIN: $internal, |
| const MAX: $internal, |
| > quickcheck::Arbitrary for $optional_type<MIN, MAX> { |
| #[inline] |
| fn arbitrary(g: &mut quickcheck::Gen) -> Self { |
| <$type<MIN, MAX> as $crate::traits::RangeIsValid>::ASSERT; |
| Option::<$type<MIN, MAX>>::arbitrary(g).into() |
| } |
| |
| #[inline] |
| fn shrink(&self) -> ::alloc::boxed::Box<dyn Iterator<Item = Self>> { |
| ::alloc::boxed::Box::new(self.get().shrink().map(Self::from)) |
| } |
| } |
| )*}; |
| } |
| |
| impl_ranged! { |
| RangedU8 { |
| mod_name: ranged_u8 |
| internal: u8 |
| signed: false |
| unsigned: u8 |
| optional: OptionRangedU8 |
| } |
| RangedU16 { |
| mod_name: ranged_u16 |
| internal: u16 |
| signed: false |
| unsigned: u16 |
| optional: OptionRangedU16 |
| } |
| RangedU32 { |
| mod_name: ranged_u32 |
| internal: u32 |
| signed: false |
| unsigned: u32 |
| optional: OptionRangedU32 |
| } |
| RangedU64 { |
| mod_name: ranged_u64 |
| internal: u64 |
| signed: false |
| unsigned: u64 |
| optional: OptionRangedU64 |
| } |
| RangedU128 { |
| mod_name: ranged_u128 |
| internal: u128 |
| signed: false |
| unsigned: u128 |
| optional: OptionRangedU128 |
| } |
| RangedUsize { |
| mod_name: ranged_usize |
| internal: usize |
| signed: false |
| unsigned: usize |
| optional: OptionRangedUsize |
| } |
| RangedI8 { |
| mod_name: ranged_i8 |
| internal: i8 |
| signed: true |
| unsigned: u8 |
| optional: OptionRangedI8 |
| } |
| RangedI16 { |
| mod_name: ranged_i16 |
| internal: i16 |
| signed: true |
| unsigned: u16 |
| optional: OptionRangedI16 |
| } |
| RangedI32 { |
| mod_name: ranged_i32 |
| internal: i32 |
| signed: true |
| unsigned: u32 |
| optional: OptionRangedI32 |
| } |
| RangedI64 { |
| mod_name: ranged_i64 |
| internal: i64 |
| signed: true |
| unsigned: u64 |
| optional: OptionRangedI64 |
| } |
| RangedI128 { |
| mod_name: ranged_i128 |
| internal: i128 |
| signed: true |
| unsigned: u128 |
| optional: OptionRangedI128 |
| } |
| RangedIsize { |
| mod_name: ranged_isize |
| internal: isize |
| signed: true |
| unsigned: usize |
| optional: OptionRangedIsize |
| } |
| } |
