Type Alias WholeSeconds

type WholeSeconds = RangedI32<{ _ }, { _ }>;

The type capable of storing the range of whole seconds that a UtcOffset can encompass.

Aliased Type

struct WholeSeconds(/* private fields */);

Implementations

impl RangedI32<0, 0>

pub const fn exact<const VALUE: i32>() -> RangedI32<VALUE, VALUE>

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

pub const MIN: RangedI32<MIN, MAX>

The smallest value that can be represented by this type.

pub const MAX: RangedI32<MIN, MAX>

The largest value that can be represented by this type.

pub const unsafe fn new_unchecked(value: i32) -> RangedI32<MIN, MAX>

Creates a ranged integer without checking the value.

Safety

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

pub const fn get(self) -> i32

Returns the value as a primitive type.

pub const fn new(value: i32) -> Option<RangedI32<MIN, MAX>>

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

pub const fn new_static<const VALUE: i32>() -> RangedI32<MIN, MAX>

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: i32) -> RangedI32<MIN, MAX>

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

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.

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.

pub fn from_str_radix( src: &str, radix: u32, ) -> Result<RangedI32<MIN, MAX>, 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>()));

pub const fn checked_add(self, rhs: i32) -> Option<RangedI32<MIN, MAX>>

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

pub const unsafe fn unchecked_add(self, rhs: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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

pub const unsafe fn unchecked_sub(self, rhs: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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

pub const unsafe fn unchecked_mul(self, rhs: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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: i32) -> RangedI32<MIN, MAX>

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: i32) -> Option<RangedI32<MIN, MAX>>

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: i32) -> RangedI32<MIN, MAX>

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<RangedI32<MIN, MAX>>

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

pub const unsafe fn unchecked_neg(self) -> RangedI32<MIN, MAX>

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) -> RangedI32<MIN, MAX>

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<RangedI32<MIN, MAX>>

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) -> RangedI32<MIN, MAX>

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<RangedI32<MIN, MAX>>

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) -> RangedI32<MIN, MAX>

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<RangedI32<MIN, MAX>>

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

pub const unsafe fn unchecked_abs(self) -> RangedI32<MIN, MAX>

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) -> RangedI32<MIN, MAX>

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<RangedI32<MIN, MAX>>

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) -> RangedI32<MIN, MAX>

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: i32) -> RangedI32<MIN, MAX>

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

pub const fn saturating_sub(self, rhs: i32) -> RangedI32<MIN, MAX>

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

pub const fn saturating_neg(self) -> RangedI32<MIN, MAX>

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

pub const fn saturating_abs(self) -> RangedI32<MIN, MAX>

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

pub const fn saturating_mul(self, rhs: i32) -> RangedI32<MIN, MAX>

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

pub const fn saturating_pow(self, exp: u32) -> RangedI32<MIN, MAX>

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

pub const fn wrapping_add(self, rhs: i32) -> RangedI32<MIN, MAX>

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

pub const fn wrapping_sub(self, rhs: i32) -> RangedI32<MIN, MAX>

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

Trait Implementations

impl<const MIN: i32, const MAX: i32> Arbitrary for RangedI32<MIN, MAX>

Available on crate feature quickcheck only.

fn arbitrary(g: &mut Gen) -> RangedI32<MIN, MAX>

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = RangedI32<MIN, MAX>>>

Return an iterator of values that are smaller than itself.

impl<const MIN: i32, const MAX: i32> AsRef<i32> for RangedI32<MIN, MAX>

fn as_ref(&self) -> &i32

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

impl<const MIN: i32, const MAX: i32> Binary for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> Borrow<i32> for RangedI32<MIN, MAX>

fn borrow(&self) -> &i32

Immutably borrows from an owned value.

impl<const MIN: i32, const MAX: i32> Clone for RangedI32<MIN, MAX>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const MIN: i32, const MAX: i32> Debug for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

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

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<RangedI32<MIN, MAX>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

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: i32, const MAX: i32> Display for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> Eq for RangedI32<MIN, MAX>

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

impl<const MIN: i32, const MAX: i32> FromStr for RangedI32<MIN, MAX>

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<RangedI32<MIN, MAX>, <RangedI32<MIN, MAX> as FromStr>::Err>

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

impl<const MIN: i32, const MAX: i32> Hash for RangedI32<MIN, MAX>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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: i32, const MAX: i32> LowerExp for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> LowerHex for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> Octal for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

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

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

fn eq(&self, other: &RangedI32<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: 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>

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

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const MIN: i32, const MAX: i32> SmartDisplay for RangedI32<MIN, MAX>

Available on crate feature powerfmt only.

type Metadata = <i32 as SmartDisplay>::Metadata

User-provided metadata type.

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

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<'_, RangedI32<MIN, MAX>>, ) -> Result<(), Error>

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: i32, const MAX: i32> TryFrom<i32> for RangedI32<MIN, MAX>

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from( value: i32, ) -> Result<RangedI32<MIN, MAX>, <RangedI32<MIN, MAX> as TryFrom<i32>>::Error>

Performs the conversion.

impl<const MIN: i32, const MAX: i32> UpperExp for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> UpperHex for RangedI32<MIN, MAX>

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

Formats the value using the given formatter.

impl<const MIN: i32, const MAX: i32> Copy for RangedI32<MIN, MAX>