Adjust [Pattern] implementation

src/pattern.rs

@@ -1,30 +1,33 @@
 use super::private;
 
-pub trait Encoder {
-    fn __encode(&mut self) -> &[u8];
+pub trait Encoded {
+    fn __get(&self) -> &[u8];
 }
 
-pub struct ByteEncoder([u8; 1]);
+pub struct EncodedByte([u8; 1]);
 
-impl Encoder for ByteEncoder {
-    fn __encode(&mut self) -> &[u8] {
+impl Encoded for EncodedByte {
+    #[inline]
+    fn __get(&self) -> &[u8] {
         &self.0
     }
 }
 
-pub struct CharEncoder {
+pub struct EncodedChar {
     buffer: [u8; 4],
-    ch: char,
+    length: usize,
 }
 
-impl Encoder for CharEncoder {
-    fn __encode(&mut self) -> &[u8] {
-        self.ch.encode_utf8(&mut self.buffer).as_bytes()
+impl Encoded for EncodedChar {
+    #[inline]
+    fn __get(&self) -> &[u8] {
+        &self.buffer[..self.length]
     }
 }
 
-impl Encoder for &str {
-    fn __encode(&mut self) -> &[u8] {
+impl Encoded for &str {
+    #[inline]
+    fn __get(&self) -> &[u8] {
         self.as_bytes()
     }
 }
@@ -40,53 +43,55 @@ impl Encoder for &str {
 #[cfg_attr(os_str_bytes_docs_rs, doc(cfg(feature = "raw_os_str")))]
 pub trait Pattern: private::Sealed {
     #[doc(hidden)]
-    type __Encoder: Encoder;
+    type __Encoded: Encoded;
 
     #[doc(hidden)]
-    fn __into_encoder(self) -> Self::__Encoder;
+    fn __encode(self) -> Self::__Encoded;
 }
 
 impl Pattern for char {
     #[doc(hidden)]
-    type __Encoder = CharEncoder;
+    type __Encoded = EncodedChar;
 
     #[doc(hidden)]
-    fn __into_encoder(self) -> Self::__Encoder {
-        CharEncoder {
+    fn __encode(self) -> Self::__Encoded {
+        let mut encoded = EncodedChar {
             buffer: [0; 4],
-            ch: self,
-        }
+            length: 0,
+        };
+        encoded.length = self.encode_utf8(&mut encoded.buffer).len();
+        encoded
     }
 }
 
 impl Pattern for &str {
     #[doc(hidden)]
-    type __Encoder = Self;
+    type __Encoded = Self;
 
     #[doc(hidden)]
-    fn __into_encoder(self) -> Self::__Encoder {
+    fn __encode(self) -> Self::__Encoded {
         self
     }
 }
 
 impl<'a> Pattern for &'a String {
     #[doc(hidden)]
-    type __Encoder = &'a str;
+    type __Encoded = <&'a str as Pattern>::__Encoded;
 
     #[doc(hidden)]
-    fn __into_encoder(self) -> Self::__Encoder {
-        self
+    fn __encode(self) -> Self::__Encoded {
+        (**self).__encode()
     }
 }
 
 impl Pattern for u8 {
     #[doc(hidden)]
-    type __Encoder = ByteEncoder;
+    type __Encoded = EncodedByte;
 
     #[doc(hidden)]
-    fn __into_encoder(self) -> Self::__Encoder {
+    fn __encode(self) -> Self::__Encoded {
         assert!(self.is_ascii(), "byte pattern is not ASCII");
 
-        ByteEncoder([self])
+        EncodedByte([self])
     }
 }

src/raw_str.rs

@@ -15,7 +15,7 @@ use std::ops::RangeToInclusive;
 use std::str;
 
 use super::imp::raw;
-use super::pattern::Encoder;
+use super::pattern::Encoded;
 use super::pattern::Pattern;
 use super::OsStrBytes;
 use super::OsStringBytes;
@@ -48,8 +48,8 @@ fn rfind_pattern(string: &[u8], pat: &[u8]) -> Option<usize> {
 
 macro_rules! impl_trim_matches {
     ( $self:ident , $pat:expr , $strip_method:ident ) => {{
-        let mut encoder = $pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = $pat.__encode();
+        let pat = pat.__get();
         if pat.is_empty() {
             return $self;
         }
@@ -67,8 +67,8 @@ macro_rules! impl_trim_matches {
 
 macro_rules! impl_split_once {
     ( $self:ident , $pat:expr , $find_fn:expr ) => {{
-        let mut encoder = $pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = $pat.__encode();
+        let pat = pat.__get();
 
         let index = $find_fn(&$self.0, pat)?;
         let prefix = &$self.0[..index];
@@ -244,8 +244,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         self.0.ends_with(pat)
     }
@@ -292,8 +292,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         find_pattern(&self.0, pat)
     }
@@ -361,8 +361,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         rfind_pattern(&self.0, pat)
     }
@@ -506,8 +506,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         self.0.starts_with(pat)
     }
@@ -558,8 +558,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         self.0
             .strip_prefix(pat)
@@ -590,8 +590,8 @@ impl RawOsStr {
     where
         P: Pattern,
     {
-        let mut encoder = pat.__into_encoder();
-        let pat = encoder.__encode();
+        let pat = pat.__encode();
+        let pat = pat.__get();
 
         self.0
             .strip_suffix(pat)