Enum BoundedEnum

#[repr(i8)]
pub enum BoundedEnum {
    N8 = -8,
    N7 = 249,
    N6 = 250,
    N5 = 251,
    N4 = 252,
    N3 = 253,
    N2 = 254,
    N1 = 255,
    Z = 0,
    P1 = 1,
    P2 = 2,
    P3 = 3,
    P4 = 4,
    P5 = 5,
    P6 = 6,
    P7 = 7,
}

Available on crate feature __doc only.

A bounded enum.

This was generated from:

bounded_integer! {
    pub enum BoundedEnum(-8, 7);
}

Variants

N8 = -8

N7 = 249

N6 = 250

N5 = 251

N4 = 252

N3 = 253

N2 = 254

N1 = 255

Z = 0

P1 = 1

P2 = 2

P3 = 3

P4 = 4

P5 = 5

P6 = 6

P7 = 7

Implementations

impl BoundedEnum

pub const MIN_VALUE: i8 = -8i8

The smallest value this bounded integer can contain.

pub const MAX_VALUE: i8 = 7i8

The largest value that this bounded integer can contain.

pub const MIN: Self

The smallest value of the bounded integer.

pub const MAX: Self

The largest value of the bounded integer.

pub const fn new(n: i8) -> Option<Self>

Creates a bounded integer if the given value is within the range [MIN, MAX].

pub const fn const_new<const N: i8>() -> Self

Creates a bounded integer whose value is known at compile time.

Causes a compile-time error if N is not in the valid range.

pub const fn new_ref(n: &i8) -> Option<&Self>

Creates a reference to a bounded integer from a reference to a primitive if the given value is within the range [MIN, MAX].

pub const fn new_mut(n: &mut i8) -> Option<&mut Self>

Creates a mutable reference to a bounded integer from a mutable reference to a primitive if the given value is within the range [MIN, MAX].

pub const unsafe fn new_unchecked(n: i8) -> Self

Creates a bounded integer without checking the value.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const unsafe fn new_ref_unchecked(n: &i8) -> &Self

Creates a shared reference to a bounded integer from a shared reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const unsafe fn new_mut_unchecked(n: &mut i8) -> &mut Self

Creates a mutable reference to a bounded integer from a mutable reference to a primitive.

Safety

The value must not be outside the valid range of values; it must not be less than MIN_VALUE or greater than MAX_VALUE.

pub const fn in_range(n: i8) -> bool

Checks whether the given value is in the range of the bounded integer.

pub const fn new_saturating(n: i8) -> Self

Creates a bounded integer by setting the value to MIN or MAX if it is too low or too high respectively.

pub const fn new_wrapping<__Z: LargerInt>(n: __Z) -> Self

Creates a bounded integer by wrapping using modular arithmetic.

For n in range, this is an identity function, and it wraps for n out of range.

The type parameter Z must be any integer type that is a superset of this one.

pub const fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseError>

Converts a string slice in a given base to the bounded integer.

Panics

Panics if radix is below 2 or above 36.

pub const fn get(self) -> i8

Returns the value of the bounded integer as a primitive type.

pub const fn get_ref(&self) -> &i8

Returns a shared reference to the value of the bounded integer.

pub const unsafe fn get_mut(&mut self) -> &mut i8

Returns a mutable reference to the value of the bounded integer.

Safety

This value must never be set to a value beyond the range of the bounded integer.

pub const fn abs(self) -> Self

Computes the absolute value of self, panicking if it is out of range.

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

Raises self to the power of exp, using exponentiation by squaring. Panics if it is out of range.

pub const fn div_euclid(self, rhs: i8) -> Self

Calculates the quotient of Euclidean division of self by rhs. Panics if rhs is 0 or the result is out of range.

pub const fn rem_euclid(self, rhs: i8) -> Self

Calculates the least nonnegative remainder of self (mod rhs). Panics if rhs is 0 or the result is out of range.

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

Checked integer addition.

Returns None if the result would be out of range.

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

Saturating integer addition.

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

Wrapping (modular) integer addition.

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

Checked integer subtraction.

Returns None if the result would be out of range.

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

Saturating integer subtraction.

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

Wrapping (modular) integer subtraction.

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

Checked integer multiplication.

Returns None if the result would be out of range.

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

Saturating integer multiplication.

pub const fn wrapping_mul(self, rhs: i8) -> Self

Wrapping (modular) integer multiplication.

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

