#![cfg_attr(not(feature = "std"), no_std)]
#![allow(unknown_lints)]
#![allow(clippy::needless_doctest_main)]
mod lib {
mod core {
#[cfg(feature = "std")]
pub use std::*;
#[cfg(not(feature = "std"))]
pub use core::*;
}
pub use self::core::num::{
NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize,
};
pub use self::core::num::{
NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
};
}
use self::lib::*;
pub mod literals;
macro_rules! impl_nonzeroness {
($trait_name:ident, $nonzero_type:ty, $wrapped:ty) => {
impl $trait_name for $nonzero_type {
type Primitive = $wrapped;
#[inline]
#[cfg_attr(feature = "cargo-clippy", allow(clippy::new_ret_no_self))]
fn new(n: $wrapped) -> Option<Self> {
Self::new(n)
}
#[inline]
fn get(self) -> Self::Primitive {
<$nonzero_type>::get(self)
}
}
};
}
pub trait NonZero {
type Primitive;
fn new(n: Self::Primitive) -> Option<Self>
where
Self: Sized;
fn get(self) -> Self::Primitive;
}
impl_nonzeroness!(NonZero, NonZeroU8, u8);
impl_nonzeroness!(NonZero, NonZeroU16, u16);
impl_nonzeroness!(NonZero, NonZeroU32, u32);
impl_nonzeroness!(NonZero, NonZeroU64, u64);
impl_nonzeroness!(NonZero, NonZeroU128, u128);
impl_nonzeroness!(NonZero, NonZeroUsize, usize);
impl_nonzeroness!(NonZero, NonZeroI8, i8);
impl_nonzeroness!(NonZero, NonZeroI16, i16);
impl_nonzeroness!(NonZero, NonZeroI32, i32);
impl_nonzeroness!(NonZero, NonZeroI64, i64);
impl_nonzeroness!(NonZero, NonZeroI128, i128);
impl_nonzeroness!(NonZero, NonZeroIsize, isize);
pub trait NonZeroAble {
type NonZero: NonZero;
#[deprecated(since = "0.2.0", note = "Renamed to `into_nonzero`")]
#[allow(clippy::wrong_self_convention)]
fn as_nonzero(self) -> Option<Self::NonZero>
where
Self: Sized,
{
self.into_nonzero()
}
fn into_nonzero(self) -> Option<Self::NonZero>;
#[deprecated(since = "0.2.0", note = "Renamed to `into_nonzero_unchecked`")]
#[allow(clippy::wrong_self_convention)]
unsafe fn as_nonzero_unchecked(self) -> Self::NonZero
where
Self: Sized,
{
self.into_nonzero_unchecked()
}
unsafe fn into_nonzero_unchecked(self) -> Self::NonZero;
}
macro_rules! impl_nonzeroable {
($trait_name:ident, $nonzero_type: ty, $nonzeroable_type:ty) => {
impl $trait_name for $nonzeroable_type {
type NonZero = $nonzero_type;
fn into_nonzero(self) -> Option<$nonzero_type> {
Self::NonZero::new(self)
}
unsafe fn into_nonzero_unchecked(self) -> $nonzero_type {
Self::NonZero::new_unchecked(self)
}
}
impl literals::NonZeroLiteral<$nonzeroable_type> {
pub const unsafe fn into_nonzero(self) -> $nonzero_type {
<$nonzero_type>::new_unchecked(self.0)
}
}
impl literals::sealed::IntegerLiteral for $nonzeroable_type {}
};
}
impl_nonzeroable!(NonZeroAble, NonZeroU8, u8);
impl_nonzeroable!(NonZeroAble, NonZeroU16, u16);
impl_nonzeroable!(NonZeroAble, NonZeroU32, u32);
impl_nonzeroable!(NonZeroAble, NonZeroU64, u64);
impl_nonzeroable!(NonZeroAble, NonZeroU128, u128);
impl_nonzeroable!(NonZeroAble, NonZeroUsize, usize);
impl_nonzeroable!(NonZeroAble, NonZeroI8, i8);
impl_nonzeroable!(NonZeroAble, NonZeroI16, i16);
impl_nonzeroable!(NonZeroAble, NonZeroI32, i32);
impl_nonzeroable!(NonZeroAble, NonZeroI64, i64);
impl_nonzeroable!(NonZeroAble, NonZeroI128, i128);
impl_nonzeroable!(NonZeroAble, NonZeroIsize, isize);
#[macro_export]
macro_rules! nonzero {
($n:expr) => {{
#[allow(unknown_lints, eq_op)]
let _ = [(); ($n.count_ones() as usize) - 1];
let lit = $crate::literals::NonZeroLiteral($n);
unsafe { lit.into_nonzero() }
}};
}