Merge pull request #67 from baoyachi/performance_optimization

Independent calc feature

Author: baoyachi

.github/workflows/check.yml

@@ -77,13 +77,15 @@ jobs:
       - name: Run tests
         run: cargo test  --all-features --all
       - name: Run tests without default features.
-        run: cargo test --no-default-features
+        run: cargo test --no-default-features --features="calc"
       - name: Run examples with deserialize_duration
         run: cargo run --example deserialize_duration
       - name: Run examples with deserialize_duration_chrono
         run: cargo run --example deserialize_duration_chrono
       - name: Run examples with deserialize_duration_time
         run: cargo run --example deserialize_duration_time
+      - name: Run examples with no_calc
+        run: cargo run --example no_calc --features="no_calc"
       - name: Coverage
         if: matrix.rust == 'stable'
         run: cargo tarpaulin -o Lcov --output-dir ./coverage

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "duration-str"
-version = "0.15.1"
+version = "0.16.0"
 authors = ["baoyachi <[email protected]>"]
 edition = "2021"
 description = "duration string parser"
@@ -12,16 +12,18 @@ license = "Apache-2.0"
 exclude = ["duration-str.png", "./playground"]
 
 [features]
-default = ["chrono", "serde", "time"]
+default = ["chrono", "serde", "time", "calc"]
 
 lowercase = []
+no_calc = []
+calc = []
 
 [dependencies]
 thiserror = "2.0.0"
 chrono = { version = "0.4.38", optional = true, default-features = false, features = ["now"] }
 time = { version = "0.3.17", optional = true, default-features = false }
 
-serde = { version = "1.0.147", features = ["derive"], optional = true}
+serde = { version = "1.0.147", features = ["derive"], optional = true }
 rust_decimal = { version = "1.29.1", default-features = false }
 winnow = "0.7.3"
 
@@ -32,7 +34,7 @@ criterion = "0.5"
 [[bench]]
 name = "parser_benchmark"
 harness = false
-required-features = ["lowercase"]
+required-features = ["lowercase", "no_calc"]
 
 # docs.rs-specific configuration
 [package.metadata.docs.rs]
@@ -50,3 +52,8 @@ required-features = ["chrono", "serde"]
 [[example]]
 name = "deserialize_duration_time"
 required-features = ["time", "serde"]
+
+[[example]]
+name = "no_calc"
+required-features = ["no_calc"]
+

README.md

@@ -33,6 +33,9 @@
 Suggestion: It is recommended to enable the `lowercase` feature to improve performance:  
 * Default: Calls `to_lowercase()` each time, designed for compatibility, suitable for flexible input but with lower performance.  
 * `lowercase` feature: Skips the conversion, ideal for lowercase input scenarios, offering better performance."
+* `no_calc` feature: When enabled, the parse function only parses and sums expression values without complex logic, ideal for high-performance scenarios not requiring intricate calculations.
+
+
 
 ## Notice ⚠️
 

benches/parser_benchmark.rs

@@ -1,4 +1,4 @@
-// use: cargo bench --features lowercase
+// use: cargo bench --features "lowercase no_calc"
 
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::time::Duration;

examples/no_calc.rs

@@ -0,0 +1,18 @@
+use duration_str::parse_std;
+use std::time::Duration;
+
+fn main() {
+    let duration = parse_std("2h 37m").unwrap();
+    assert_eq!(duration, Duration::new(9420, 0));
+
+    let duration = parse_std("2h 37m ").unwrap();
+    assert_eq!(duration, Duration::new(9420, 0));
+
+    let duration = parse_std(" 2h 37m").unwrap();
+    assert_eq!(duration, Duration::new(9420, 0));
+
+    let duration = parse_std(" 2h 37m    ").unwrap();
+    assert_eq!(duration, Duration::new(9420, 0));
+
+    assert!(parse_std("").is_err());
+}

src/parser.rs

@@ -2,7 +2,6 @@ use crate::unit::{opt_unit_abbr, TimeUnit};
 use crate::{Calc, CondUnit, ExpectErr};
 use std::time::Duration;
 use winnow::ascii::{digit1, multispace0};
-use winnow::combinator::trace;
 use winnow::combinator::{alt, cut_err};
 use winnow::combinator::{eof, peek, repeat};
 use winnow::error::{ContextError, StrContext, StrContextValue};
@@ -68,20 +67,43 @@ pub(crate) fn cond_time<'a>(input: &mut &'a str) -> WResult<Vec<(&'a str, CondUn
 
 pub fn parse(input: impl AsRef<str>) -> Result<Duration, String> {
     let input = input.as_ref();
-    let (unit_time, cond_val) = (parse_expr_time, trace("cond_time", cond_time))
-        .parse(input)
-        .map_err(|e| format!("{}", e))?;
-
-    let (init_cond, init_duration) = if cond_val.is_empty() {
-        CondUnit::init()
-    } else {
-        cond_val.calc().map_err(|err| err.to_string())?
-    };
+    if input.is_empty() {
+        return Err(String::from("Empty input"));
+    }
+    #[cfg(all(feature = "no_calc", not(feature = "calc")))]
+    {
+        use crate::DError;
+
+        let d = repeat(0.., parse_expr_time)
+            .try_fold(
+                Default::default,
+                |mut acc: u64, item| -> Result<_, DError> {
+                    acc = acc.checked_add(item).ok_or(DError::OverflowError)?;
+                    Ok(acc)
+                },
+            )
+            .parse(input)
+            .map_err(|err| err.to_string())?;
+        return Ok(Duration::from_nanos(d));
+    }
 
-    let duration = init_cond
-        .calc(unit_time, init_duration)
-        .map_err(|err| err.to_string())?;
-    Ok(duration)
+    #[cfg(feature = "calc")]
+    {
+        let (unit_time, cond_val) = (parse_expr_time, cond_time)
+            .parse(input)
+            .map_err(|e| format!("{}", e))?;
+
+        let (init_cond, init_duration) = if cond_val.is_empty() {
+            CondUnit::init()
+        } else {
+            cond_val.calc().map_err(|err| err.to_string())?
+        };
+
+        let duration = init_cond
+            .calc(unit_time, init_duration)
+            .map_err(|err| err.to_string())?;
+        Ok(duration)
+    }
 }
 
 #[cfg(test)]
@@ -197,6 +219,8 @@ expected ["y", "mon", "w", "d", "h", "m", "s", "ms", "µs", "us", "ns"]"#
 expected ['+', '*']"#
                 .trim()
         );
+
+        assert_eq!(catch_err!(parse("")), "Empty input");
     }
 
     #[test]