Checked integer division.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_div(self, rhs: i8) -> Self

Wrapping (modular) integer division.

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

Checked Euclidean division.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_div_euclid(self, rhs: i8) -> Self

Wrapping (modular) Euclidean division.

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

Checked integer remainder.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_rem(self, rhs: i8) -> Self

Wrapping (modular) integer remainder.

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

Checked Euclidean remainder.

Returns None if the result would be out of range, or if rhs is zero.

pub const fn wrapping_rem_euclid(self, rhs: i8) -> Self

Wrapping (modular) Euclidean remainder.

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

Checked negation.

Returns None if the result would be out of range.

pub const fn saturating_neg(self) -> Self

Saturating negation.

pub const fn wrapping_neg(self) -> Self

Wrapping (modular) negation.

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

Checked absolute value.

pub const fn saturating_abs(self) -> Self

Saturating absolute value.

pub const fn wrapping_abs(self) -> Self

Wrapping (modular) absolute value.

pub const fn checked_pow(self, rhs: u32) -> Option<Self>

Checked exponentiation.

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

Saturating exponentiation.

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

Wrapping (modular) exponentiation.

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

Checked shift left.

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

Checked shift right.

Trait Implementations

impl Add<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<BoundedEnum> for i8

type Output = i8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&BoundedEnum> for BoundedEnum

fn add_assign(&mut self, rhs: &BoundedEnum)

Performs the += operation.

impl AddAssign<&BoundedEnum> for i8

fn add_assign(&mut self, rhs: &BoundedEnum)

Performs the += operation.

impl AddAssign<&i8> for BoundedEnum

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl AddAssign<BoundedEnum> for i8

fn add_assign(&mut self, rhs: BoundedEnum)

Performs the += operation.

impl AddAssign<i8> for BoundedEnum

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign for BoundedEnum

fn add_assign(&mut self, rhs: BoundedEnum)

Performs the += operation.

impl<'__a> Arbitrary<'__a> for BoundedEnum

Available on crate feature arbitrary1 only.

fn arbitrary(u: &mut Unstructured<'__a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<__T> AsPrimitive<__T> for BoundedEnum

where i8: AsPrimitive<__T>, __T: 'static + Copy, Self: 'static,

Available on crate feature num-traits02 only.

fn as_(self) -> __T

Convert a value to another, using the as operator.

impl AsRef<i8> for BoundedEnum

fn as_ref(&self) -> &i8

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

impl Binary for BoundedEnum

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

Formats the value using the given formatter.

impl BitAnd<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: &i8) -> Self::Output

Performs the & operation.

impl BitAnd<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: &i8) -> Self::Output

Performs the & operation.

impl BitAnd<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<BoundedEnum> for i8

type Output = i8

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAnd<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl BitAnd<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> Self::Output

Performs the & operation.

impl BitAnd for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the & operator.

fn bitand(self, rhs: BoundedEnum) -> Self::Output

Performs the & operation.

impl BitAndAssign<&BoundedEnum> for BoundedEnum

fn bitand_assign(&mut self, rhs: &BoundedEnum)

Performs the &= operation.

impl BitAndAssign<&BoundedEnum> for i8

fn bitand_assign(&mut self, rhs: &BoundedEnum)

Performs the &= operation.

impl BitAndAssign<&i8> for BoundedEnum

fn bitand_assign(&mut self, rhs: &i8)

Performs the &= operation.

impl BitAndAssign<BoundedEnum> for i8

fn bitand_assign(&mut self, rhs: BoundedEnum)

Performs the &= operation.

impl BitAndAssign<i8> for BoundedEnum

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl BitAndAssign for BoundedEnum

fn bitand_assign(&mut self, rhs: BoundedEnum)

Performs the &= operation.

impl BitOr<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: &i8) -> Self::Output

Performs the | operation.

impl BitOr<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: &i8) -> Self::Output

Performs the | operation.

impl BitOr<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<BoundedEnum> for i8

type Output = i8

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOr<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl BitOr<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> Self::Output

Performs the | operation.

impl BitOr for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the | operator.

fn bitor(self, rhs: BoundedEnum) -> Self::Output

Performs the | operation.

impl BitOrAssign<&BoundedEnum> for BoundedEnum

fn bitor_assign(&mut self, rhs: &BoundedEnum)

Performs the |= operation.

impl BitOrAssign<&BoundedEnum> for i8

fn bitor_assign(&mut self, rhs: &BoundedEnum)

