Skip to content

Commit

Permalink
[ref] Change some Ref constructor names
Browse files Browse the repository at this point in the history 
Makes progress on #871
  • Loading branch information
@joshlf
joshlf committed May 10, 2024
1 parent f8057e9 commit e3ac3eb
Show file tree
Hide file tree
Showing 4 changed files with 120 additions and 120 deletions.
12 changes: 6 additions & 6 deletions src/deprecated.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,7 @@ where
#[doc(hidden)]
#[inline]
pub fn new_slice(bytes: B) -> Option<Ref<B, [T]>> {
Self::new(bytes).ok()
Self::from(bytes).ok()
}
}

Expand All @@ -34,7 +34,7 @@ where
#[doc(hidden)]
#[inline(always)]
pub fn new_slice_unaligned(bytes: B) -> Option<Ref<B, [T]>> {
Ref::new_unaligned(bytes).ok()
Ref::unaligned_from(bytes).ok()
}
}

Expand Down Expand Up @@ -74,15 +74,15 @@ where
#[doc(hidden)]
#[inline]
pub fn new_slice_from_prefix(bytes: B, count: usize) -> Option<(Ref<B, [T]>, B)> {
Ref::with_trailing_elements_from_prefix(bytes, count).ok()
Ref::from_prefix_with_elems(bytes, count).ok()
}

#[deprecated(since = "0.8.0", note = "replaced by `Ref::with_trailing_elements_from_suffix`")]
#[must_use = "has no side effects"]
#[doc(hidden)]
#[inline]
pub fn new_slice_from_suffix(bytes: B, count: usize) -> Option<(B, Ref<B, [T]>)> {
Ref::with_trailing_elements_from_suffix(bytes, count).ok()
Ref::from_suffix_with_elems(bytes, count).ok()
}
}

Expand All @@ -99,7 +99,7 @@ where
#[must_use = "has no side effects"]
#[inline(always)]
pub fn new_slice_unaligned_from_prefix(bytes: B, count: usize) -> Option<(Ref<B, [T]>, B)> {
Ref::with_trailing_elements_unaligned_from_prefix(bytes, count).ok()
Ref::unaligned_from_prefix_with_elems(bytes, count).ok()
}

