Struct devela::num::NonRangeIsize

#[repr(C)]
pub struct NonRangeIsize<const RMIN: isize, const RMAX: isize>(/* private fields */);

Available on crate feature num only.

A signed integer that is known to be excluded from some inclusive range.

It has an optimized memory layout, so that Option<NonRangeIsize> is the same size as NonRangeIsize.

Examples

use devela::num::NonRangeIsize;

assert![NonRangeIsize::<5, 25>::new(5).is_none()];
assert![NonRangeIsize::<5, 25>::new(25).is_none()];
assert![NonRangeIsize::<5, 25>::new(4).unwrap().get() == 4];
assert![NonRangeIsize::<5, 25>::new(26).unwrap().get() == 26];

// Self::INVALID_VALUES + Self::VALID_VALUES == usize::MAX + 1.
assert![NonRangeIsize::<5, 25>::VALID_VALUES == usize::MAX - 21 + 1];
assert![NonRangeIsize::<5, 25>::INVALID_VALUES == 21];

Implementations

impl<const RMIN: isize, const RMAX: isize> NonRangeIsize<RMIN, RMAX>

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

Returns a NonRangeIsize with the given value, only if it’s not between RMIN and RMAX.

Returns None if value is between RMIN and RMAX, inclusive, or if RMIN > RMAX.

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

Available on crate feature unsafe_num only.

Returns a NonRangeIsize if the given value is not between RMIN and RMAX.

Panics

Panics in debug if the given value is between RMIN and RMAX, inclusive, or if RMIN > RMAX.

Safety

The given value must never be between RMIN and RMAX, inclusive.

pub const fn get(&self) -> isize

Returns the value as a primitive type.

pub const VALID_VALUES: usize = _

Returns the number of valid values outside the range from RMIN to RMAX, inclusive, as an unsigned integer with equal bit size.

Notice

A range where RMAX == RMIN will result in VALID_VALUES == usize::MAX, as expected.

A range from isize::MIN to isize::MAX will result in VALID_VALUES == 0, also as expected. Just be aware that in this case INVALID_VALUES will also be == 0 instead of usize::MAX + 1.

pub const INVALID_VALUES: usize = _

Returns the number of invalid values in the range from RMIN to RMAX, inclusive, as an unsigned integer with equal bit size.

Notice

A range where RMAX == RMIN will result in INVALID_VALUES == 1, as expected.

A range from isize::MIN to isize::MAX will result in INVALID_VALUES == 0 instead of usize::MAX + 1. This is because the maximum number of representable values for a given bit-size can’t be represented using the same number of bits. In this case VALID_VALUES will also be == 0.

This doesn’t matter as much because a NonRangeIsize with the largest range of invalid values can’t ever be constructed.

Remember that INVALID_VALUES + VALID_VALUES == usize::MAX + 1, which would wrap to 0.

Trait Implementations

impl<const RMIN: isize, const RMAX: isize> Binary for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> BitSize<8> for NonRangeIsize<RMIN, RMAX>

Available on crate feature mem only.

const BIT_SIZE: usize = _

The bit size of this type (only the relevant data part, without padding).

const MIN_BYTE_SIZE: usize = _

The rounded up byte size for this type.

fn bit_size(&self) -> usize

Returns the bit size of this type (only the relevant data part, without padding).

fn min_byte_size(&self) -> usize

Returns the rounded up byte size for this type.

impl<const RMIN: isize, const RMAX: isize> Clone for NonRangeIsize<RMIN, RMAX>

fn clone(&self) -> NonRangeIsize<RMIN, RMAX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const RMIN: isize, const RMAX: isize> Debug for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> Display for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> From<NonRangeIsize<RMIN, RMAX>> for isize

fn from(value: NonRangeIsize<RMIN, RMAX>) -> isize

Converts to this type from the input type.

impl<const RMIN: isize, const RMAX: isize> FromStr for NonRangeIsize<RMIN, RMAX>

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 RMIN: isize, const RMAX: isize> Hash for NonRangeIsize<RMIN, RMAX>

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 RMIN: isize, const RMAX: isize> LowerHex for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> Num for NonRangeIsize<RMIN, RMAX>

type Inner = isize

The internal representation of this numeric type.

type Out = NonRangeIsize<RMIN, RMAX>

The output type for operations.

type Rhs = NonRangeIsize<RMIN, RMAX>

The right hand side type for operations.

fn num_into(self) -> Self::Inner

Returns the inner self representation.

fn num_from(from: Self::Inner) -> Result<Self>

Returns Self if given a valid value.