Performs the |= operation.

impl BitOrAssign<&i8> for BoundedEnum

fn bitor_assign(&mut self, rhs: &i8)

Performs the |= operation.

impl BitOrAssign<BoundedEnum> for i8

fn bitor_assign(&mut self, rhs: BoundedEnum)

Performs the |= operation.

impl BitOrAssign<i8> for BoundedEnum

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl BitOrAssign for BoundedEnum

fn bitor_assign(&mut self, rhs: BoundedEnum)

Performs the |= operation.

impl BitXor<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i8) -> Self::Output

Performs the ^ operation.

impl BitXor<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i8) -> Self::Output

Performs the ^ operation.

impl BitXor<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<BoundedEnum> for i8

type Output = i8

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXor<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl BitXor<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> Self::Output

Performs the ^ operation.

impl BitXor for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoundedEnum) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<&BoundedEnum> for BoundedEnum

fn bitxor_assign(&mut self, rhs: &BoundedEnum)

Performs the ^= operation.

impl BitXorAssign<&BoundedEnum> for i8

fn bitxor_assign(&mut self, rhs: &BoundedEnum)

Performs the ^= operation.

impl BitXorAssign<&i8> for BoundedEnum

fn bitxor_assign(&mut self, rhs: &i8)

Performs the ^= operation.

impl BitXorAssign<BoundedEnum> for i8

fn bitxor_assign(&mut self, rhs: BoundedEnum)

Performs the ^= operation.

impl BitXorAssign<i8> for BoundedEnum

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl BitXorAssign for BoundedEnum

fn bitxor_assign(&mut self, rhs: BoundedEnum)

Performs the ^= operation.

impl Borrow<i8> for BoundedEnum

fn borrow(&self) -> &i8

Immutably borrows from an owned value.

impl Bounded for BoundedEnum

