From 838ad1b18a308994b9f8bc003dc86345f870557e Mon Sep 17 00:00:00 2001 From: ppom Date: Sat, 26 Oct 2024 12:00:00 +0200 Subject: [PATCH] less owned data, more borrowed data --- import-rust-db/src/main.rs | 4 ++-- src/client/mod.rs | 4 ++-- src/concepts/pattern.rs | 28 ++++++++++++++-------------- src/daemon/action.rs | 26 +++++++++++++------------- src/daemon/database/lowlevel.rs | 6 +++--- src/daemon/socket.rs | 6 +++--- 6 files changed, 37 insertions(+), 37 deletions(-) diff --git a/import-rust-db/src/main.rs b/import-rust-db/src/main.rs index 0918ed1..0e587c2 100644 --- a/import-rust-db/src/main.rs +++ b/import-rust-db/src/main.rs @@ -52,7 +52,7 @@ fn lil_main() -> Result<(), E> { Ok(()) } -fn import(json_path: String, write_path: String) -> Result<(), E> { +fn import(json_path: &str, write_path: &str) -> Result<(), E> { let json_file = BufReader::new(File::open(json_path.clone())?); let mut write_file = BufWriter::new(File::create(write_path)?); let bin = bincode_options(); @@ -81,7 +81,7 @@ fn import(json_path: String, write_path: String) -> Result<(), E> { Ok(()) } -fn collect_stream_filters(json_path: String) -> Result { +fn collect_stream_filters(json_path: &str) -> Result { let mut header = BTreeMap::new(); let mut count = 0; let json_file = BufReader::new(File::open(json_path)?); diff --git a/src/client/mod.rs b/src/client/mod.rs index 3236ec6..8a1b61a 100644 --- a/src/client/mod.rs +++ b/src/client/mod.rs @@ -2,7 +2,7 @@ use std::{ collections::BTreeSet, error::Error, io::{stdin, BufRead, BufReader}, - path::PathBuf, + path::{Path, PathBuf}, sync::Arc, }; @@ -26,7 +26,7 @@ macro_rules! or_quit { }; } -async fn send_retrieve(socket: &PathBuf, req: &ClientRequest) -> Result { +async fn send_retrieve(socket: &Path, req: &ClientRequest) -> Result { let bin = bincode_options(); let conn = or_quit!( "opening connection to daemon", diff --git a/src/concepts/pattern.rs b/src/concepts/pattern.rs index 2d3e089..eacd49a 100644 --- a/src/concepts/pattern.rs +++ b/src/concepts/pattern.rs @@ -23,7 +23,7 @@ pub struct Pattern { } impl Pattern { - pub fn setup(&mut self, name: &String) -> Result<(), String> { + pub fn setup(&mut self, name: &str) -> Result<(), String> { self._setup(name) .map_err(|msg| format!("pattern {}: {}", name, msg)) } @@ -35,8 +35,8 @@ impl Pattern { &self.name_with_braces } - pub fn _setup(&mut self, name: &String) -> Result<(), String> { - self.name = name.clone(); + pub fn _setup(&mut self, name: &str) -> Result<(), String> { + self.name = name.to_string(); self.name_with_braces = format!("<{}>", name); if self.name.is_empty() { @@ -151,16 +151,16 @@ pub mod tests { // Empty name pattern = default_pattern(); pattern.regex = "abc".into(); - assert!(pattern.setup(&"".into()).is_err()); + assert!(pattern.setup("").is_err()); // '.' in name pattern = default_pattern(); pattern.regex = "abc".into(); - assert!(pattern.setup(&"na.me".into()).is_err()); + assert!(pattern.setup("na.me").is_err()); // Empty regex pattern = default_pattern(); - assert!(pattern.setup(&"name".into()).is_err()); + assert!(pattern.setup("name").is_err()); } #[test] @@ -169,17 +169,17 @@ pub mod tests { // regex ok pattern = ok_pattern(); - assert!(pattern.setup(&"name".into()).is_ok()); + assert!(pattern.setup("name").is_ok()); // regex ok pattern = default_pattern(); pattern.regex = "abc".into(); - assert!(pattern.setup(&"name".into()).is_ok()); + assert!(pattern.setup("name").is_ok()); // regex ko pattern = default_pattern(); pattern.regex = "[abc".into(); - assert!(pattern.setup(&"name".into()).is_err()); + assert!(pattern.setup("name").is_err()); } #[test] @@ -191,13 +191,13 @@ pub mod tests { pattern.regex = "[abc]".into(); pattern.ignore.push("a".into()); pattern.ignore.push("b".into()); - assert!(pattern.setup(&"name".into()).is_ok()); + assert!(pattern.setup("name").is_ok()); // ignore ko pattern = default_pattern(); pattern.regex = "[abc]".into(); pattern.ignore.push("d".into()); - assert!(pattern.setup(&"name".into()).is_err()); + assert!(pattern.setup("name").is_err()); } #[test] @@ -209,13 +209,13 @@ pub mod tests { pattern.regex = "[abc]".into(); pattern.ignore_regex.push("[a]".into()); pattern.ignore_regex.push("a".into()); - assert!(pattern.setup(&"name".into()).is_ok()); + assert!(pattern.setup("name").is_ok()); // ignore_regex ko pattern = default_pattern(); pattern.regex = "[abc]".into(); pattern.ignore.push("[a".into()); - assert!(pattern.setup(&"name".into()).is_err()); + assert!(pattern.setup("name").is_err()); } #[test] @@ -230,7 +230,7 @@ pub mod tests { pattern.ignore_regex.push("c".into()); pattern.ignore_regex.push("[de]".into()); - pattern.setup(&"name".into()).unwrap(); + pattern.setup("name").unwrap(); assert!(!pattern.not_an_ignore("a")); assert!(!pattern.not_an_ignore("b")); assert!(!pattern.not_an_ignore("c")); diff --git a/src/daemon/action.rs b/src/daemon/action.rs index 44742e8..db36557 100644 --- a/src/daemon/action.rs +++ b/src/daemon/action.rs @@ -16,24 +16,24 @@ struct State { } impl State { - fn add_match(&mut self, m: &Match, t: Time) { - self.pending.entry(m.clone()).or_default().insert(t); - self.ordered_times.insert(t, m.clone()); + fn add_match(&mut self, m: &Match, t: &Time) { + self.pending.entry(m.clone()).or_default().insert(*t); + self.ordered_times.insert(*t, m.clone()); } - fn remove(&mut self, m: Match, t: Time) -> bool { - self.pending.entry(m).and_modify(|times| { - times.remove(&t); + fn remove(&mut self, m: &Match, t: &Time) -> bool { + self.pending.entry(m.clone()).and_modify(|times| { + times.remove(t); }); - self.ordered_times.remove(&t).is_some() + self.ordered_times.remove(t).is_some() } - fn clear_past_times(&mut self, now: Time, after: Option) { + fn clear_past_times(&mut self, now: &Time, after: Option) { let after = after.unwrap_or_default(); while self .ordered_times .first_key_value() - .is_some_and(|(k, _)| *k + after < now) + .is_some_and(|(k, _)| *k + after < *now) { #[allow(clippy::unwrap_used)] // we just checked in the condition that first is_some let (_, m) = self.ordered_times.pop_first().unwrap(); @@ -81,8 +81,8 @@ impl ActionManager { { #[allow(clippy::unwrap_used)] // propagating panics is ok let mut state = self.state.lock().unwrap(); - state.clear_past_times(t, self.action.after_duration()); - state.add_match(&m, exec_t); + state.clear_past_times(&t, self.action.after_duration()); + state.add_match(&m, &exec_t); } let this = self.clone(); tokio::spawn(async move { @@ -90,7 +90,7 @@ impl ActionManager { tokio::time::sleep(dur).await; #[allow(clippy::unwrap_used)] // propagating panics is ok let mut state = this.state.lock().unwrap(); - if state.remove(m.clone(), t) { + if state.remove(&m, &t) { this.exec_now(m); } }); @@ -115,7 +115,7 @@ impl ActionManager { .iter() .map(|time| { if let Order::Flush = order { - if state.remove(match_.clone(), *time) { + if state.remove(&match_, time) { self.exec_now(match_.clone()); } } diff --git a/src/daemon/database/lowlevel.rs b/src/daemon/database/lowlevel.rs index a16a1b1..7d0536c 100644 --- a/src/daemon/database/lowlevel.rs +++ b/src/daemon/database/lowlevel.rs @@ -165,11 +165,11 @@ impl WriteDB { pub fn write(&mut self, entry: LogEntry) -> Result<(), DBError> { let computed = ComputedLogEntry::from(entry, &self.h)?; - self._write(computed) + self._write(&computed) } - fn _write(&mut self, data: T) -> Result<(), DBError> { - let encoded = self.bin.serialize(&data)?; + fn _write(&mut self, data: &T) -> Result<(), DBError> { + let encoded = self.bin.serialize(data)?; // debug!("writing this: {:?}, {:?}", &data, &encoded); self.f.write_all(&encoded)?; Ok(()) diff --git a/src/daemon/socket.rs b/src/daemon/socket.rs index 599f530..64935b4 100644 --- a/src/daemon/socket.rs +++ b/src/daemon/socket.rs @@ -65,17 +65,17 @@ async fn answer_order( // Compute the Vec<(pattern_name: String, regex: String)> into a BTreeMap, Regex> let patterns = options .patterns - .iter() + .into_iter() .map(|(name, reg)| { // lookup pattern in config.patterns config .patterns() .iter() // retrieve or Err - .find(|(pattern_name, _)| name == *pattern_name) + .find(|(pattern_name, _)| &name == *pattern_name) .ok_or_else(|| format!("pattern '{name}' doesn't exist")) // compile Regex or Err - .and_then(|(_, pattern)| match Regex::new(reg) { + .and_then(|(_, pattern)| match Regex::new(®) { Ok(reg) => Ok((pattern.clone(), reg)), Err(err) => Err(format!("pattern '{name}' regex doesn't compile: {err}")), })