pub struct NonZeroI32(/* private fields */);
Expand description
An integer that is known not to equal zero.
This enables some memory layout optimization.
For example, Option<NonZeroI32>
is the same size as i32
:
use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroI32>>(), size_of::<i32>());
§Layout
NonZeroI32
is guaranteed to have the same layout and bit validity as i32
with the exception that 0
is not a valid instance.
Option<NonZeroI32>
is guaranteed to be compatible with i32
,
including in FFI.
Thanks to the null pointer optimization,
NonZeroI32
and Option<NonZeroI32>
are guaranteed to have the same size and alignment:
use std::num::NonZeroI32;
assert_eq!(size_of::<NonZeroI32>(), size_of::<Option<NonZeroI32>>());
assert_eq!(align_of::<NonZeroI32>(), align_of::<Option<NonZeroI32>>());
Implementations§
source§impl NonZeroI32
impl NonZeroI32
const: 1.34.0 · sourcepub const unsafe fn new_unchecked(n: i32) -> NonZeroI32
pub const unsafe fn new_unchecked(n: i32) -> NonZeroI32
Creates a non-zero without checking whether the value is non-zero. This results in undefined behaviour if the value is zero.
§Safety
The value must not be zero.
const: 1.47.0 · sourcepub const fn new(n: i32) -> Option<NonZeroI32>
pub const fn new(n: i32) -> Option<NonZeroI32>
Creates a non-zero if the given value is not zero.
sourcepub unsafe fn from_mut_unchecked(n: &mut i32) -> &mut NonZeroI32
🔬This is a nightly-only experimental API. (nonzero_from_mut
)
pub unsafe fn from_mut_unchecked(n: &mut i32) -> &mut NonZeroI32
nonzero_from_mut
)Converts a primitive mutable reference to a non-zero mutable reference
without checking whether the referenced value is non-zero.
This results in undefined behavior if *n
is zero.
§Safety
The referenced value must not be currently zero.
sourcepub fn from_mut(n: &mut i32) -> Option<&mut NonZeroI32>
🔬This is a nightly-only experimental API. (nonzero_from_mut
)
pub fn from_mut(n: &mut i32) -> Option<&mut NonZeroI32>
nonzero_from_mut
)Converts a primitive mutable reference to a non-zero mutable reference if the referenced integer is not zero.
1.53.0 (const: 1.53.0) · sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
Returns the number of leading zeros in the binary representation of self
.
On many architectures, this function can perform better than leading_zeros()
on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = std::num::NonZeroI32::new(-1i32).unwrap();
assert_eq!(n.leading_zeros(), 0);
1.53.0 (const: 1.53.0) · sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
Returns the number of trailing zeros in the binary representation
of self
.
On many architectures, this function can perform better than trailing_zeros()
on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = std::num::NonZeroI32::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
const: unstable · sourcepub fn count_ones(self) -> NonZeroU32
🔬This is a nightly-only experimental API. (non_zero_count_ones
)
pub fn count_ones(self) -> NonZeroU32
non_zero_count_ones
)Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
#![feature(non_zero_count_ones)]
let one = num::NonZeroU32::new(1)?;
let three = num::NonZeroU32::new(3)?;
let a = NonZeroI32::new(0b100_0000)?;
let b = NonZeroI32::new(0b100_0011)?;
assert_eq!(a.count_ones(), one);
assert_eq!(b.count_ones(), three);
1.70.0 · sourcepub const MIN: NonZeroI32 = _
pub const MIN: NonZeroI32 = _
The smallest value that can be represented by this non-zero
integer type,
equal to i32::MIN
.
Note: While most integer types are defined for every whole
number between MIN
and MAX
, signed non-zero integers are
a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZeroI32::MIN.get(), i32::MIN);
1.70.0 · sourcepub const MAX: NonZeroI32 = _
pub const MAX: NonZeroI32 = _
The largest value that can be represented by this non-zero
integer type,
equal to i32::MAX
.
Note: While most integer types are defined for every whole
number between MIN
and MAX
, signed non-zero integers are
a special case. They have a “gap” at 0.
§Examples
assert_eq!(NonZeroI32::MAX.get(), i32::MAX);
1.64.0 (const: 1.64.0) · sourcepub const fn abs(self) -> NonZeroI32
pub const fn abs(self) -> NonZeroI32
1.64.0 (const: 1.64.0) · sourcepub const fn checked_abs(self) -> Option<NonZeroI32>
pub const fn checked_abs(self) -> Option<NonZeroI32>
Checked absolute value.
Checks for overflow and returns None
if
self == NonZeroI32::MIN
.
The result cannot be zero.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(Some(pos), neg.checked_abs());
assert_eq!(None, min.checked_abs());
1.64.0 (const: 1.64.0) · sourcepub const fn overflowing_abs(self) -> (NonZeroI32, bool)
pub const fn overflowing_abs(self) -> (NonZeroI32, bool)
Computes the absolute value of self,
with overflow information, see
i32::overflowing_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!((pos, false), pos.overflowing_abs());
assert_eq!((pos, false), neg.overflowing_abs());
assert_eq!((min, true), min.overflowing_abs());
1.64.0 (const: 1.64.0) · sourcepub const fn saturating_abs(self) -> NonZeroI32
pub const fn saturating_abs(self) -> NonZeroI32
Saturating absolute value, see
i32::saturating_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
let min_plus = NonZeroI32::new(i32::MIN + 1)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(pos, pos.saturating_abs());
assert_eq!(pos, neg.saturating_abs());
assert_eq!(max, min.saturating_abs());
assert_eq!(max, min_plus.saturating_abs());
1.64.0 (const: 1.64.0) · sourcepub const fn wrapping_abs(self) -> NonZeroI32
pub const fn wrapping_abs(self) -> NonZeroI32
Wrapping absolute value, see
i32::wrapping_abs
.
§Example
let pos = NonZeroI32::new(1)?;
let neg = NonZeroI32::new(-1)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos, pos.wrapping_abs());
assert_eq!(pos, neg.wrapping_abs());
assert_eq!(min, min.wrapping_abs());
assert_eq!(max, (-max).wrapping_abs());
1.64.0 (const: 1.64.0) · sourcepub const fn unsigned_abs(self) -> NonZeroU32
pub const fn unsigned_abs(self) -> NonZeroU32
Computes the absolute value of self without any wrapping or panicking.
§Example
let u_pos = NonZeroU32::new(1)?;
let i_pos = NonZeroI32::new(1)?;
let i_neg = NonZeroI32::new(-1)?;
let i_min = NonZeroI32::new(i32::MIN)?;
let u_max = NonZeroU32::new(u32::MAX / 2 + 1)?;
assert_eq!(u_pos, i_pos.unsigned_abs());
assert_eq!(u_pos, i_neg.unsigned_abs());
assert_eq!(u_max, i_min.unsigned_abs());
1.71.0 (const: 1.71.0) · sourcepub const fn is_positive(self) -> bool
pub const fn is_positive(self) -> bool
Returns true
if self
is positive and false
if the
number is negative.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
assert!(pos_five.is_positive());
assert!(!neg_five.is_positive());
1.71.0 (const: 1.71.0) · sourcepub const fn is_negative(self) -> bool
pub const fn is_negative(self) -> bool
Returns true
if self
is negative and false
if the
number is positive.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
assert!(neg_five.is_negative());
assert!(!pos_five.is_negative());
1.71.0 (const: 1.71.0) · sourcepub const fn checked_neg(self) -> Option<NonZeroI32>
pub const fn checked_neg(self) -> Option<NonZeroI32>
Checked negation. Computes -self
,
returning None
if self == NonZeroI32::MIN
.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos_five.checked_neg(), Some(neg_five));
assert_eq!(min.checked_neg(), None);
1.71.0 (const: 1.71.0) · sourcepub const fn overflowing_neg(self) -> (NonZeroI32, bool)
pub const fn overflowing_neg(self) -> (NonZeroI32, bool)
Negates self, overflowing if this is equal to the minimum value.
See i32::overflowing_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos_five.overflowing_neg(), (neg_five, false));
assert_eq!(min.overflowing_neg(), (min, true));
1.71.0 (const: 1.71.0) · sourcepub const fn saturating_neg(self) -> NonZeroI32
pub const fn saturating_neg(self) -> NonZeroI32
Saturating negation. Computes -self
,
returning NonZeroI32::MAX
if self == NonZeroI32::MIN
instead of overflowing.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
let min_plus_one = NonZeroI32::new(i32::MIN + 1)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(pos_five.saturating_neg(), neg_five);
assert_eq!(min.saturating_neg(), max);
assert_eq!(max.saturating_neg(), min_plus_one);
1.71.0 (const: 1.71.0) · sourcepub const fn wrapping_neg(self) -> NonZeroI32
pub const fn wrapping_neg(self) -> NonZeroI32
Wrapping (modular) negation. Computes -self
, wrapping around at the boundary
of the type.
See i32::wrapping_neg
for documentation on overflow behaviour.
§Example
let pos_five = NonZeroI32::new(5)?;
let neg_five = NonZeroI32::new(-5)?;
let min = NonZeroI32::new(i32::MIN)?;
assert_eq!(pos_five.wrapping_neg(), neg_five);
assert_eq!(min.wrapping_neg(), min);
1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZeroI32) -> Option<NonZeroI32>
pub const fn checked_mul(self, other: NonZeroI32) -> Option<NonZeroI32>
Multiplies two non-zero integers together.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
1.64.0 (const: 1.64.0) · sourcepub const fn saturating_mul(self, other: NonZeroI32) -> NonZeroI32
pub const fn saturating_mul(self, other: NonZeroI32) -> NonZeroI32
Multiplies two non-zero integers together.
Return NonZeroI32::MAX
on overflow.
§Examples
let two = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
sourcepub const unsafe fn unchecked_mul(self, other: NonZeroI32) -> NonZeroI32
🔬This is a nightly-only experimental API. (nonzero_ops
)
pub const unsafe fn unchecked_mul(self, other: NonZeroI32) -> NonZeroI32
nonzero_ops
)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behaviour to overflow
even if the result would wrap to a non-zero value.
The behaviour is undefined as soon as
self * rhs > i32::MAX
, or self * rhs < i32::MIN
.
§Examples
#![feature(nonzero_ops)]
let two = NonZeroI32::new(2)?;
let four = NonZeroI32::new(4)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
1.64.0 (const: 1.64.0) · sourcepub const fn checked_pow(self, other: u32) -> Option<NonZeroI32>
pub const fn checked_pow(self, other: u32) -> Option<NonZeroI32>
Raises non-zero value to an integer power.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZeroI32::new(3)?;
let twenty_seven = NonZeroI32::new(27)?;
let half_max = NonZeroI32::new(i32::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
1.64.0 (const: 1.64.0) · sourcepub const fn saturating_pow(self, other: u32) -> NonZeroI32
pub const fn saturating_pow(self, other: u32) -> NonZeroI32
Raise non-zero value to an integer power.
Return NonZeroI32::MIN
or NonZeroI32::MAX
on overflow.
§Examples
let three = NonZeroI32::new(3)?;
let twenty_seven = NonZeroI32::new(27)?;
let max = NonZeroI32::new(i32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Trait Implementations§
§impl AsBytes for NonZeroI32
impl AsBytes for NonZeroI32
§fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>
fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>
source§impl Binary for NonZeroI32
impl Binary for NonZeroI32
1.45.0 · source§impl BitOr<NonZeroI32> for i32
impl BitOr<NonZeroI32> for i32
§type Output = NonZeroI32
type Output = NonZeroI32
|
operator.source§fn bitor(self, rhs: NonZeroI32) -> <i32 as BitOr<NonZeroI32>>::Output
fn bitor(self, rhs: NonZeroI32) -> <i32 as BitOr<NonZeroI32>>::Output
|
operation. Read more1.45.0 · source§impl BitOr<i32> for NonZeroI32
impl BitOr<i32> for NonZeroI32
1.45.0 · source§impl BitOr for NonZeroI32
impl BitOr for NonZeroI32
§type Output = NonZeroI32
type Output = NonZeroI32
|
operator.source§fn bitor(self, rhs: NonZeroI32) -> <NonZeroI32 as BitOr>::Output
fn bitor(self, rhs: NonZeroI32) -> <NonZeroI32 as BitOr>::Output
|
operation. Read more1.45.0 · source§impl BitOrAssign<i32> for NonZeroI32
impl BitOrAssign<i32> for NonZeroI32
source§fn bitor_assign(&mut self, rhs: i32)
fn bitor_assign(&mut self, rhs: i32)
|=
operation. Read more1.45.0 · source§impl BitOrAssign for NonZeroI32
impl BitOrAssign for NonZeroI32
source§fn bitor_assign(&mut self, rhs: NonZeroI32)
fn bitor_assign(&mut self, rhs: NonZeroI32)
|=
operation. Read moresource§impl Clone for NonZeroI32
impl Clone for NonZeroI32
source§fn clone(&self) -> NonZeroI32
fn clone(&self) -> NonZeroI32
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for NonZeroI32
impl Debug for NonZeroI32
§impl Decode for NonZeroI32
impl Decode for NonZeroI32
§fn decode<I>(input: &mut I) -> Result<NonZeroI32, Error>where
I: Input,
fn decode<I>(input: &mut I) -> Result<NonZeroI32, Error>where
I: Input,
§fn decode_into<I>(
input: &mut I,
dst: &mut MaybeUninit<Self>
) -> Result<DecodeFinished, Error>where
I: Input,
fn decode_into<I>(
input: &mut I,
dst: &mut MaybeUninit<Self>
) -> Result<DecodeFinished, Error>where
I: Input,
§fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,
fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,
§fn encoded_fixed_size() -> Option<usize>
fn encoded_fixed_size() -> Option<usize>
source§impl<'de> Deserialize<'de> for NonZeroI32
impl<'de> Deserialize<'de> for NonZeroI32
source§fn deserialize<D>(
deserializer: D
) -> Result<NonZeroI32, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<NonZeroI32, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl Display for NonZeroI32
impl Display for NonZeroI32
§impl Encode for NonZeroI32
impl Encode for NonZeroI32
§fn using_encoded<R, F>(&self, f: F) -> R
fn using_encoded<R, F>(&self, f: F) -> R
§fn encoded_size(&self) -> usize
fn encoded_size(&self) -> usize
§impl EncodeAsType for NonZeroI32
impl EncodeAsType for NonZeroI32
§fn encode_as_type_to(
&self,
type_id: u32,
types: &PortableRegistry,
out: &mut Vec<u8>
) -> Result<(), Error>
fn encode_as_type_to( &self, type_id: u32, types: &PortableRegistry, out: &mut Vec<u8> ) -> Result<(), Error>
type_id
, types
, a context
and some output target for the SCALE encoded bytes,
attempt to SCALE encode the current value into the type given by type_id
.§fn encode_as_type(
&self,
type_id: u32,
types: &PortableRegistry
) -> Result<Vec<u8>, Error>
fn encode_as_type( &self, type_id: u32, types: &PortableRegistry ) -> Result<Vec<u8>, Error>
EncodeAsType::encode_as_type_to
]. Prefer to
implement that instead.1.41.0 · source§impl From<NonZeroI16> for NonZeroI32
impl From<NonZeroI16> for NonZeroI32
source§fn from(small: NonZeroI16) -> NonZeroI32
fn from(small: NonZeroI16) -> NonZeroI32
Converts NonZeroI16
to NonZeroI32
losslessly.
1.41.0 · source§impl From<NonZeroI32> for NonZeroI128
impl From<NonZeroI32> for NonZeroI128
source§fn from(small: NonZeroI32) -> NonZeroI128
fn from(small: NonZeroI32) -> NonZeroI128
Converts NonZeroI32
to NonZeroI128
losslessly.
1.41.0 · source§impl From<NonZeroI32> for NonZeroI64
impl From<NonZeroI32> for NonZeroI64
source§fn from(small: NonZeroI32) -> NonZeroI64
fn from(small: NonZeroI32) -> NonZeroI64
Converts NonZeroI32
to NonZeroI64
losslessly.
1.31.0 · source§impl From<NonZeroI32> for i32
impl From<NonZeroI32> for i32
source§fn from(nonzero: NonZeroI32) -> i32
fn from(nonzero: NonZeroI32) -> i32
Converts a NonZeroI32
into an i32
1.41.0 · source§impl From<NonZeroI8> for NonZeroI32
impl From<NonZeroI8> for NonZeroI32
source§fn from(small: NonZeroI8) -> NonZeroI32
fn from(small: NonZeroI8) -> NonZeroI32
Converts NonZeroI8
to NonZeroI32
losslessly.
1.41.0 · source§impl From<NonZeroU16> for NonZeroI32
impl From<NonZeroU16> for NonZeroI32
source§fn from(small: NonZeroU16) -> NonZeroI32
fn from(small: NonZeroU16) -> NonZeroI32
Converts NonZeroU16
to NonZeroI32
losslessly.
1.41.0 · source§impl From<NonZeroU8> for NonZeroI32
impl From<NonZeroU8> for NonZeroI32
source§fn from(small: NonZeroU8) -> NonZeroI32
fn from(small: NonZeroU8) -> NonZeroI32
Converts NonZeroU8
to NonZeroI32
losslessly.
1.35.0 · source§impl FromStr for NonZeroI32
impl FromStr for NonZeroI32
§type Err = ParseIntError
type Err = ParseIntError
source§fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>
fn from_str(src: &str) -> Result<NonZeroI32, <NonZeroI32 as FromStr>::Err>
s
to return a value of this type. Read moresource§impl Hash for NonZeroI32
impl Hash for NonZeroI32
§impl IntoVisitor for NonZeroI32where
BasicVisitor<NonZeroI32>: for<'scale, 'info> Visitor<Error = Error, Value<'scale, 'info> = NonZeroI32>,
impl IntoVisitor for NonZeroI32where
BasicVisitor<NonZeroI32>: for<'scale, 'info> Visitor<Error = Error, Value<'scale, 'info> = NonZeroI32>,
§type Visitor = BasicVisitor<NonZeroI32>
type Visitor = BasicVisitor<NonZeroI32>
Self
.§fn into_visitor() -> <NonZeroI32 as IntoVisitor>::Visitor
fn into_visitor() -> <NonZeroI32 as IntoVisitor>::Visitor
source§impl LowerHex for NonZeroI32
impl LowerHex for NonZeroI32
§impl MaxEncodedLen for NonZeroI32
impl MaxEncodedLen for NonZeroI32
§fn max_encoded_len() -> usize
fn max_encoded_len() -> usize
1.71.0 · source§impl Neg for &NonZeroI32
impl Neg for &NonZeroI32
1.71.0 · source§impl Neg for NonZeroI32
impl Neg for NonZeroI32
§type Output = NonZeroI32
type Output = NonZeroI32
-
operator.source§fn neg(self) -> NonZeroI32
fn neg(self) -> NonZeroI32
-
operation. Read moresource§impl Octal for NonZeroI32
impl Octal for NonZeroI32
source§impl Ord for NonZeroI32
impl Ord for NonZeroI32
source§fn cmp(&self, other: &NonZeroI32) -> Ordering
fn cmp(&self, other: &NonZeroI32) -> Ordering
source§fn max(self, other: NonZeroI32) -> NonZeroI32
fn max(self, other: NonZeroI32) -> NonZeroI32
source§fn min(self, other: NonZeroI32) -> NonZeroI32
fn min(self, other: NonZeroI32) -> NonZeroI32
source§fn clamp(self, min: NonZeroI32, max: NonZeroI32) -> NonZeroI32
fn clamp(self, min: NonZeroI32, max: NonZeroI32) -> NonZeroI32
source§impl PartialEq for NonZeroI32
impl PartialEq for NonZeroI32
source§fn eq(&self, other: &NonZeroI32) -> bool
fn eq(&self, other: &NonZeroI32) -> bool
self
and other
values to be equal, and is used
by ==
.source§fn ne(&self, other: &NonZeroI32) -> bool
fn ne(&self, other: &NonZeroI32) -> bool
!=
. The default implementation is almost always
sufficient, and should not be overridden without very good reason.source§impl PartialOrd for NonZeroI32
impl PartialOrd for NonZeroI32
source§fn partial_cmp(&self, other: &NonZeroI32) -> Option<Ordering>
fn partial_cmp(&self, other: &NonZeroI32) -> Option<Ordering>
source§fn lt(&self, other: &NonZeroI32) -> bool
fn lt(&self, other: &NonZeroI32) -> bool
source§fn le(&self, other: &NonZeroI32) -> bool
fn le(&self, other: &NonZeroI32) -> bool
self
and other
) and is used by the <=
operator. Read moresource§fn gt(&self, other: &NonZeroI32) -> bool
fn gt(&self, other: &NonZeroI32) -> bool
source§impl Serialize for NonZeroI32
impl Serialize for NonZeroI32
source§fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
1.49.0 · source§impl TryFrom<NonZeroI128> for NonZeroI32
impl TryFrom<NonZeroI128> for NonZeroI32
source§fn try_from(
value: NonZeroI128
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI128>>::Error>
fn try_from( value: NonZeroI128 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI128>>::Error>
Attempts to convert NonZeroI128
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroI16
impl TryFrom<NonZeroI32> for NonZeroI16
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroI16
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroI8
impl TryFrom<NonZeroI32> for NonZeroI8
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroI8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroIsize
impl TryFrom<NonZeroI32> for NonZeroIsize
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroIsize
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroU128
impl TryFrom<NonZeroI32> for NonZeroU128
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroU128
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroU16
impl TryFrom<NonZeroI32> for NonZeroU16
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroU16
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroU32
impl TryFrom<NonZeroI32> for NonZeroU32
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroU64
impl TryFrom<NonZeroI32> for NonZeroU64
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroU64
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroU8
impl TryFrom<NonZeroI32> for NonZeroU8
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroU8
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI32> for NonZeroUsize
impl TryFrom<NonZeroI32> for NonZeroUsize
source§fn try_from(
value: NonZeroI32
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI32>>::Error>
fn try_from( value: NonZeroI32 ) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI32>>::Error>
Attempts to convert NonZeroI32
to NonZeroUsize
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI64> for NonZeroI32
impl TryFrom<NonZeroI64> for NonZeroI32
source§fn try_from(
value: NonZeroI64
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI64>>::Error>
fn try_from( value: NonZeroI64 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI64>>::Error>
Attempts to convert NonZeroI64
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroIsize> for NonZeroI32
impl TryFrom<NonZeroIsize> for NonZeroI32
source§fn try_from(
value: NonZeroIsize
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroIsize>>::Error>
fn try_from( value: NonZeroIsize ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroIsize>>::Error>
Attempts to convert NonZeroIsize
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU128> for NonZeroI32
impl TryFrom<NonZeroU128> for NonZeroI32
source§fn try_from(
value: NonZeroU128
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU128>>::Error>
fn try_from( value: NonZeroU128 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU128>>::Error>
Attempts to convert NonZeroU128
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU32> for NonZeroI32
impl TryFrom<NonZeroU32> for NonZeroI32
source§fn try_from(
value: NonZeroU32
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU32>>::Error>
fn try_from( value: NonZeroU32 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU32>>::Error>
Attempts to convert NonZeroU32
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU64> for NonZeroI32
impl TryFrom<NonZeroU64> for NonZeroI32
source§fn try_from(
value: NonZeroU64
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU64>>::Error>
fn try_from( value: NonZeroU64 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU64>>::Error>
Attempts to convert NonZeroU64
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroUsize> for NonZeroI32
impl TryFrom<NonZeroUsize> for NonZeroI32
source§fn try_from(
value: NonZeroUsize
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroUsize>>::Error>
fn try_from( value: NonZeroUsize ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroUsize>>::Error>
Attempts to convert NonZeroUsize
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.46.0 · source§impl TryFrom<i32> for NonZeroI32
impl TryFrom<i32> for NonZeroI32
source§fn try_from(
value: i32
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<i32>>::Error>
fn try_from( value: i32 ) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<i32>>::Error>
Attempts to convert i32
to NonZeroI32
.
§type Error = TryFromIntError
type Error = TryFromIntError
§impl TypeInfo for NonZeroI32
impl TypeInfo for NonZeroI32
source§impl UpperHex for NonZeroI32
impl UpperHex for NonZeroI32
§impl Value for NonZeroI32
impl Value for NonZeroI32
§impl Zeroize for NonZeroI32
impl Zeroize for NonZeroI32
impl ConstEncodedLen for NonZeroI32
impl Copy for NonZeroI32
impl Eq for NonZeroI32
impl StructuralEq for NonZeroI32
impl StructuralPartialEq for NonZeroI32
Auto Trait Implementations§
impl RefUnwindSafe for NonZeroI32
impl Send for NonZeroI32
impl Sync for NonZeroI32
impl Unpin for NonZeroI32
impl UnwindSafe for NonZeroI32
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> CallHasher for T
impl<T> CallHasher for T
§impl<T> CheckedConversion for T
impl<T> CheckedConversion for T
§fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
§fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> DecodeAsType for Twhere
T: IntoVisitor,
Error: From<<<T as IntoVisitor>::Visitor as Visitor>::Error>,
impl<T> DecodeAsType for Twhere
T: IntoVisitor,
Error: From<<<T as IntoVisitor>::Visitor as Visitor>::Error>,
fn decode_as_type_maybe_compact( input: &mut &[u8], type_id: u32, types: &PortableRegistry, is_compact: bool ) -> Result<T, Error>
§fn decode_as_type(
input: &mut &[u8],
type_id: u32,
types: &PortableRegistry
) -> Result<Self, Error>
fn decode_as_type( input: &mut &[u8], type_id: u32, types: &PortableRegistry ) -> Result<Self, Error>
type_id
, and type registry, attempt to decode said bytes into
Self
. Implementations should modify the &mut
reference to the bytes such that any bytes
not used in the course of decoding are still pointed to after decoding is complete.§impl<T> DecodeLimit for Twhere
T: Decode,
impl<T> DecodeLimit for Twhere
T: Decode,
§impl<T> DecodeWithMetadata for Twhere
T: DecodeAsType,
impl<T> DecodeWithMetadata for Twhere
T: DecodeAsType,
§fn decode_with_metadata(
bytes: &mut &[u8],
type_id: u32,
metadata: &Metadata
) -> Result<T, Error>
fn decode_with_metadata( bytes: &mut &[u8], type_id: u32, metadata: &Metadata ) -> Result<T, Error>
Self
.§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> EncodeWithMetadata for Twhere
T: EncodeAsType,
impl<T> EncodeWithMetadata for Twhere
T: EncodeAsType,
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> FromBits<T> for T
impl<T> FromBits<T> for T
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T, Outer> IsWrappedBy<Outer> for T
impl<T, Outer> IsWrappedBy<Outer> for T
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
§fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
§fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
T
. Read more§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.§impl<T> TryConv for T
impl<T> TryConv for T
§impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
§fn unchecked_into(self) -> T
fn unchecked_into(self) -> T
unchecked_from
.§impl<T, S> UniqueSaturatedInto<T> for S
impl<T, S> UniqueSaturatedInto<T> for S
§fn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
T
.