Available on crate feature num-traits02 only.

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl CheckedAdd for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_add(&self, v: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedDiv for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedMul for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_mul(&self, v: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl CheckedNeg for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl CheckedRem for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_rem(&self, v: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedShl for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_shl(&self, v: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl CheckedShr for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_shr(&self, v: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl CheckedSub for BoundedEnum

Available on crate feature num-traits02 only.

fn checked_sub(&self, v: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for BoundedEnum

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Contiguous for BoundedEnum

where Self: 'static,

Available on crate feature bytemuck1 only.

const MAX_VALUE: i8 = 7i8

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i8 = -8i8

The lower inclusive bound for valid instances of this type.

type Int = i8

The primitive integer type with an identical representation to this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl Debug for BoundedEnum

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

Formats the value using the given formatter.

impl Default for BoundedEnum

fn default() -> Self

Returns the “default value” for a type.

impl<'__de> Deserialize<'__de> for BoundedEnum

Available on crate feature serde1 only.

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

Deserialize this value from the given Serde deserializer.

impl Display for BoundedEnum

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

Formats the value using the given formatter.

impl Div<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: &BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl Div<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> Self::Output

Performs the / operation.

impl Div<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<BoundedEnum> for i8

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: BoundedEnum) -> Self::Output

Performs the / operation.

impl Div<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl Div<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl Div for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the / operator.

fn div(self, rhs: BoundedEnum) -> Self::Output

Performs the / operation.

impl DivAssign<&BoundedEnum> for BoundedEnum

fn div_assign(&mut self, rhs: &BoundedEnum)

Performs the /= operation.

impl DivAssign<&BoundedEnum> for i8

fn div_assign(&mut self, rhs: &BoundedEnum)

Performs the /= operation.

impl DivAssign<&i8> for BoundedEnum

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl DivAssign<BoundedEnum> for i8

fn div_assign(&mut self, rhs: BoundedEnum)

Performs the /= operation.

impl DivAssign<i8> for BoundedEnum

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign for BoundedEnum

fn div_assign(&mut self, rhs: BoundedEnum)

Performs the /= operation.

impl From<BoundedEnum> for i128

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl From<BoundedEnum> for i16

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl From<BoundedEnum> for i32

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl From<BoundedEnum> for i64

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl From<BoundedEnum> for i8

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl From<BoundedEnum> for isize

fn from(bounded: BoundedEnum) -> Self

Converts to this type from the input type.

impl FromPrimitive for BoundedEnum

where i8: FromPrimitive,

Available on crate feature num-traits02 only.

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for BoundedEnum

type Err = ParseError

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 FromZeros for BoundedEnum

fn zero(&mut self)

Overwrites self with zeros.

fn new_zeroed() -> Self

where Self: Sized,

Creates an instance of Self from zeroed bytes.

impl Hash for BoundedEnum

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 IntoBytes for BoundedEnum

fn as_bytes(&self) -> &[u8]

where Self: Immutable,

Gets the bytes of this value.

fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to dst.

fn write_to_prefix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the prefix of dst.

fn write_to_suffix( &self, dst: &mut [u8], ) -> Result<(), SizeError<&Self, &mut [u8]>>

where Self: Immutable,

Writes a copy of self to the suffix of dst.

impl LowerExp for BoundedEnum

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

Formats the value using the given formatter.

impl LowerHex for BoundedEnum

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

Formats the value using the given formatter.

impl Mul<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: &BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl Mul<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> Self::Output

Performs the * operation.

impl Mul<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<BoundedEnum> for i8

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedEnum) -> Self::Output

Performs the * operation.

impl Mul<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl Mul<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl Mul for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the * operator.

fn mul(self, rhs: BoundedEnum) -> Self::Output

Performs the * operation.

impl<__A, __B> MulAdd<__A, __B> for BoundedEnum

where i8: MulAdd<__A, __B, Output = i8>,

Available on crate feature num-traits02 only.

type Output = i8

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: __A, b: __B) -> Self::Output

Performs the fused multiply-add operation (self * a) + b

impl MulAssign<&BoundedEnum> for BoundedEnum

fn mul_assign(&mut self, rhs: &BoundedEnum)

Performs the *= operation.

impl MulAssign<&BoundedEnum> for i8

fn mul_assign(&mut self, rhs: &BoundedEnum)

Performs the *= operation.

impl MulAssign<&i8> for BoundedEnum

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<BoundedEnum> for i8

fn mul_assign(&mut self, rhs: BoundedEnum)

Performs the *= operation.

impl MulAssign<i8> for BoundedEnum

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign for BoundedEnum

fn mul_assign(&mut self, rhs: BoundedEnum)

Performs the *= operation.

impl Neg for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl NumCast for BoundedEnum

where i8: NumCast,

Available on crate feature num-traits02 only.

fn from<__T: ToPrimitive>(n: __T) -> Option<Self>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl Octal for BoundedEnum

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

Formats the value using the given formatter.

impl One for BoundedEnum

Available on crate feature num-traits02 only.

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl Ord for BoundedEnum

fn cmp(&self, other: &BoundedEnum) -> 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 PartialEq<BoundedEnum> for i8

fn eq(&self, other: &BoundedEnum) -> 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 PartialEq<i8> for BoundedEnum

fn eq(&self, other: &i8) -> 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 PartialEq for BoundedEnum

fn eq(&self, other: &BoundedEnum) -> 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 PartialOrd<BoundedEnum> for i8

fn partial_cmp(&self, other: &BoundedEnum) -> 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 PartialOrd<i8> for BoundedEnum

fn partial_cmp(&self, other: &i8) -> 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 PartialOrd for BoundedEnum

fn partial_cmp(&self, other: &BoundedEnum) -> 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<'__a> Product<&'__a BoundedEnum> for BoundedEnum

fn product<I: Iterator<Item = &'__a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'__a> Product<&'__a BoundedEnum> for i8

fn product<I: Iterator<Item = &'__a BoundedEnum>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product<BoundedEnum> for i8

fn product<I: Iterator<Item = BoundedEnum>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product for BoundedEnum

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Rem<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: &BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl Rem<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl Rem<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<BoundedEnum> for i8

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedEnum) -> Self::Output

Performs the % operation.

impl Rem<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl Rem<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Self::Output

Performs the % operation.

impl Rem for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the % operator.

fn rem(self, rhs: BoundedEnum) -> Self::Output

Performs the % operation.

impl RemAssign<&BoundedEnum> for BoundedEnum

fn rem_assign(&mut self, rhs: &BoundedEnum)

Performs the %= operation.

impl RemAssign<&BoundedEnum> for i8

fn rem_assign(&mut self, rhs: &BoundedEnum)

Performs the %= operation.

impl RemAssign<&i8> for BoundedEnum

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl RemAssign<BoundedEnum> for i8

fn rem_assign(&mut self, rhs: BoundedEnum)

Performs the %= operation.

impl RemAssign<i8> for BoundedEnum

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl RemAssign for BoundedEnum

fn rem_assign(&mut self, rhs: BoundedEnum)

Performs the %= operation.

impl SaturatingAdd for BoundedEnum

Available on crate feature num-traits02 only.

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl SaturatingMul for BoundedEnum

Available on crate feature num-traits02 only.

fn saturating_mul(&self, v: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl SaturatingSub for BoundedEnum

Available on crate feature num-traits02 only.

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl Serialize for BoundedEnum

Available on crate feature serde1 only.

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

Serialize this value into the given Serde serializer.

impl Shl<&u32> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<&u32> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shl<u32> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the << operator.

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

Performs the << operation.

impl ShlAssign<&u32> for BoundedEnum

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl ShlAssign<u32> for BoundedEnum

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl Shr<&u32> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<&u32> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Shr<u32> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl ShrAssign<&u32> for BoundedEnum

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl ShrAssign<u32> for BoundedEnum

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl Step for BoundedEnum

Available on crate feature step_trait only.

fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>)

🔬This is a nightly-only experimental API. (step_trait)

Returns the bounds on the number of successor steps required to get from start to end like Iterator::size_hint().

fn forward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward_checked(start: Self, count: usize) -> Option<Self>

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

fn forward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

unsafe fn forward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the successor of self count times.

fn backward(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

unsafe fn backward_unchecked(start: Self, count: usize) -> Self

🔬This is a nightly-only experimental API. (step_trait)

Returns the value that would be obtained by taking the predecessor of self count times.

impl Sub<&BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&BoundedEnum> for &i8

type Output = i8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&BoundedEnum> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&BoundedEnum> for i8

type Output = i8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<BoundedEnum> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<BoundedEnum> for &i8

type Output = i8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<BoundedEnum> for i8

type Output = i8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for &BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for BoundedEnum

type Output = BoundedEnum

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&BoundedEnum> for BoundedEnum

fn sub_assign(&mut self, rhs: &BoundedEnum)

Performs the -= operation.

impl SubAssign<&BoundedEnum> for i8

fn sub_assign(&mut self, rhs: &BoundedEnum)

Performs the -= operation.

impl SubAssign<&i8> for BoundedEnum

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<BoundedEnum> for i8

fn sub_assign(&mut self, rhs: BoundedEnum)

Performs the -= operation.

impl SubAssign<i8> for BoundedEnum

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign for BoundedEnum

fn sub_assign(&mut self, rhs: BoundedEnum)

Performs the -= operation.

impl<'__a> Sum<&'__a BoundedEnum> for BoundedEnum

fn sum<I: Iterator<Item = &'__a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'__a> Sum<&'__a BoundedEnum> for i8

fn sum<I: Iterator<Item = &'__a BoundedEnum>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum<BoundedEnum> for i8

fn sum<I: Iterator<Item = BoundedEnum>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for BoundedEnum

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl ToPrimitive for BoundedEnum

where i8: ToPrimitive,

Available on crate feature num-traits02 only.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl TryFrom<BoundedEnum> for u128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoundedEnum> for u16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoundedEnum> for u32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoundedEnum> for u64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoundedEnum> for u8

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoundedEnum> for usize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(n: BoundedEnum) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i128> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i16> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i32> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i64> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i8> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<isize> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u128> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u16> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u64> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<usize> for BoundedEnum

type Error = TryFromError

The type returned in the event of a conversion error.

fn try_from(n: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFromBytes for BoundedEnum

fn try_read_from_bytes( source: &[u8], ) -> Result<Self, ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read the given source as a Self.

fn try_read_from_prefix( source: &[u8], ) -> Result<(Self, &[u8]), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the prefix of the given source.

fn try_read_from_suffix( source: &[u8], ) -> Result<(&[u8], Self), ConvertError<Infallible, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>

where Self: Sized,

Attempts to read a Self from the suffix of the given source.

impl UpperExp for BoundedEnum

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

Formats the value using the given formatter.

impl UpperHex for BoundedEnum

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

Formats the value using the given formatter.

impl Zero for BoundedEnum

Available on crate feature num-traits02 only.

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Zeroable for BoundedEnum

Available on crate feature bytemuck1 only.

fn zeroed() -> Self

Calls zeroed.

impl Copy for BoundedEnum

impl Eq for BoundedEnum

impl Immutable for BoundedEnum

impl NoUninit for BoundedEnum

where Self: 'static,

Available on crate feature bytemuck1 only.

impl Unaligned for BoundedEnum