`#[repr(transparent)]pub struct RangedI32<const MIN: i32, const MAX: i32>(pub(crate) Unsafe<i32>);`

## Expand description

An `i32`

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

.

## Tuple Fields§

§`0: Unsafe<i32>`

## Implementations§

source§### impl<const MIN: i32, const MAX: i32> RangedI32<MIN, MAX>

### impl<const MIN: i32, const MAX: i32> RangedI32<MIN, MAX>

source#### pub const unsafe fn new_unchecked(value: i32) -> Self

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

Creates a ranged integer without checking the value.

##### §Safety

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

.

#### pub(crate) const fn get_ref(&self) -> &i32

source#### pub const fn new(value: i32) -> Option<Self>

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

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

.

source#### pub const fn new_static<const VALUE: i32>() -> Self

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

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

source#### pub const fn new_saturating(value: i32) -> Self

#### pub const fn new_saturating(value: i32) -> Self

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

source#### pub const fn expand<const NEW_MIN: i32, const NEW_MAX: i32>(
self,
) -> RangedI32<NEW_MIN, NEW_MAX>

#### pub const fn expand<const NEW_MIN: i32, const NEW_MAX: i32>( self, ) -> RangedI32<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.

source#### pub const fn narrow<const NEW_MIN: i32, const NEW_MAX: i32>(
self,
) -> Option<RangedI32<NEW_MIN, NEW_MAX>>

#### pub const fn narrow<const NEW_MIN: i32, const NEW_MAX: i32>( self, ) -> Option<RangedI32<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.

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

#### 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!(RangedI32::<5, 10>::from_str_radix("A", 16), Ok(RangedI32::new_static::<10>()));`

source#### pub const fn checked_add(self, rhs: i32) -> Option<Self>

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

Checked integer addition. Computes `self + rhs`

, returning `None`

if the resulting
value is out of range.

source#### pub const unsafe fn unchecked_add(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_add(self, rhs: i32) -> 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`

.

source#### pub const fn checked_sub(self, rhs: i32) -> Option<Self>

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

Checked integer addition. Computes `self - rhs`

, returning `None`

if the resulting
value is out of range.

source#### pub const unsafe fn unchecked_sub(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_sub(self, rhs: i32) -> 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`

.

source#### pub const fn checked_mul(self, rhs: i32) -> Option<Self>

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

Checked integer addition. Computes `self * rhs`

, returning `None`

if the resulting
value is out of range.

source#### pub const unsafe fn unchecked_mul(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_mul(self, rhs: i32) -> 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`

.

source#### pub const fn checked_div(self, rhs: i32) -> Option<Self>

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

Checked integer addition. Computes `self / rhs`

, returning `None`

if `rhs == 0`

or
if the resulting value is out of range.

source#### pub const unsafe fn unchecked_div(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_div(self, rhs: i32) -> 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`

.

source#### pub const fn checked_div_euclid(self, rhs: i32) -> Option<Self>

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

Checked Euclidean division. Computes `self.div_euclid(rhs)`

, returning `None`

if
`rhs == 0`

or if the resulting value is out of range.

source#### pub const unsafe fn unchecked_div_euclid(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_div_euclid(self, rhs: i32) -> 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`

.

source#### pub const fn checked_rem(self, rhs: i32) -> Option<Self>

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

Checked integer remainder. Computes `self % rhs`

, returning `None`

if `rhs == 0`

or
if the resulting value is out of range.

source#### pub const unsafe fn unchecked_rem(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_rem(self, rhs: i32) -> 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`

.

source#### pub const fn checked_rem_euclid(self, rhs: i32) -> Option<Self>

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

Checked Euclidean remainder. Computes `self.rem_euclid(rhs)`

, returning `None`

if
`rhs == 0`

or if the resulting value is out of range.

source#### pub const unsafe fn unchecked_rem_euclid(self, rhs: i32) -> Self

#### pub const unsafe fn unchecked_rem_euclid(self, rhs: i32) -> 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`