fn num_from_ref(from: &Self::Inner) -> Result<Self>

Returns Self if given a valid &value.

fn num_set(&mut self, value: Self::Inner) -> Result<()>

Sets self to the given valid value.

fn num_set_ref(&mut self, value: &Self::Inner) -> Result<()>

Sets self to the given valid &value.

fn num_is_zero(&self) -> Result<bool>

Returns true if self is zero.

fn num_is_one(&self) -> Result<bool>

Returns true if self is one.

fn num_get_zero() -> Result<Self>

Returns the number zero.

fn num_get_one() -> Result<Self>

Returns the number one.

fn num_set_zero(&mut self) -> Result<()>

Sets self to 0.

fn num_set_one(&mut self) -> Result<()>

Sets the number to one.

fn num_add(self, other: Self) -> Result<Self::Out>

Computes self + other.

fn num_add_ref(self, other: &Self) -> Result<Self::Out>

Computes self + &other.

fn num_ref_add(&self, other: Self) -> Result<Self::Out>

Computes &self + other.

fn num_ref_add_ref(&self, other: &Self) -> Result<Self::Out>

Computes &self + &other.

fn num_mul(self, other: Self) -> Result<Self::Out>

Computes self * other.

fn num_mul_ref(self, other: &Self) -> Result<Self::Out>

Computes self * &other.

fn num_ref_mul(&self, other: Self) -> Result<Self::Out>

Computes &self * other.

fn num_ref_mul_ref(&self, other: &Self) -> Result<Self::Out>

Computes &self * &other.

fn num_sub(self, other: Self) -> Result<Self::Out>

Computes self - other.

fn num_sub_ref(self, other: &Self) -> Result<Self::Out>

Computes self - &other.

fn num_ref_sub(&self, other: Self) -> Result<Self::Out>

Computes &self - other.

fn num_ref_sub_ref(&self, other: &Self) -> Result<Self::Out>

Computes &self - &other.

fn num_div(self, other: Self) -> Result<Self::Out>

Computes self / other.

fn num_div_ref(self, other: &Self) -> Result<Self::Out>

Computes self / &other.

fn num_ref_div(&self, other: Self) -> Result<Self::Out>

Computes &self / other.

fn num_ref_div_ref(&self, other: &Self) -> Result<Self::Out>

Computes &self / &other.

fn num_rem(self, other: Self) -> Result<Self::Out>

Computes self % other.

fn num_rem_ref(self, other: &Self) -> Result<Self::Out>

Computes self % &other.

fn num_ref_rem(&self, other: Self) -> Result<Self::Out>

Computes &self % other.

fn num_ref_rem_ref(&self, other: &Self) -> Result<Self::Out>

Computes &self % &other.

fn num_neg(self) -> Result<Self::Out>

Computes - self.

fn num_ref_neg(&self) -> Result<Self::Out>

Computes - &self.

fn num_abs(self) -> Result<Self::Out>

Computes the absolute value of self.

fn num_ref_abs(&self) -> Result<Self::Out>

Computes the absolute value of &self.

impl<const RMIN: isize, const RMAX: isize> Octal for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> Ord for NonRangeIsize<RMIN, RMAX>

fn cmp(&self, other: &NonRangeIsize<RMIN, RMAX>) -> 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 RMIN: isize, const RMAX: isize> PartialEq for NonRangeIsize<RMIN, RMAX>

fn eq(&self, other: &NonRangeIsize<RMIN, RMAX>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const RMIN: isize, const RMAX: isize> PartialOrd for NonRangeIsize<RMIN, RMAX>

fn partial_cmp(&self, other: &NonRangeIsize<RMIN, RMAX>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<const RMIN: isize, const RMAX: isize> TryFrom<isize> for NonRangeIsize<RMIN, RMAX>

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 RMIN: isize, const RMAX: isize> UpperHex for NonRangeIsize<RMIN, RMAX>

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

Formats the value using the given formatter.

impl<const RMIN: isize, const RMAX: isize> Copy for NonRangeIsize<RMIN, RMAX>

impl<const RMIN: isize, const RMAX: isize> Eq for NonRangeIsize<RMIN, RMAX>

impl<const RMIN: isize, const RMAX: isize> IntBufAble for NonRangeIsize<RMIN, RMAX>

Available on crate features unsafe_text and text only.

impl<const RMIN: isize, const RMAX: isize> StructuralEq for NonRangeIsize<RMIN, RMAX>

impl<const RMIN: isize, const RMAX: isize> StructuralPartialEq for NonRangeIsize<RMIN, RMAX>