Struct rocket_governor::NonZeroU32
1.28.0 · source · pub struct NonZeroU32(/* private fields */);
Expand description
An integer that is known not to equal zero.
This enables some memory layout optimization.
For example, Option<NonZeroU32>
is the same size as u32
:
use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroU32>>(), size_of::<u32>());
Layout
NonZeroU32
is guaranteed to have the same layout and bit validity as u32
with the exception that 0
is not a valid instance.
Option<NonZeroU32>
is guaranteed to be compatible with u32
,
including in FFI.
Thanks to the null pointer optimization,
NonZeroU32
and Option<NonZeroU32>
are guaranteed to have the same size and alignment:
use std::num::NonZeroU32;
assert_eq!(size_of::<NonZeroU32>(), size_of::<Option<NonZeroU32>>());
assert_eq!(align_of::<NonZeroU32>(), align_of::<Option<NonZeroU32>>());
Implementations§
source§impl NonZeroU32
impl NonZeroU32
const: 1.28.0 · sourcepub const unsafe fn new_unchecked(n: u32) -> NonZeroU32
pub const unsafe fn new_unchecked(n: u32) -> NonZeroU32
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: u32) -> Option<NonZeroU32>
pub const fn new(n: u32) -> Option<NonZeroU32>
Creates a non-zero if the given value is not zero.
source§impl NonZeroU32
impl NonZeroU32
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::NonZeroU32::new(u32::MAX).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::NonZeroU32::new(0b0101000).unwrap();
assert_eq!(n.trailing_zeros(), 3);
source§impl NonZeroU32
impl NonZeroU32
1.64.0 (const: 1.64.0) · sourcepub const fn checked_add(self, other: u32) -> Option<NonZeroU32>
pub const fn checked_add(self, other: u32) -> Option<NonZeroU32>
Adds an unsigned integer to a non-zero value.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
Examples
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
1.64.0 (const: 1.64.0) · sourcepub const fn saturating_add(self, other: u32) -> NonZeroU32
pub const fn saturating_add(self, other: u32) -> NonZeroU32
Adds an unsigned integer to a non-zero value.
Return NonZeroU32::MAX
on overflow.
Examples
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
sourcepub const unsafe fn unchecked_add(self, other: u32) -> NonZeroU32
🔬This is a nightly-only experimental API. (nonzero_ops
)
pub const unsafe fn unchecked_add(self, other: u32) -> NonZeroU32
nonzero_ops
)Adds an unsigned integer to a non-zero value,
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 > u32::MAX
.
Examples
#![feature(nonzero_ops)]
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
1.64.0 (const: 1.64.0) · sourcepub const fn checked_next_power_of_two(self) -> Option<NonZeroU32>
pub const fn checked_next_power_of_two(self) -> Option<NonZeroU32>
Returns the smallest power of two greater than or equal to n.
Checks for overflow and returns None
if the next power of two is greater than the type’s maximum value.
As a consequence, the result cannot wrap to zero.
Examples
let two = NonZeroU32::new(2)?;
let three = NonZeroU32::new(3)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );
1.67.0 (const: 1.67.0) · sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u32::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
Examples
assert_eq!(NonZeroU32::new(7).unwrap().ilog2(), 2);
assert_eq!(NonZeroU32::new(8).unwrap().ilog2(), 3);
assert_eq!(NonZeroU32::new(9).unwrap().ilog2(), 3);
1.67.0 (const: 1.67.0) · sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u32::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
Examples
assert_eq!(NonZeroU32::new(99).unwrap().ilog10(), 1);
assert_eq!(NonZeroU32::new(100).unwrap().ilog10(), 2);
assert_eq!(NonZeroU32::new(101).unwrap().ilog10(), 2);
const: unstable · sourcepub fn midpoint(self, rhs: NonZeroU32) -> NonZeroU32
🔬This is a nightly-only experimental API. (num_midpoint
)
pub fn midpoint(self, rhs: NonZeroU32) -> NonZeroU32
num_midpoint
)Calculates the middle point of self
and rhs
.
midpoint(a, b)
is (a + b) >> 1
as if it were performed in a
sufficiently-large signed integral type. This implies that the result is
always rounded towards negative infinity and that no overflow will ever occur.
Examples
#![feature(num_midpoint)]
let one = NonZeroU32::new(1)?;
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
source§impl NonZeroU32
impl NonZeroU32
1.64.0 (const: 1.64.0) · sourcepub const fn checked_mul(self, other: NonZeroU32) -> Option<NonZeroU32>
pub const fn checked_mul(self, other: NonZeroU32) -> Option<NonZeroU32>
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 = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::new(u32::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: NonZeroU32) -> NonZeroU32
pub const fn saturating_mul(self, other: NonZeroU32) -> NonZeroU32
Multiplies two non-zero integers together.
Return NonZeroU32::MAX
on overflow.
Examples
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::new(4)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
sourcepub const unsafe fn unchecked_mul(self, other: NonZeroU32) -> NonZeroU32
🔬This is a nightly-only experimental API. (nonzero_ops
)
pub const unsafe fn unchecked_mul(self, other: NonZeroU32) -> NonZeroU32
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 > u32::MAX
.
Examples
#![feature(nonzero_ops)]
let two = NonZeroU32::new(2)?;
let four = NonZeroU32::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<NonZeroU32>
pub const fn checked_pow(self, other: u32) -> Option<NonZeroU32>
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 = NonZeroU32::new(3)?;
let twenty_seven = NonZeroU32::new(27)?;
let half_max = NonZeroU32::new(u32::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) -> NonZeroU32
pub const fn saturating_pow(self, other: u32) -> NonZeroU32
Raise non-zero value to an integer power.
Return NonZeroU32::MAX
on overflow.
Examples
let three = NonZeroU32::new(3)?;
let twenty_seven = NonZeroU32::new(27)?;
let max = NonZeroU32::new(u32::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
source§impl NonZeroU32
impl NonZeroU32
1.59.0 (const: 1.59.0) · sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
Returns true
if and only if self == (1 << k)
for some k
.
On many architectures, this function can perform better than is_power_of_two()
on the underlying integer type, as special handling of zero can be avoided.
Examples
Basic usage:
let eight = std::num::NonZeroU32::new(8).unwrap();
assert!(eight.is_power_of_two());
let ten = std::num::NonZeroU32::new(10).unwrap();
assert!(!ten.is_power_of_two());
source§impl NonZeroU32
impl NonZeroU32
1.70.0 · sourcepub const MIN: NonZeroU32 = _
pub const MIN: NonZeroU32 = _
The smallest value that can be represented by this non-zero integer type, 1.
Examples
assert_eq!(NonZeroU32::MIN.get(), 1u32);
1.70.0 · sourcepub const MAX: NonZeroU32 = _
pub const MAX: NonZeroU32 = _
Trait Implementations§
source§impl Binary for NonZeroU32
impl Binary for NonZeroU32
1.45.0 · source§impl BitOr<u32> for NonZeroU32
impl BitOr<u32> for NonZeroU32
1.45.0 · source§impl BitOr for NonZeroU32
impl BitOr for NonZeroU32
§type Output = NonZeroU32
type Output = NonZeroU32
|
operator.source§fn bitor(self, rhs: NonZeroU32) -> <NonZeroU32 as BitOr>::Output
fn bitor(self, rhs: NonZeroU32) -> <NonZeroU32 as BitOr>::Output
|
operation. Read more1.45.0 · source§impl BitOrAssign<u32> for NonZeroU32
impl BitOrAssign<u32> for NonZeroU32
source§fn bitor_assign(&mut self, rhs: u32)
fn bitor_assign(&mut self, rhs: u32)
|=
operation. Read more1.45.0 · source§impl BitOrAssign for NonZeroU32
impl BitOrAssign for NonZeroU32
source§fn bitor_assign(&mut self, rhs: NonZeroU32)
fn bitor_assign(&mut self, rhs: NonZeroU32)
|=
operation. Read more§impl CheckedBitPattern for NonZeroU32
impl CheckedBitPattern for NonZeroU32
§type Bits = u32
type Bits = u32
Self
must have the same layout as the specified Bits
except for
the possible invalid bit patterns being checked during
is_valid_bit_pattern
.§fn is_valid_bit_pattern(bits: &<NonZeroU32 as CheckedBitPattern>::Bits) -> bool
fn is_valid_bit_pattern(bits: &<NonZeroU32 as CheckedBitPattern>::Bits) -> bool
bits
as &Self
.source§impl Clone for NonZeroU32
impl Clone for NonZeroU32
source§fn clone(&self) -> NonZeroU32
fn clone(&self) -> NonZeroU32
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Contiguous for NonZeroU32
impl Contiguous for NonZeroU32
§fn from_integer(value: Self::Int) -> Option<Self>
fn from_integer(value: Self::Int) -> Option<Self>
value
is within the range for valid instances of this type,
returns Some(converted_value)
, otherwise, returns None
. Read more§fn into_integer(self) -> Self::Int
fn into_integer(self) -> Self::Int
C
into the underlying integral type. This
mostly exists otherwise generic code would need unsafe for the value as integer
Read moresource§impl Debug for NonZeroU32
impl Debug for NonZeroU32
source§impl<'de> Deserialize<'de> for NonZeroU32
impl<'de> Deserialize<'de> for NonZeroU32
source§fn deserialize<D>(
deserializer: D
) -> Result<NonZeroU32, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D
) -> Result<NonZeroU32, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl Display for NonZeroU32
impl Display for NonZeroU32
1.41.0 · source§impl From<NonZeroU16> for NonZeroU32
impl From<NonZeroU16> for NonZeroU32
source§fn from(small: NonZeroU16) -> NonZeroU32
fn from(small: NonZeroU16) -> NonZeroU32
Converts NonZeroU16
to NonZeroU32
losslessly.
1.41.0 · source§impl From<NonZeroU8> for NonZeroU32
impl From<NonZeroU8> for NonZeroU32
source§fn from(small: NonZeroU8) -> NonZeroU32
fn from(small: NonZeroU8) -> NonZeroU32
Converts NonZeroU8
to NonZeroU32
losslessly.
source§impl<'v> FromFormField<'v> for NonZeroU32
impl<'v> FromFormField<'v> for NonZeroU32
source§fn from_value(field: ValueField<'v>) -> Result<NonZeroU32, Errors<'v>>
fn from_value(field: ValueField<'v>) -> Result<NonZeroU32, Errors<'v>>
T
from a form value field. Read moresource§impl<'a> FromParam<'a> for NonZeroU32
impl<'a> FromParam<'a> for NonZeroU32
source§fn from_param(
param: &'a str
) -> Result<NonZeroU32, <NonZeroU32 as FromParam<'a>>::Error>
fn from_param( param: &'a str ) -> Result<NonZeroU32, <NonZeroU32 as FromParam<'a>>::Error>
Self
from a path parameter string
or returns an Error
if parsing or validation fails.1.35.0 · source§impl FromStr for NonZeroU32
impl FromStr for NonZeroU32
§type Err = ParseIntError
type Err = ParseIntError
source§fn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>
fn from_str(src: &str) -> Result<NonZeroU32, <NonZeroU32 as FromStr>::Err>
s
to return a value of this type. Read more§impl<'x, P> FromUriParam<P, &'x NonZeroU32> for NonZeroU32where
P: Part,
impl<'x, P> FromUriParam<P, &'x NonZeroU32> for NonZeroU32where
P: Part,
§type Target = &'x NonZeroU32
type Target = &'x NonZeroU32
§fn from_uri_param(param: &'x NonZeroU32) -> &'x NonZeroU32
fn from_uri_param(param: &'x NonZeroU32) -> &'x NonZeroU32
T
into a value of type Self::Target
. The
resulting value of type Self::Target
will be rendered into a URI using
its [UriDisplay
] implementation.§impl<'x, P> FromUriParam<P, &'x mut NonZeroU32> for NonZeroU32where
P: Part,
impl<'x, P> FromUriParam<P, &'x mut NonZeroU32> for NonZeroU32where
P: Part,
§type Target = &'x mut NonZeroU32
type Target = &'x mut NonZeroU32
§fn from_uri_param(param: &'x mut NonZeroU32) -> &'x mut NonZeroU32
fn from_uri_param(param: &'x mut NonZeroU32) -> &'x mut NonZeroU32
T
into a value of type Self::Target
. The
resulting value of type Self::Target
will be rendered into a URI using
its [UriDisplay
] implementation.§impl<P> FromUriParam<P, NonZeroU32> for NonZeroU32where
P: Part,
impl<P> FromUriParam<P, NonZeroU32> for NonZeroU32where
P: Part,
§type Target = NonZeroU32
type Target = NonZeroU32
§fn from_uri_param(param: NonZeroU32) -> NonZeroU32
fn from_uri_param(param: NonZeroU32) -> NonZeroU32
T
into a value of type Self::Target
. The
resulting value of type Self::Target
will be rendered into a URI using
its [UriDisplay
] implementation.source§impl Hash for NonZeroU32
impl Hash for NonZeroU32
source§impl LowerHex for NonZeroU32
impl LowerHex for NonZeroU32
§impl NonZero for NonZeroU32
impl NonZero for NonZeroU32
source§impl Octal for NonZeroU32
impl Octal for NonZeroU32
source§impl Ord for NonZeroU32
impl Ord for NonZeroU32
source§fn cmp(&self, other: &NonZeroU32) -> Ordering
fn cmp(&self, other: &NonZeroU32) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl PartialEq for NonZeroU32
impl PartialEq for NonZeroU32
source§fn eq(&self, other: &NonZeroU32) -> bool
fn eq(&self, other: &NonZeroU32) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialOrd for NonZeroU32
impl PartialOrd for NonZeroU32
source§fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>
fn partial_cmp(&self, other: &NonZeroU32) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl Serialize for NonZeroU32
impl Serialize for NonZeroU32
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 NonZeroU32
impl TryFrom<NonZeroI128> for NonZeroU32
source§fn try_from(
value: NonZeroI128
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI128>>::Error>
fn try_from( value: NonZeroI128 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI128>>::Error>
Attempts to convert NonZeroI128
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI16> for NonZeroU32
impl TryFrom<NonZeroI16> for NonZeroU32
source§fn try_from(
value: NonZeroI16
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI16>>::Error>
fn try_from( value: NonZeroI16 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI16>>::Error>
Attempts to convert NonZeroI16
to NonZeroU32
.
§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<NonZeroI64> for NonZeroU32
impl TryFrom<NonZeroI64> for NonZeroU32
source§fn try_from(
value: NonZeroI64
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI64>>::Error>
fn try_from( value: NonZeroI64 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI64>>::Error>
Attempts to convert NonZeroI64
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroI8> for NonZeroU32
impl TryFrom<NonZeroI8> for NonZeroU32
source§fn try_from(
value: NonZeroI8
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI8>>::Error>
fn try_from( value: NonZeroI8 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI8>>::Error>
Attempts to convert NonZeroI8
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroIsize> for NonZeroU32
impl TryFrom<NonZeroIsize> for NonZeroU32
source§fn try_from(
value: NonZeroIsize
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroIsize>>::Error>
fn try_from( value: NonZeroIsize ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroIsize>>::Error>
Attempts to convert NonZeroIsize
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU128> for NonZeroU32
impl TryFrom<NonZeroU128> for NonZeroU32
source§fn try_from(
value: NonZeroU128
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU128>>::Error>
fn try_from( value: NonZeroU128 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU128>>::Error>
Attempts to convert NonZeroU128
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroU64> for NonZeroU32
impl TryFrom<NonZeroU64> for NonZeroU32
source§fn try_from(
value: NonZeroU64
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU64>>::Error>
fn try_from( value: NonZeroU64 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU64>>::Error>
Attempts to convert NonZeroU64
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.49.0 · source§impl TryFrom<NonZeroUsize> for NonZeroU32
impl TryFrom<NonZeroUsize> for NonZeroU32
source§fn try_from(
value: NonZeroUsize
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroUsize>>::Error>
fn try_from( value: NonZeroUsize ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroUsize>>::Error>
Attempts to convert NonZeroUsize
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
1.46.0 · source§impl TryFrom<u32> for NonZeroU32
impl TryFrom<u32> for NonZeroU32
source§fn try_from(
value: u32
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<u32>>::Error>
fn try_from( value: u32 ) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<u32>>::Error>
Attempts to convert u32
to NonZeroU32
.
§type Error = TryFromIntError
type Error = TryFromIntError
source§impl UpperHex for NonZeroU32
impl UpperHex for NonZeroU32
§impl<P> UriDisplay<P> for NonZeroU32where
P: Part,
impl<P> UriDisplay<P> for NonZeroU32where
P: Part,
This implementation is identical to the Display
implementation.
§impl Value for NonZeroU32
impl Value for NonZeroU32
impl Copy for NonZeroU32
impl Eq for NonZeroU32
impl NoUninit for NonZeroU32
impl PodInOption for NonZeroU32
impl StructuralEq for NonZeroU32
impl StructuralPartialEq for NonZeroU32
impl ZeroableInOption for NonZeroU32
Auto Trait Implementations§
impl RefUnwindSafe for NonZeroU32
impl Send for NonZeroU32
impl Sync for NonZeroU32
impl Unpin for NonZeroU32
impl UnwindSafe for NonZeroU32
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<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§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.source§impl<'v, T> FromForm<'v> for Twhere
T: FromFormField<'v>,
impl<'v, T> FromForm<'v> for Twhere
T: FromFormField<'v>,
source§fn init(opts: Options) -> <T as FromForm<'v>>::Context
fn init(opts: Options) -> <T as FromForm<'v>>::Context
Self
.source§fn push_value(ctxt: &mut <T as FromForm<'v>>::Context, field: ValueField<'v>)
fn push_value(ctxt: &mut <T as FromForm<'v>>::Context, field: ValueField<'v>)
field
.source§fn push_data<'life0, 'life1, 'async_trait>(
ctxt: &'life0 mut FromFieldContext<'v, T>,
field: DataField<'v, 'life1>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'v: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
T: 'async_trait,
fn push_data<'life0, 'life1, 'async_trait>(
ctxt: &'life0 mut FromFieldContext<'v, T>,
field: DataField<'v, 'life1>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'v: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
T: 'async_trait,
field
.source§fn finalize(ctxt: <T as FromForm<'v>>::Context) -> Result<T, Errors<'v>>
fn finalize(ctxt: <T as FromForm<'v>>::Context) -> Result<T, Errors<'v>>
Errors
otherwise.§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> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
§fn into_collection<A>(self) -> SmallVec<A>where
A: Array<Item = T>,
fn into_collection<A>(self) -> SmallVec<A>where
A: Array<Item = T>,
self
into a collection.fn mapped<U, F, A>(self, f: F) -> SmallVec<A>where
F: FnMut(T) -> U,
A: Array<Item = U>,
§impl<T> Paint for Twhere
T: ?Sized,
impl<T> Paint for Twhere
T: ?Sized,
§fn fg(&self, value: Color) -> Painted<&T>
fn fg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the foreground set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like red()
and
green()
, which have the same functionality but are
pithier.
Example
Set foreground color to white using fg()
:
use yansi::{Paint, Color};
painted.fg(Color::White);
Set foreground color to white using white()
.
use yansi::Paint;
painted.white();
§fn bright_black(&self) -> Painted<&T>
fn bright_black(&self) -> Painted<&T>
§fn bright_red(&self) -> Painted<&T>
fn bright_red(&self) -> Painted<&T>
§fn bright_green(&self) -> Painted<&T>
fn bright_green(&self) -> Painted<&T>
§fn bright_yellow(&self) -> Painted<&T>
fn bright_yellow(&self) -> Painted<&T>
§fn bright_blue(&self) -> Painted<&T>
fn bright_blue(&self) -> Painted<&T>
§fn bright_magenta(&self) -> Painted<&T>
fn bright_magenta(&self) -> Painted<&T>
§fn bright_cyan(&self) -> Painted<&T>
fn bright_cyan(&self) -> Painted<&T>
§fn bright_white(&self) -> Painted<&T>
fn bright_white(&self) -> Painted<&T>
§fn bg(&self, value: Color) -> Painted<&T>
fn bg(&self, value: Color) -> Painted<&T>
Returns a styled value derived from self
with the background set to
value
.
This method should be used rarely. Instead, prefer to use color-specific
builder methods like on_red()
and
on_green()
, which have the same functionality but
are pithier.
Example
Set background color to red using fg()
:
use yansi::{Paint, Color};
painted.bg(Color::Red);
Set background color to red using on_red()
.
use yansi::Paint;
painted.on_red();
§fn on_primary(&self) -> Painted<&T>
fn on_primary(&self) -> Painted<&T>
§fn on_magenta(&self) -> Painted<&T>
fn on_magenta(&self) -> Painted<&T>
§fn on_bright_black(&self) -> Painted<&T>
fn on_bright_black(&self) -> Painted<&T>
§fn on_bright_red(&self) -> Painted<&T>
fn on_bright_red(&self) -> Painted<&T>
§fn on_bright_green(&self) -> Painted<&T>
fn on_bright_green(&self) -> Painted<&T>
§fn on_bright_yellow(&self) -> Painted<&T>
fn on_bright_yellow(&self) -> Painted<&T>
§fn on_bright_blue(&self) -> Painted<&T>
fn on_bright_blue(&self) -> Painted<&T>
§fn on_bright_magenta(&self) -> Painted<&T>
fn on_bright_magenta(&self) -> Painted<&T>
§fn on_bright_cyan(&self) -> Painted<&T>
fn on_bright_cyan(&self) -> Painted<&T>
§fn on_bright_white(&self) -> Painted<&T>
fn on_bright_white(&self) -> Painted<&T>
§fn attr(&self, value: Attribute) -> Painted<&T>
fn attr(&self, value: Attribute) -> Painted<&T>
Enables the styling [Attribute
] value
.
This method should be used rarely. Instead, prefer to use
attribute-specific builder methods like bold()
and
underline()
, which have the same functionality
but are pithier.
Example
Make text bold using attr()
:
use yansi::{Paint, Attribute};
painted.attr(Attribute::Bold);
Make text bold using using bold()
.
use yansi::Paint;
painted.bold();
§fn rapid_blink(&self) -> Painted<&T>
fn rapid_blink(&self) -> Painted<&T>
§fn quirk(&self, value: Quirk) -> Painted<&T>
fn quirk(&self, value: Quirk) -> Painted<&T>
Enables the yansi
[Quirk
] value
.
This method should be used rarely. Instead, prefer to use quirk-specific
builder methods like mask()
and
wrap()
, which have the same functionality but are
pithier.
Example
Enable wrapping using .quirk()
:
use yansi::{Paint, Quirk};
painted.quirk(Quirk::Wrap);
Enable wrapping using wrap()
.
use yansi::Paint;
painted.wrap();
§fn whenever(&self, value: Condition) -> Painted<&T>
fn whenever(&self, value: Condition) -> Painted<&T>
Conditionally enable styling based on whether the [Condition
] value
applies. Replaces any previous condition.
See the crate level docs for more details.
Example
Enable styling painted
only when both stdout
and stderr
are TTYs:
use yansi::{Paint, Condition};
painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);