feat(bytestring): split_at method (#619)

bytestring/CHANGES.md

@@ -2,7 +2,10 @@
 
 ## Unreleased
 
-- Minimum supported Rust version (MSRV) is now 1.70.
+## 1.4.0
+
+- Add `ByteString::split_at()` method.
+- Minimum supported Rust version (MSRV) is now 1.71.
 
 ## 1.3.1
 

bytestring/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "bytestring"
-version = "1.3.1"
+version = "1.4.0"
 description = "A UTF-8 encoded read-only string using `Bytes` as storage"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
 ]
-keywords = ["string", "bytes", "utf8", "web", "actix"]
+keywords = ["string", "bytes", "utf8", "web", "bytestring"]
 categories = ["no-std", "web-programming"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net"

bytestring/README.md

@@ -5,11 +5,11 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/bytestring?label=latest)](https://crates.io/crates/bytestring)
-[![Documentation](https://docs.rs/bytestring/badge.svg?version=1.3.1)](https://docs.rs/bytestring/1.3.1)
+[![Documentation](https://docs.rs/bytestring/badge.svg?version=1.4.0)](https://docs.rs/bytestring/1.4.0)
 [![Version](https://img.shields.io/badge/rustc-1.52+-ab6000.svg)](https://blog.rust-lang.org/2021/05/06/Rust-1.52.0.html)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/bytestring.svg)
 <br />
-[![Dependency Status](https://deps.rs/crate/bytestring/1.3.1/status.svg)](https://deps.rs/crate/bytestring/1.3.1)
+[![Dependency Status](https://deps.rs/crate/bytestring/1.4.0/status.svg)](https://deps.rs/crate/bytestring/1.4.0)
 ![Download](https://img.shields.io/crates/d/bytestring.svg)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 

bytestring/src/lib.rs

@@ -17,7 +17,7 @@ use core::{borrow::Borrow, fmt, hash, ops, str};
 
 use bytes::Bytes;
 
-/// An immutable UTF-8 encoded string with [`Bytes`] as a storage.
+/// An immutable UTF-8 encoded string using [`Bytes`] as the storage.
 #[derive(Clone, Default, Eq, PartialOrd, Ord)]
 pub struct ByteString(Bytes);
 
@@ -53,7 +53,29 @@ impl ByteString {
         Self(src)
     }
 
-    /// Returns a new byte string that is equivalent to the given `subset`.
+    /// Divides one bytestring into two at an index, returning both parts.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `mid` is not on a UTF-8 code point boundary, or if it is past the end of the last
+    /// code point of the bytestring.
+    pub fn split_at(&self, mid: usize) -> (ByteString, ByteString) {
+        let this: &str = self.as_ref();
+        let _valid_midpoint_check = this.split_at(mid);
+
+        let mut bytes = self.0.clone();
+        let first = bytes.split_to(mid);
+        let last = bytes;
+
+        unsafe {
+            (
+                ByteString::from_bytes_unchecked(first),
+                ByteString::from_bytes_unchecked(last),
+            )
+        }
+    }
+
+    /// Returns a new `ByteString` that is equivalent to the given `subset`.
     ///
     /// When processing a `ByteString` buffer with other tools, one often gets a `&str` which is in
     /// fact a slice of the original `ByteString`; i.e., a subset of it. This function turns that
@@ -465,4 +487,33 @@ mod test {
         // being a logical subset of the string
         ByteString::from_static("foo bar").slice_ref("foo");
     }
+
+    #[test]
+    fn split_at() {
+        let buf = ByteString::from_static("foo bar");
+
+        let (first, last) = buf.split_at(0);
+        assert_eq!(ByteString::from_static(""), first);
+        assert_eq!(ByteString::from_static("foo bar"), last);
+
+        let (first, last) = buf.split_at(4);
+        assert_eq!(ByteString::from_static("foo "), first);
+        assert_eq!(ByteString::from_static("bar"), last);
+
+        let (first, last) = buf.split_at(7);
+        assert_eq!(ByteString::from_static("foo bar"), first);
+        assert_eq!(ByteString::from_static(""), last);
+    }
+
+    #[test]
+    #[should_panic = "byte index 1 is not a char boundary;"]
+    fn split_at_invalid_code_point() {
+        ByteString::from_static("µ").split_at(1);
+    }
+
+    #[test]
+    #[should_panic = "byte index 9 is out of bounds"]
+    fn split_at_outside_string() {
+        ByteString::from_static("foo").split_at(9);
+    }
 }