Clean code

importcjj · importcjj · commit 9c60f2d195ea · 2022-08-31T11:51:12.000+08:00
diff --git a/README.md b/README.md
@@ -151,12 +151,12 @@ Value has a number of methods that meet your different needs.
 ```rust
 value.get(&str) -> Option<Value>
 value.as_str() -> &str
-value.to_u64() -> u64
-value.to_i64() -> i64
-value.to_f64() -> f64
-value.to_bool() -> bool
-value.to_vec() -> Vec<Value>
-value.to_object() -> HashMap<String, Value>
+value.as_u64() -> u64
+value.as_i64() -> i64
+value.as_f64() -> f64
+value.as_bool() -> bool
+value.as_vec() -> Vec<Value>
+value.as_object() -> HashMap<String, Value>
 ```
 
 
@@ -231,13 +231,9 @@ Found 5 outliers among 100 measurements (5.00%)
   1 (1.00%) high severe
 ```
 
-* MacBook Pro (13-inch, 2018, Four Thunderbolt 3 Ports)
-* 2.7 GHz Intel Core i7
-* 16 GB 2133 MHz LPDDR3
-
-## problems
-
-AJSON has just been finished, there may be some bugs and shortcomings, please feel free to issue. Also, Rust is a new language for me, and maybe ajson isn't rust enough, so I hope you have some suggestions.
+* MacBook Pro (14-inch, 2021)
+* Apple M1 Pro
+* 16 GB
 
 ## License
  MIT License.
diff --git a/benches/traversing.rs b/benches/traversing.rs
@@ -218,9 +218,6 @@ pub fn traverse_benchmark(c: &mut Criterion) {
     c.bench_function("traversing", |b| {
         b.iter(|| traversing(black_box(BENCH_DATA.as_bytes())))
     });
-    c.bench_function("chunk traversing", |b| {
-        b.iter(|| ajson::compound(black_box(BENCH_DATA)))
-    });
 
     c.bench_function("chunk traversing u8", |b| {
         b.iter(|| ajson::compound_u8(black_box(BENCH_DATA.as_bytes())))
diff --git a/src/element.rs b/src/element.rs
@@ -1,4 +1,4 @@
-use std::{borrow::Cow, collections::HashMap, str};
+use std::{borrow::Cow, collections::HashMap};
 
 use crate::{unescape, value::Value, Number, Result};
 
@@ -152,11 +152,6 @@ pub fn null_u8(bytes: &[u8]) -> Result<(&[u8], &[u8])> {
     Ok(split_at_u8(bytes, 4))
 }
 
-#[inline(always)]
-pub fn split_at(s: &str, mid: usize) -> (&str, &str) {
-    unsafe { (s.get_unchecked(..mid), s.get_unchecked(mid..s.len())) }
-}
-
 #[inline(always)]
 pub fn split_at_u8(s: &[u8], mid: usize) -> (&[u8], &[u8]) {
     unsafe { (s.get_unchecked(..mid), s.get_unchecked(mid..s.len())) }
@@ -201,60 +196,21 @@ pub fn string_u8(bytes: &[u8]) -> Result<(&[u8], &[u8], bool)> {
     Ok((a, b, esc))
 }
 
-pub fn string(input: &str) -> Result<(&str, &str)> {
-    let mut i = 1;
-    let bytes = input.as_bytes();
-    const CHUNK: usize = 4;
-
-    'outer: while i + CHUNK < bytes.len() {
-        for _ in 0..CHUNK {
-            let &b = unsafe { bytes.get_unchecked(i) };
-            i += 1;
-            match b {
-                b'"' => {
-                    return Ok(split_at(input, i));
-                }
-                b'\\' => {
-                    i += 1;
-                    continue 'outer;
-                }
-                _ => {}
-            }
-        }
-    }
-
-    while i < bytes.len() {
-        let b = unsafe { *bytes.get_unchecked(i) };
-
-        match b {
-            b'"' => {
-                i += 1;
-                break;
-            }
-            b'\\' => {
-                i += 1;
-            }
-            _ => {}
-        }
-
-        i += 1;
-    }
-
-    return Ok(split_at(input, i));
-}
-
 #[cfg(test)]
-mod test_string {
-    use super::string;
+mod test_strin_u8 {
+    use super::string_u8;
 
     #[test]
     fn test_string() {
         assert_eq!(
-            string(r#""hello": "tom""#),
-            Ok((r#""hello""#, r#": "tom""#))
+            string_u8(r#""hello": "tom""#.as_bytes()),
+            Ok((r#""hello""#.as_bytes(), r#": "tom""#.as_bytes(), false))
         );
 
-        assert_eq!(string(r#""hello"#), Ok((r#""hello"#, r#""#)));
+        assert_eq!(
+            string_u8(r#""hello"#.as_bytes()),
+            Ok((r#""hello"#.as_bytes(), r#""#.as_bytes(), false))
+        );
     }
 }
 
@@ -322,83 +278,17 @@ pub fn compound_u8(bytes: &[u8]) -> Result<(&[u8], &[u8])> {
     return Ok(split_at_u8(bytes, i));
 }
 
-// object or array
-pub fn compound(input: &str) -> Result<(&str, &str)> {
-    let bytes = input.as_bytes();
-    let mut i = 1;
-    let mut depth = 1;
-
-    const CHUNK_SIZE: usize = 32;
-
-    'outer: while i + CHUNK_SIZE < bytes.len() {
-        for _ in 0..CHUNK_SIZE {
-            let &b = unsafe { bytes.get_unchecked(i) };
-
-            match b {
-                b'\\' => {
-                    i += 2;
-                    continue 'outer;
-                }
-                b'"' => {
-                    let input = unsafe { input.get_unchecked(i..) };
-                    let (s, _) = string(input).unwrap();
-
-                    i += s.len();
-                    continue 'outer;
-                }
-                b'[' | b'{' => depth += 1,
-                b']' | b'}' => {
-                    depth -= 1;
-                    if depth == 0 {
-                        i += 1;
-                        return Ok(split_at(input, i));
-                    }
-                }
-                _ => (),
-            }
-            i += 1;
-        }
-    }
-
-    while i < bytes.len() {
-        let &b = unsafe { bytes.get_unchecked(i) };
-        match b {
-            b'\\' => {
-                i += 1;
-            }
-            b'"' => {
-                let input = unsafe { input.get_unchecked(i..) };
-                let (s, _) = string(input).unwrap();
-                i += s.len();
-                continue;
-            }
-            b'[' | b'{' => depth += 1,
-            b']' | b'}' => {
-                depth -= 1;
-                if depth == 0 {
-                    i += 1;
-                    break;
-                }
-            }
-            _ => (),
-        }
-        i += 1;
-    }
-
-    return Ok(split_at(input, i));
-}
-
 #[cfg(test)]
-mod test_compound {
-    use super::{compound, Result};
+mod test_compound_u8 {
+    use super::{compound_u8, Result};
 
     #[test]
     fn test_compound() -> Result<()> {
         const JSON: &str = r#"{"1":"2", "name": "jack"}xxxx"#;
-        let r = compound(JSON)?;
+        let r = compound_u8(JSON.as_bytes())?;
 
-        assert_eq!(r.0, r#"{"1":"2", "name": "jack"}"#);
-        assert_eq!(r.1, "xxxx");
+        assert_eq!(r.0, r#"{"1":"2", "name": "jack"}"#.as_bytes());
+        assert_eq!(r.1, "xxxx".as_bytes());
 
         Ok(())
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -104,8 +104,6 @@ mod value;
 
 use std::result;
 
-#[doc(hidden)]
-pub use element::compound;
 #[doc(hidden)]
 pub use element::compound_u8;
 pub use number::Number;
diff --git a/src/path/sub_selector.rs b/src/path/sub_selector.rs
@@ -81,8 +81,8 @@ pub fn parse_selectors(v: &[u8]) -> (Vec<SubSelector>, usize, bool) {
                 i += 1;
             }
             b'"' => {
-                let input = unsafe { std::str::from_utf8_unchecked(v.get_unchecked(i..)) };
-                let (a, _) = element::string(input).unwrap();
+                let input = unsafe { v.get_unchecked(i..) };
+                let (a, _, _) = element::string_u8(input).unwrap();
                 i += a.len();
 
                 continue;
