Move Wrapping<T> definition to wrapping mod
This commit is contained in:
parent
baecad9c39
commit
7125a481ce
2 changed files with 82 additions and 75 deletions
|
@ -34,79 +34,6 @@ macro_rules! doc_comment {
|
|||
};
|
||||
}
|
||||
|
||||
/// Provides intentionally-wrapped arithmetic on `T`.
|
||||
///
|
||||
/// Operations like `+` on `u32` values are intended to never overflow,
|
||||
/// and in some debug configurations overflow is detected and results
|
||||
/// in a panic. While most arithmetic falls into this category, some
|
||||
/// code explicitly expects and relies upon modular arithmetic (e.g.,
|
||||
/// hashing).
|
||||
///
|
||||
/// Wrapping arithmetic can be achieved either through methods like
|
||||
/// `wrapping_add`, or through the `Wrapping<T>` type, which says that
|
||||
/// all standard arithmetic operations on the underlying value are
|
||||
/// intended to have wrapping semantics.
|
||||
///
|
||||
/// The underlying value can be retrieved through the `.0` index of the
|
||||
/// `Wrapping` tuple.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::num::Wrapping;
|
||||
///
|
||||
/// let zero = Wrapping(0u32);
|
||||
/// let one = Wrapping(1u32);
|
||||
///
|
||||
/// assert_eq!(u32::MAX, (zero - one).0);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]
|
||||
#[repr(transparent)]
|
||||
pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")] pub T);
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: fmt::Debug> fmt::Debug for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_display", since = "1.10.0")]
|
||||
impl<T: fmt::Display> fmt::Display for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::Binary> fmt::Binary for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::Octal> fmt::Octal for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::LowerHex> fmt::LowerHex for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::UpperHex> fmt::UpperHex for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
// All these modules are technically private and only exposed for coretests:
|
||||
pub mod bignum;
|
||||
pub mod dec2flt;
|
||||
|
@ -116,6 +43,9 @@ pub mod flt2dec;
|
|||
mod nonzero;
|
||||
mod wrapping;
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub use wrapping::Wrapping;
|
||||
|
||||
#[stable(feature = "nonzero", since = "1.28.0")]
|
||||
pub use nonzero::{NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
|
||||
|
||||
|
|
|
@ -1,6 +1,83 @@
|
|||
use super::Wrapping;
|
||||
//! Definitions of `Wrapping<T>`.
|
||||
|
||||
use crate::ops::*;
|
||||
use crate::fmt;
|
||||
use crate::ops::{Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign};
|
||||
use crate::ops::{BitXor, BitXorAssign, Div, DivAssign};
|
||||
use crate::ops::{Mul, MulAssign, Neg, Not, Rem, RemAssign};
|
||||
use crate::ops::{Shl, ShlAssign, Shr, ShrAssign, Sub, SubAssign};
|
||||
|
||||
/// Provides intentionally-wrapped arithmetic on `T`.
|
||||
///
|
||||
/// Operations like `+` on `u32` values are intended to never overflow,
|
||||
/// and in some debug configurations overflow is detected and results
|
||||
/// in a panic. While most arithmetic falls into this category, some
|
||||
/// code explicitly expects and relies upon modular arithmetic (e.g.,
|
||||
/// hashing).
|
||||
///
|
||||
/// Wrapping arithmetic can be achieved either through methods like
|
||||
/// `wrapping_add`, or through the `Wrapping<T>` type, which says that
|
||||
/// all standard arithmetic operations on the underlying value are
|
||||
/// intended to have wrapping semantics.
|
||||
///
|
||||
/// The underlying value can be retrieved through the `.0` index of the
|
||||
/// `Wrapping` tuple.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use std::num::Wrapping;
|
||||
///
|
||||
/// let zero = Wrapping(0u32);
|
||||
/// let one = Wrapping(1u32);
|
||||
///
|
||||
/// assert_eq!(u32::MAX, (zero - one).0);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]
|
||||
#[repr(transparent)]
|
||||
pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")] pub T);
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: fmt::Debug> fmt::Debug for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_display", since = "1.10.0")]
|
||||
impl<T: fmt::Display> fmt::Display for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::Binary> fmt::Binary for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::Octal> fmt::Octal for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::LowerHex> fmt::LowerHex for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "wrapping_fmt", since = "1.11.0")]
|
||||
impl<T: fmt::UpperHex> fmt::UpperHex for Wrapping<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(unused_macros)]
|
||||
macro_rules! sh_impl_signed {
|
||||
|
|
Loading…
Reference in a new issue