mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #85679 - hch12907:master, r=Mark-Simulacrum

Browse Source 
Remove num_as_ne_bytes feature

From the discussion in #76976, it is determined that eventual results of the safe transmute work as a more general mechanism will let these conversions happen in safe code without needing specialized methods.

Merging this PR closes #76976 and resolves #64464. Several T-libs members have raised their opinion that it doesn't pull its weight as a standalone method, and so we should not track it as a specific thing to add.
This commit is contained in:
Dylan DPC 2021-05-26 13:32:11 +02:00 committed by GitHub
commit f3b10dd709
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
library/core/src/num/f32.rs
View File

@ -854,35 +854,6 @@ pub const fn from_bits(v: u32) -> Self {
self.to_bits().to_ne_bytes()
}
/// Return the memory representation of this floating point number as a byte array in
/// native byte order.
///
/// [`to_ne_bytes`] should be preferred over this whenever possible.
///
/// [`to_ne_bytes`]: f32::to_ne_bytes
///
/// # Examples
///
/// ```
/// #![feature(num_as_ne_bytes)]
/// let num = 12.5f32;
/// let bytes = num.as_ne_bytes();
/// assert_eq!(
/// bytes,
/// if cfg!(target_endian = "big") {
/// &[0x41, 0x48, 0x00, 0x00]
/// } else {
/// &[0x00, 0x00, 0x48, 0x41]
/// }
/// );
/// ```
#[unstable(feature = "num_as_ne_bytes", issue = "76976")]
#[inline]
pub fn as_ne_bytes(&self) -> &[u8; 4] {
// SAFETY: `f32` is a plain old datatype so we can always transmute to it
unsafe { &*(self as *const Self as *const _) }
}
/// Create a floating point value from its representation as a byte array in big endian.
///
/// # Examples

29
library/core/src/num/f64.rs
View File

@ -868,35 +868,6 @@ pub const fn from_bits(v: u64) -> Self {
self.to_bits().to_ne_bytes()
}
/// Return the memory representation of this floating point number as a byte array in
/// native byte order.
///
/// [`to_ne_bytes`] should be preferred over this whenever possible.
///
/// [`to_ne_bytes`]: f64::to_ne_bytes
///
/// # Examples
///
/// ```
/// #![feature(num_as_ne_bytes)]
/// let num = 12.5f64;
/// let bytes = num.as_ne_bytes();
/// assert_eq!(
/// bytes,
/// if cfg!(target_endian = "big") {
/// &[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
/// } else {
/// &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
/// }
/// );
/// ```
#[unstable(feature = "num_as_ne_bytes", issue = "76976")]
#[inline]
pub fn as_ne_bytes(&self) -> &[u8; 8] {
// SAFETY: `f64` is a plain old datatype so we can always transmute to it
unsafe { &*(self as *const Self as *const _) }
}
/// Create a floating point value from its representation as a byte array in big endian.
///
/// # Examples

30
library/core/src/num/int_macros.rs
View File

@ -1842,36 +1842,6 @@ pub const fn is_negative(self) -> bool { self < 0 }
unsafe { mem::transmute(self) }
}
/// Return the memory representation of this integer as a byte array in
/// native byte order.
///
/// [`to_ne_bytes`] should be preferred over this whenever possible.
///
/// [`to_ne_bytes`]: Self::to_ne_bytes
///
/// # Examples
///
/// ```
/// #![feature(num_as_ne_bytes)]
#[doc = concat!("let num = ", $swap_op, stringify!($SelfT), ";")]
/// let bytes = num.as_ne_bytes();
/// assert_eq!(
/// bytes,
/// if cfg!(target_endian = "big") {
#[doc = concat!(" &", $be_bytes)]
/// } else {
#[doc = concat!(" &", $le_bytes)]
/// }
/// );
/// ```
#[unstable(feature = "num_as_ne_bytes", issue = "76976")]
#[inline]
pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
// SAFETY: integers are plain old datatypes so we can always transmute them to
// arrays of bytes
unsafe { &*(self as *const Self as *const _) }
}
/// Create an integer value from its representation as a byte array in
/// big endian.
///

30
library/core/src/num/uint_macros.rs
View File

@ -1672,36 +1672,6 @@ pub const fn wrapping_next_power_of_two(self) -> Self {
unsafe { mem::transmute(self) }
}
/// Return the memory representation of this integer as a byte array in
/// native byte order.
///
/// [`to_ne_bytes`] should be preferred over this whenever possible.
///
/// [`to_ne_bytes`]: Self::to_ne_bytes
///
/// # Examples
///
/// ```
/// #![feature(num_as_ne_bytes)]
#[doc = concat!("let num = ", $swap_op, stringify!($SelfT), ";")]
/// let bytes = num.as_ne_bytes();
/// assert_eq!(
/// bytes,
/// if cfg!(target_endian = "big") {
#[doc = concat!(" &", $be_bytes)]
/// } else {
#[doc = concat!(" &", $le_bytes)]
/// }
/// );
/// ```
#[unstable(feature = "num_as_ne_bytes", issue = "76976")]
#[inline]
pub fn as_ne_bytes(&self) -> &[u8; mem::size_of::<Self>()] {
// SAFETY: integers are plain old datatypes so we can always transmute them to
// arrays of bytes
unsafe { &*(self as *const Self as *const _) }
}
/// Create a native endian integer value from its representation
/// as a byte array in big endian.
///