Merge pull request #68 from WalterSmuts/master

Raise str buffer size checking to type level

benches/bench.rs

@@ -20,7 +20,7 @@ fn bench_to_str(b: &mut Bencher) {
  let ulid = Ulid::new();
  b.iter(|| {
  let mut buffer = [0; ULID_LEN];
- ulid.to_str(&mut buffer).unwrap();
+ ulid.array_to_str(&mut buffer);
  });
 }
 

src/base32.rs

@@ -57,6 +57,10 @@ impl fmt::Display for EncodeError {
 }
 
 /// Encode a u128 value to a given buffer. The provided buffer should be at least `ULID_LEN` long.
+#[deprecated(
+ since = "1.2.0",
+ note = "Use the infallible `encode_to_array` instead."
+)]
 pub fn encode_to(mut value: u128, buffer: &mut [u8]) -> Result<usize, EncodeError> {
  // NOTE: This function can't be made const because mut refs aren't allowed for some reason
 
@@ -72,11 +76,21 @@ pub fn encode_to(mut value: u128, buffer: &mut [u8]) -> Result<usize, EncodeErro
  Ok(ULID_LEN)
 }
 
+/// Encode a u128 value to a given buffer.
+pub fn encode_to_array(mut value: u128, buffer: &mut [u8; ULID_LEN]) {
+ // NOTE: This function can't be made const because mut refs aren't allowed for some reason
+
+ for i in 0..ULID_LEN {
+ buffer[ULID_LEN - 1 - i] = ALPHABET[(value & 0x1f) as usize];
+ value >>= 5;
+ }
+}
+
 #[cfg(feature = "std")]
 pub fn encode(value: u128) -> String {
  let mut buffer: [u8; ULID_LEN] = [0; ULID_LEN];
 
- encode_to(value, &mut buffer).expect("unexpected encoding error");
+ encode_to_array(value, &mut buffer);
 
  String::from_utf8(buffer.to_vec()).expect("unexpected failure in base32 encode for ulid")
 }

src/lib.rs

@@ -190,11 +190,32 @@ impl Ulid {
  ///
  /// assert_eq!(new_text, text);
  /// ```
+ #[deprecated(since = "1.2.0", note = "Use the infallible `array_to_str` instead.")]
  pub fn to_str<'buf>(&self, buf: &'buf mut [u8]) -> Result<&'buf mut str, EncodeError> {
+ #[allow(deprecated)]
  let len = base32::encode_to(self.0, buf)?;
  Ok(unsafe { core::str::from_utf8_unchecked_mut(&mut buf[..len]) })
  }
 
+ /// Creates a Crockford Base32 encoded string that represents this Ulid
+ ///
+ /// # Example
+ /// ```rust
+ /// use ulid::Ulid;
+ ///
+ /// let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
+ /// let ulid = Ulid::from_string(text).unwrap();
+ ///
+ /// let mut buf = [0; ulid::ULID_LEN];
+ /// let new_text = ulid.array_to_str(&mut buf);
+ ///
+ /// assert_eq!(new_text, text);
+ /// ```
+ pub fn array_to_str<'buf>(&self, buf: &'buf mut [u8; ULID_LEN]) -> &'buf mut str {
+ base32::encode_to_array(self.0, buf);
+ unsafe { core::str::from_utf8_unchecked_mut(buf) }
+ }
+
  /// Creates a Crockford Base32 encoded string that represents this Ulid
  ///
  /// # Example
@@ -336,7 +357,7 @@ impl FromStr for Ulid {
 impl fmt::Display for Ulid {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  let mut buffer = [0; ULID_LEN];
- write!(f, "{}", self.to_str(&mut buffer).unwrap())
+ write!(f, "{}", self.array_to_str(&mut buffer))
  }
 }
 

src/serde.rs

@@ -15,7 +15,7 @@ impl Serialize for Ulid {
  S: Serializer,
  {
  let mut buffer = [0; ULID_LEN];
- let text = self.to_str(&mut buffer).unwrap();
+ let text = self.array_to_str(&mut buffer);
  text.serialize(serializer)
  }
 }