From 812c83a2b16c7d97c5e5250ebfd785da4e089895 Mon Sep 17 00:00:00 2001 From: Kornel Date: Thu, 26 Jan 2023 17:00:12 +0000 Subject: [PATCH] Use 16-bit lengths on 16-bit targets --- src/array_string.rs | 4 ++-- src/arrayvec.rs | 4 ++-- src/lib.rs | 9 ++++++++- tests/tests.rs | 9 +++------ 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/array_string.rs b/src/array_string.rs index 6833237..227e01d 100644 --- a/src/array_string.rs +++ b/src/array_string.rs @@ -27,8 +27,8 @@ use serde::{Serialize, Deserialize, Serializer, Deserializer}; /// The `ArrayString` is a string backed by a fixed size array. It keeps track /// of its length, and is parameterized by `CAP` for the maximum capacity. /// -/// `CAP` is of type `usize` but is range limited to `u32::MAX`; attempting to create larger -/// arrayvecs with larger capacity will panic. +/// `CAP` is of type `usize` but is range limited to `u32::MAX` (or `u16` on 16-bit targets); +/// attempting to create larger arrayvecs with larger capacity will panic. /// /// The string is a contiguous value that you can store directly on the stack /// if needed. diff --git a/src/arrayvec.rs b/src/arrayvec.rs index 840bcd5..e5ea52d 100644 --- a/src/arrayvec.rs +++ b/src/arrayvec.rs @@ -31,8 +31,8 @@ use crate::utils::MakeMaybeUninit; /// the number of initialized elements. The `ArrayVec` is parameterized /// by `T` for the element type and `CAP` for the maximum capacity. /// -/// `CAP` is of type `usize` but is range limited to `u32::MAX`; attempting to create larger -/// arrayvecs with larger capacity will panic. +/// `CAP` is of type `usize` but is range limited to `u32::MAX` (or `u16::MAX` on 16-bit targets); +/// attempting to create larger arrayvecs with larger capacity will panic. /// /// The vector is a contiguous value (storing the elements inline) that you can store directly on /// the stack if needed. diff --git a/src/lib.rs b/src/lib.rs index f9a2fe6..5c4bcee 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,13 +28,20 @@ extern crate serde; #[cfg(not(feature="std"))] extern crate core as std; +#[cfg(not(target_pointer_width = "16"))] pub(crate) type LenUint = u32; +#[cfg(target_pointer_width = "16")] +pub(crate) type LenUint = u16; + macro_rules! assert_capacity_limit { ($cap:expr) => { if std::mem::size_of::() > std::mem::size_of::() { if $cap > LenUint::MAX as usize { - panic!("ArrayVec: largest supported capacity is u32::MAX") + #[cfg(not(target_pointer_width = "16"))] + panic!("ArrayVec: largest supported capacity is u32::MAX"); + #[cfg(target_pointer_width = "16")] + panic!("ArrayVec: largest supported capacity is u16::MAX"); } } } diff --git a/tests/tests.rs b/tests/tests.rs index 16508b7..ff779ba 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -680,6 +680,7 @@ fn test_pop_at() { } #[test] +#[cfg(not(target_pointer_width = "16"))] fn test_sizes() { let v = ArrayVec::from([0u8; 1 << 16]); assert_eq!(vec![0u8; v.len()], &v[..]); @@ -729,21 +730,17 @@ fn allow_max_capacity_arrayvec_type() { } #[should_panic(expected="largest supported capacity")] +#[cfg(not(target_pointer_width = "16"))] #[test] fn deny_max_capacity_arrayvec_value() { - if mem::size_of::() <= mem::size_of::() { - panic!("This test does not work on this platform. 'largest supported capacity'"); - } // this type is allowed to be used (but can't be constructed) let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new(); } #[should_panic(expected="index out of bounds")] +#[cfg(not(target_pointer_width = "16"))] #[test] fn deny_max_capacity_arrayvec_value_const() { - if mem::size_of::() <= mem::size_of::() { - panic!("This test does not work on this platform. 'index out of bounds'"); - } // this type is allowed to be used (but can't be constructed) let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new_const(); }