.

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

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

Checked negation. Computes `-self`

, returning `None`

if the resulting value is out
of range.

source#### pub const unsafe fn unchecked_neg(self) -> Self

#### 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`

.

source#### pub const fn neg(self) -> Self

#### pub const fn neg(self) -> Self

Negation. Computes `self.neg()`

, **failing to compile** if the result is not
guaranteed to be in range.

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

#### 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.

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

#### 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`

.

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

#### 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.

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

#### 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`

.

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

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

Checked absolute value. Computes `self.abs()`

, returning `None`

if the resulting
value is out of range.

source#### pub const unsafe fn unchecked_abs(self) -> Self

#### 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`

.

source#### pub const fn abs(self) -> Self

#### pub const fn abs(self) -> Self

Absolute value. Computes `self.abs()`

, **failing to compile** if the result is not
guaranteed to be in range.

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

#### 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.

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

#### 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`

.

source#### pub const fn saturating_add(self, rhs: i32) -> Self

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

Saturating integer addition. Computes `self + rhs`

, saturating at the numeric
bounds.

source#### pub const fn saturating_sub(self, rhs: i32) -> Self

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

Saturating integer subtraction. Computes `self - rhs`

, saturating at the numeric
bounds.

source#### pub const fn saturating_neg(self) -> Self

#### pub const fn saturating_neg(self) -> Self

Saturating integer negation. Computes `self - rhs`

, saturating at the numeric
bounds.

source#### pub const fn saturating_abs(self) -> Self

#### pub const fn saturating_abs(self) -> Self

Saturating absolute value. Computes `self.abs()`

, saturating at the numeric bounds.

source#### pub const fn saturating_mul(self, rhs: i32) -> Self

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

Saturating integer multiplication. Computes `self * rhs`

, saturating at the numeric
bounds.

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

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

Saturating integer exponentiation. Computes `self.pow(exp)`

, saturating at the
numeric bounds.

source#### pub(crate) const fn rem_euclid_unsigned(rhs: i32, range_len: u32) -> u32

#### pub(crate) const fn rem_euclid_unsigned(rhs: i32, range_len: u32) -> u32

Compute the `rem_euclid`

of this type with its unsigned type equivalent

source#### pub const fn wrapping_add(self, rhs: i32) -> Self

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

Wrapping integer addition. Computes `self + rhs`

, wrapping around the numeric
bounds.

source#### pub const fn wrapping_sub(self, rhs: i32) -> Self

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

Wrapping integer subtraction. Computes `self - rhs`

, wrapping around the numeric
bounds.

## Trait Implementations§

source§### impl<'de, const MIN: i32, const MAX: i32> Deserialize<'de> for RangedI32<MIN, MAX>

### impl<'de, const MIN: i32, const MAX: i32> Deserialize<'de> for RangedI32<MIN, MAX>

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

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

source§### impl<const MIN: i32, const MAX: i32> Ord for RangedI32<MIN, MAX>

### impl<const MIN: i32, const MAX: i32> Ord for RangedI32<MIN, MAX>

1.21.0 · source§#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

source§### impl<const MIN_A: i32, const MAX_A: i32, const MIN_B: i32, const MAX_B: i32> PartialEq<RangedI32<MIN_B, MAX_B>> for RangedI32<MIN_A, MAX_A>

### impl<const MIN_A: i32, const MAX_A: i32, const MIN_B: i32, const MAX_B: i32> PartialEq<RangedI32<MIN_B, MAX_B>> for RangedI32<MIN_A, MAX_A>

source§### impl<const MIN_A: i32, const MAX_A: i32, const MIN_B: i32, const MAX_B: i32> PartialOrd<RangedI32<MIN_B, MAX_B>> for RangedI32<MIN_A, MAX_A>

### impl<const MIN_A: i32, const MAX_A: i32, const MIN_B: i32, const MAX_B: i32> PartialOrd<RangedI32<MIN_B, MAX_B>> for RangedI32<MIN_A, MAX_A>

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read more