Struct ranged_type::RangedI32

pub struct RangedI32<const START: i32, const END: i32> { /* fields omitted */ }

Implementations

impl<const START: i32, const END: i32> RangedI32<START, END>

#[must_use]pub fn checked_abs(self) -> Option<Self>

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

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

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

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

#[must_use]pub fn checked_neg(self) -> Option<Self>

#[must_use]pub fn checked_pow(self, rhs: u32) -> Option<Self>

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

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

#[must_use]pub fn checked_shl(self, rhs: u32) -> Option<Self>

#[must_use]pub fn checked_shr(self, rhs: u32) -> Option<Self>

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

impl<const START: i32, const END: i32> RangedI32<START, END>

#[must_use]pub fn overflowing_add(self, rhs: i32) -> (Self, bool)

impl<const START: i32, const END: i32> RangedI32<START, END>

#[must_use]pub fn overflowing_sub(self, rhs: i32) -> (Self, bool)

impl<const START: i32, const END: i32> RangedI32<START, END>

#[must_use]pub fn wrapping_abs(self) -> Self

#[must_use]pub fn wrapping_add(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_div(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_div_euclid(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_mul(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_neg(self) -> Self

#[must_use]pub fn wrapping_pow(self, rhs: u32) -> Self

#[must_use]pub fn wrapping_rem(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_rem_euclid(self, rhs: i32) -> Self

#[must_use]pub fn wrapping_shl(self, rhs: u32) -> Self

#[must_use]pub fn wrapping_shr(self, rhs: u32) -> Self

#[must_use]pub fn wrapping_sub(self, rhs: i32) -> Self

impl<const START: i32, const END: i32> RangedI32<START, END>

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

Trait Implementations

impl<const START: i32, const END: i32, const START_RHS: i32, const END_RHS: i32> Add<RangedI32<START_RHS, END_RHS>> for RangedI32<START, END> where
    RangedI32<{ START + START_RHS }, { END + END_RHS - 1 }>: , 

type Output = RangedI32<{ START + START_RHS }, { END + END_RHS - 1 }>

The resulting type after applying the + operator.

fn add(self, rhs: RangedI32<START_RHS, END_RHS>) -> Self::Output

Performs the + operation.

impl<const START: i32, const END: i32> Add<i32> for RangedI32<START, END>

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<const START: i32, const END: i32, const START_RHS: i32, const END_RHS: i32> AddAssign<RangedI32<START_RHS, END_RHS>> for RangedI32<START, END>

fn add_assign(&mut self, rhs: RangedI32<START_RHS, END_RHS>)

Performs the += operation.

impl<const START: i32, const END: i32> AddAssign<i32> for RangedI32<START, END>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const START: i32, const END: i32> Check<i32> for RangedI32<START, END>

type Output = Option<Self>

fn checked_abs(self) -> Self::Output

fn checked_add(self, rhs: i32) -> Self::Output

fn checked_div(self, rhs: i32) -> Self::Output

fn checked_div_euclid(self, rhs: i32) -> Self::Output

fn checked_mul(self, rhs: i32) -> Self::Output

fn checked_neg(self) -> Self::Output

fn checked_pow(self, rhs: u32) -> Self::Output

fn checked_rem(self, rhs: i32) -> Self::Output

fn checked_rem_euclid(self, rhs: i32) -> Self::Output

fn checked_shl(self, rhs: u32) -> Self::Output

fn checked_shr(self, rhs: u32) -> Self::Output

fn checked_sub(self, rhs: i32) -> Self::Output

impl<const START: i32, const END: i32> Debug for RangedI32<START, END>

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

Formats the value using the given formatter.

impl<const START: i32, const END: i32> Eq for RangedI32<START, END>

impl<const START: i32, const END: i32> Overflow<i32> for RangedI32<START, END>

type Output = (Self, bool)

fn overflowing_abs(self) -> Self::Output

#[must_use]fn overflowing_add(self, rhs: i32) -> Self::Output

fn overflowing_div(self, rhs: i32) -> Self::Output

fn overflowing_div_euclid(self, rhs: i32) -> Self::Output

fn overflowing_mul(self, rhs: i32) -> Self::Output

fn overflowing_neg(self) -> Self::Output

fn overflowing_pow(self, rhs: u32) -> Self::Output

fn overflowing_rem(self, rhs: i32) -> Self::Output

fn overflowing_rem_euclid(self, rhs: i32) -> Self::Output

fn overflowing_shl(self, rhs: u32) -> Self::Output

fn overflowing_shr(self, rhs: u32) -> Self::Output

fn overflowing_sub(self, rhs: i32) -> Self::Output

impl<const START: i32, const END: i32> PartialEq<RangedI32<START, END>> for RangedI32<START, END>

fn eq(&self, rhs: &Self) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<const START: i32, const END: i32, const START_RHS: i32, const END_RHS: i32> Sub<RangedI32<START_RHS, END_RHS>> for RangedI32<START, END> where
    RangedI32<{ START - END_RHS + 1 }, { END - START_RHS - 1 }>: , 

type Output = RangedI32<{ START - END_RHS + 1 }, { END - START_RHS - 1 }>

The resulting type after applying the - operator.

fn sub(self, rhs: RangedI32<START_RHS, END_RHS>) -> Self::Output

Performs the - operation.

impl<const START: i32, const END: i32> Sub<i32> for RangedI32<START, END>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<const START: i32, const END: i32, const START_RHS: i32, const END_RHS: i32> SubAssign<RangedI32<START_RHS, END_RHS>> for RangedI32<START, END>

fn sub_assign(&mut self, rhs: RangedI32<START_RHS, END_RHS>)

Performs the -= operation.

impl<const START: i32, const END: i32> SubAssign<i32> for RangedI32<START, END>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const START: i32, const END: i32> Wrap<i32> for RangedI32<START, END>

type Output = Self

fn wrapping_abs(self) -> Self::Output

fn wrapping_add(self, rhs: i32) -> Self::Output

fn wrapping_div(self, rhs: i32) -> Self::Output

fn wrapping_div_euclid(self, rhs: i32) -> Self::Output

fn wrapping_mul(self, rhs: i32) -> Self::Output

fn wrapping_neg(self) -> Self::Output

fn wrapping_pow(self, rhs: u32) -> Self::Output

fn wrapping_rem(self, rhs: i32) -> Self::Output

fn wrapping_rem_euclid(self, rhs: i32) -> Self::Output

fn wrapping_shl(self, rhs: u32) -> Self::Output

fn wrapping_shr(self, rhs: u32) -> Self::Output

fn wrapping_sub(self, rhs: i32) -> Self::Output