#[deprecated(
Expand All @@ -110,6 +110,6 @@ where
#[must_use = "has no side effects"]
#[inline(always)]
pub fn new_slice_unaligned_from_suffix(bytes: B, count: usize) -> Option<(B, Ref<B, [T]>)> {
Ref::with_trailing_elements_unaligned_from_suffix(bytes, count).ok()
Ref::unaligned_from_suffix_with_elems(bytes, count).ok()
}
}
4 changes: 2 additions & 2 deletions src/error.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,8 +7,8 @@
//! - [`SizeError`]: the conversion source was of incorrect size
//! - [`ValidityError`]: the conversion source contained invalid data
//!
//! Methods that only have one failure mode, like [`Ref::new_unaligned`], return
//! that mode's corresponding error type directly.
//! Methods that only have one failure mode, like [`Ref::unaligned_from`],
//! return that mode's corresponding error type directly.
//!
//! ## Compound errors
//!
Expand Down
114 changes: 53 additions & 61 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3091,7 +3091,7 @@ pub unsafe trait FromBytes: FromZeros {
where
Self: Sized,
{
match Ref::<_, Unalign<Self>>::new_sized(bytes) {
match Ref::<_, Unalign<Self>>::sized_from(bytes) {
Ok(r) => Ok(r.read().into_inner()),
Err(CastError::Size(e)) => Err(e.with_dst()),
Err(CastError::Alignment(_)) => unreachable!(),
Expand Down Expand Up @@ -3136,7 +3136,7 @@ pub unsafe trait FromBytes: FromZeros {
where
Self: Sized,
{
match Ref::<_, Unalign<Self>>::new_sized_from_prefix(bytes) {
match Ref::<_, Unalign<Self>>::sized_from_prefix(bytes) {
Ok((r, _)) => Ok(r.read().into_inner()),
Err(CastError::Size(e)) => Err(e.with_dst()),
Err(CastError::Alignment(_)) => unreachable!(),
Expand Down Expand Up @@ -3175,7 +3175,7 @@ pub unsafe trait FromBytes: FromZeros {
where
Self: Sized,
{
match Ref::<_, Unalign<Self>>::new_sized_from_suffix(bytes) {
match Ref::<_, Unalign<Self>>::sized_from_suffix(bytes) {
Ok((_, r)) => Ok(r.read().into_inner()),
Err(CastError::Size(e)) => Err(CastError::Size(e.with_dst())),
Err(CastError::Alignment(_)) => unreachable!(),
Expand Down Expand Up @@ -7225,13 +7225,13 @@ mod tests {
// reference which points to the right region of memory.

let buf = [0];
let r = Ref::<_, u8>::new(&buf[..]).unwrap();
let r = Ref::<_, u8>::from(&buf[..]).unwrap();
let buf_ptr = buf.as_ptr();
let deref_ptr: *const u8 = r.deref();
assert_eq!(buf_ptr, deref_ptr);

let buf = [0];
let r = Ref::<_, [u8]>::new(&buf[..]).unwrap();
let r = Ref::<_, [u8]>::from(&buf[..]).unwrap();
let buf_ptr = buf.as_ptr();
let deref_ptr = r.deref().as_ptr();
assert_eq!(buf_ptr, deref_ptr);
Expand Down Expand Up @@ -7353,17 +7353,17 @@ mod tests {
// A buffer with an alignment of 8.
let mut buf = Align::<[u8; 8], AU64>::default();
// `buf.t` should be aligned to 8, so this should always succeed.
test_new_helper(Ref::<_, AU64>::new(&mut buf.t[..]).unwrap());
test_new_helper(Ref::<_, AU64>::from(&mut buf.t[..]).unwrap());
{
// In a block so that `r` and `suffix` don't live too long.
buf.set_default();
let (r, suffix) = Ref::<_, AU64>::new_from_prefix(&mut buf.t[..]).unwrap();
let (r, suffix) = Ref::<_, AU64>::from_prefix(&mut buf.t[..]).unwrap();
assert!(suffix.is_empty());
test_new_helper(r);
}
{
buf.set_default();
let (prefix, r) = Ref::<_, AU64>::new_from_suffix(&mut buf.t[..]).unwrap();
let (prefix, r) = Ref::<_, AU64>::from_suffix(&mut buf.t[..]).unwrap();
assert!(prefix.is_empty());
test_new_helper(r);
}
Expand All @@ -7376,7 +7376,7 @@ mod tests {
let mut buf = Align::<[u8; 24], AU64>::default();
// `buf.t` should be aligned to 8 and have a length which is a multiple
// of `size_of::<AU64>()`, so this should always succeed.
test_new_helper_slice(Ref::<_, [AU64]>::new(&mut buf.t[..]).unwrap(), 3);
test_new_helper_slice(Ref::<_, [AU64]>::from(&mut buf.t[..]).unwrap(), 3);
let ascending: [u8; 24] = (0..24).collect::<Vec<_>>().try_into().unwrap();
// 16 ascending bytes followed by 8 zeros.
let mut ascending_prefix = ascending;
Expand All @@ -7387,15 +7387,13 @@ mod tests {

{
buf.t = ascending_suffix;
let (r, suffix) =
Ref::<_, [AU64]>::with_trailing_elements_from_prefix(&mut buf.t[..], 1).unwrap();
let (r, suffix) = Ref::<_, [AU64]>::from_prefix_with_elems(&mut buf.t[..], 1).unwrap();
assert_eq!(suffix, &ascending[8..]);
test_new_helper_slice(r, 1);
}
{
buf.t = ascending_prefix;
let (prefix, r) =
Ref::<_, [AU64]>::with_trailing_elements_from_suffix(&mut buf.t[..], 1).unwrap();
let (prefix, r) = Ref::<_, [AU64]>::from_suffix_with_elems(&mut buf.t[..], 1).unwrap();
assert_eq!(prefix, &ascending[..16]);
test_new_helper_slice(r, 1);
}
Expand All @@ -7411,39 +7409,37 @@ mod tests {
// for `new_slice`.

let mut buf = [0u8; 8];
test_new_helper_unaligned(Ref::<_, [u8; 8]>::new_unaligned(&mut buf[..]).unwrap());
test_new_helper_unaligned(Ref::<_, [u8; 8]>::unaligned_from(&mut buf[..]).unwrap());
{
// In a block so that `r` and `suffix` don't live too long.
buf = [0u8; 8];
let (r, suffix) = Ref::<_, [u8; 8]>::new_unaligned_from_prefix(&mut buf[..]).unwrap();
let (r, suffix) = Ref::<_, [u8; 8]>::unaligned_from_prefix(&mut buf[..]).unwrap();
assert!(suffix.is_empty());
test_new_helper_unaligned(r);
}
{
buf = [0u8; 8];
let (prefix, r) = Ref::<_, [u8; 8]>::new_unaligned_from_suffix(&mut buf[..]).unwrap();
let (prefix, r) = Ref::<_, [u8; 8]>::unaligned_from_suffix(&mut buf[..]).unwrap();
assert!(prefix.is_empty());
test_new_helper_unaligned(r);
}

let mut buf = [0u8; 16];
// `buf.t` should be aligned to 8 and have a length which is a multiple
// of `size_of::AU64>()`, so this should always succeed.
test_new_helper_slice_unaligned(Ref::<_, [u8]>::new_unaligned(&mut buf[..]).unwrap(), 16);
test_new_helper_slice_unaligned(Ref::<_, [u8]>::unaligned_from(&mut buf[..]).unwrap(), 16);

{
buf = [0u8; 16];
let (r, suffix) =
Ref::<_, [u8]>::with_trailing_elements_unaligned_from_prefix(&mut buf[..], 8)
.unwrap();
Ref::<_, [u8]>::unaligned_from_prefix_with_elems(&mut buf[..], 8).unwrap();
assert_eq!(suffix, [0; 8]);
test_new_helper_slice_unaligned(r, 8);
}
{
buf = [0u8; 16];
let (prefix, r) =
Ref::<_, [u8]>::with_trailing_elements_unaligned_from_suffix(&mut buf[..], 8)
.unwrap();
Ref::<_, [u8]>::unaligned_from_suffix_with_elems(&mut buf[..], 8).unwrap();
assert_eq!(prefix, [0; 8]);
test_new_helper_slice_unaligned(r, 8);
}
Expand All @@ -7459,14 +7455,14 @@ mod tests {
{
// In a block so that `r` and `suffix` don't live too long. `buf.t`
// should be aligned to 8, so this should always succeed.
let (r, suffix) = Ref::<_, AU64>::new_from_prefix(&mut buf.t[..]).unwrap();
let (r, suffix) = Ref::<_, AU64>::from_prefix(&mut buf.t[..]).unwrap();
assert_eq!(suffix.len(), 8);
test_new_helper(r);
}
{
buf.set_default();
// `buf.t` should be aligned to 8, so this should always succeed.
let (prefix, r) = Ref::<_, AU64>::new_from_suffix(&mut buf.t[..]).unwrap();
let (prefix, r) = Ref::<_, AU64>::from_suffix(&mut buf.t[..]).unwrap();
assert_eq!(prefix.len(), 8);
test_new_helper(r);
}
Expand All @@ -7481,13 +7477,13 @@ mod tests {
let mut buf = [0u8; 16];
{
// In a block so that `r` and `suffix` don't live too long.
let (r, suffix) = Ref::<_, [u8; 8]>::new_unaligned_from_prefix(&mut buf[..]).unwrap();
let (r, suffix) = Ref::<_, [u8; 8]>::unaligned_from_prefix(&mut buf[..]).unwrap();
assert_eq!(suffix.len(), 8);
test_new_helper_unaligned(r);
}
{
buf = [0u8; 16];
let (prefix, r) = Ref::<_, [u8; 8]>::new_unaligned_from_suffix(&mut buf[..]).unwrap();
let (prefix, r) = Ref::<_, [u8; 8]>::unaligned_from_suffix(&mut buf[..]).unwrap();
assert_eq!(prefix.len(), 8);
test_new_helper_unaligned(r);
}
Expand Down Expand Up @@ -7575,38 +7571,36 @@ mod tests {
// A buffer with an alignment of 8.
let buf = Align::<[u8; 16], AU64>::default();
// `buf.t` should be aligned to 8, so only the length check should fail.
assert!(Ref::<_, AU64>::new(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::new_unaligned(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::from(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::unaligned_from(&buf.t[..]).is_err());

// Fail because the buffer is too small.

// A buffer with an alignment of 8.
let buf = Align::<[u8; 4], AU64>::default();
// `buf.t` should be aligned to 8, so only the length check should fail.
assert!(Ref::<_, AU64>::new(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::new_unaligned(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::new_from_prefix(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::new_from_suffix(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::new_unaligned_from_prefix(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::new_unaligned_from_suffix(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::from(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::unaligned_from(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::from_prefix(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::from_suffix(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::unaligned_from_prefix(&buf.t[..]).is_err());
assert!(Ref::<_, [u8; 8]>::unaligned_from_suffix(&buf.t[..]).is_err());

// Fail because the length is not a multiple of the element size.

let buf = Align::<[u8; 12], AU64>::default();
// `buf.t` has length 12, but element size is 8.
assert!(Ref::<_, [AU64]>::new(&buf.t[..]).is_err());
assert!(Ref::<_, [[u8; 8]]>::new_unaligned(&buf.t[..]).is_err());
assert!(Ref::<_, [AU64]>::from(&buf.t[..]).is_err());
assert!(Ref::<_, [[u8; 8]]>::unaligned_from(&buf.t[..]).is_err());

// Fail because the buffer is too short.
let buf = Align::<[u8; 12], AU64>::default();
// `buf.t` has length 12, but the element size is 8 (and we're expecting
// two of them).
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_prefix(&buf.t[..], 2).is_err());
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_suffix(&buf.t[..], 2).is_err());
assert!(Ref::<_, [[u8; 8]]>::with_trailing_elements_unaligned_from_prefix(&buf.t[..], 2)
.is_err());
assert!(Ref::<_, [[u8; 8]]>::with_trailing_elements_unaligned_from_suffix(&buf.t[..], 2)
.is_err());
assert!(Ref::<_, [AU64]>::from_prefix_with_elems(&buf.t[..], 2).is_err());
assert!(Ref::<_, [AU64]>::from_suffix_with_elems(&buf.t[..], 2).is_err());
assert!(Ref::<_, [[u8; 8]]>::unaligned_from_prefix_with_elems(&buf.t[..], 2).is_err());
assert!(Ref::<_, [[u8; 8]]>::unaligned_from_suffix_with_elems(&buf.t[..], 2).is_err());

// Fail because the alignment is insufficient.

Expand All @@ -7615,29 +7609,27 @@ mod tests {
let buf = Align::<[u8; 13], AU64>::default();
// Slicing from 1, we get a buffer with size 12 (so the length check
// should succeed) but an alignment of only 1, which is insufficient.
assert!(Ref::<_, AU64>::new(&buf.t[1..]).is_err());
assert!(Ref::<_, AU64>::new_from_prefix(&buf.t[1..]).is_err());
assert!(Ref::<_, [AU64]>::new(&buf.t[1..]).is_err());
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_prefix(&buf.t[1..], 1).is_err());
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_suffix(&buf.t[1..], 1).is_err());
assert!(Ref::<_, AU64>::from(&buf.t[1..]).is_err());
assert!(Ref::<_, AU64>::from_prefix(&buf.t[1..]).is_err());
assert!(Ref::<_, [AU64]>::from(&buf.t[1..]).is_err());
assert!(Ref::<_, [AU64]>::from_prefix_with_elems(&buf.t[1..], 1).is_err());
assert!(Ref::<_, [AU64]>::from_suffix_with_elems(&buf.t[1..], 1).is_err());
// Slicing is unnecessary here because `new_from_suffix` uses the suffix
// of the slice, which has odd alignment.
assert!(Ref::<_, AU64>::new_from_suffix(&buf.t[..]).is_err());
assert!(Ref::<_, AU64>::from_suffix(&buf.t[..]).is_err());

// Fail due to arithmetic overflow.

let buf = Align::<[u8; 16], AU64>::default();
let unreasonable_len = usize::MAX / mem::size_of::<AU64>() + 1;
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_prefix(&buf.t[..], unreasonable_len)
.is_err());
assert!(Ref::<_, [AU64]>::with_trailing_elements_from_suffix(&buf.t[..], unreasonable_len)
.is_err());
assert!(Ref::<_, [[u8; 8]]>::with_trailing_elements_unaligned_from_prefix(
assert!(Ref::<_, [AU64]>::from_prefix_with_elems(&buf.t[..], unreasonable_len).is_err());
assert!(Ref::<_, [AU64]>::from_suffix_with_elems(&buf.t[..], unreasonable_len).is_err());
assert!(Ref::<_, [[u8; 8]]>::unaligned_from_prefix_with_elems(
&buf.t[..],
unreasonable_len
)
.is_err());
assert!(Ref::<_, [[u8; 8]]>::with_trailing_elements_unaligned_from_suffix(
assert!(Ref::<_, [[u8; 8]]>::unaligned_from_suffix_with_elems(
&buf.t[..],
unreasonable_len
)
Expand Down Expand Up @@ -7754,39 +7746,39 @@ mod tests {
#[test]
fn test_display_debug() {
let buf = Align::<[u8; 8], u64>::default();
let r = Ref::<_, u64>::new(&buf.t[..]).unwrap();
let r = Ref::<_, u64>::from(&buf.t[..]).unwrap();
assert_eq!(format!("{}", r), "0");
assert_eq!(format!("{:?}", r), "Ref(0)");

let buf = Align::<[u8; 8], u64>::default();
let r = Ref::<_, [u64]>::new(&buf.t[..]).unwrap();
let r = Ref::<_, [u64]>::from(&buf.t[..]).unwrap();
assert_eq!(format!("{:?}", r), "Ref([0])");
}

#[test]
fn test_eq() {
let buf1 = 0_u64;
let r1 = Ref::<_, u64>::new(buf1.as_bytes()).unwrap();
let r1 = Ref::<_, u64>::from(buf1.as_bytes()).unwrap();
let buf2 = 0_u64;
let r2 = Ref::<_, u64>::new(buf2.as_bytes()).unwrap();
let r2 = Ref::<_, u64>::from(buf2.as_bytes()).unwrap();
assert_eq!(r1, r2);
}

#[test]
fn test_ne() {
let buf1 = 0_u64;
let r1 = Ref::<_, u64>::new(buf1.as_bytes()).unwrap();
let r1 = Ref::<_, u64>::from(buf1.as_bytes()).unwrap();
let buf2 = 1_u64;
let r2 = Ref::<_, u64>::new(buf2.as_bytes()).unwrap();
let r2 = Ref::<_, u64>::from(buf2.as_bytes()).unwrap();
assert_ne!(r1, r2);
}

#[test]
fn test_ord() {
let buf1 = 0_u64;
let r1 = Ref::<_, u64>::new(buf1.as_bytes()).unwrap();
let r1 = Ref::<_, u64>::from(buf1.as_bytes()).unwrap();
let buf2 = 1_u64;
let r2 = Ref::<_, u64>::new(buf2.as_bytes()).unwrap();
let r2 = Ref::<_, u64>::from(buf2.as_bytes()).unwrap();
assert!(r1 < r2);
}

Expand Down
Loading

0 comments on commit e3ac3eb

Please sign in to comment.