From 5dbea93266c3a30dac5ec6f5a7915d73a440f573 Mon Sep 17 00:00:00 2001
From: Daniel <kingdread@gmx.de>
Date: Sat, 25 Apr 2020 13:14:30 +0200
Subject: use free functions instead of Filter::new

Having a ::new on each of the filter types was a bit weird, especially
because we returned Box<dyn ...> instead of Self (and clippy rightfully
complained). With this patch, we now have a bunch of normal functions,
and we don't show to the outside how a filter is actually implemented
(or what struct is behind it).
---
 src/filters/log.rs | 99 +++++++++++++++++++++++++++++++++---------------------
 1 file changed, 61 insertions(+), 38 deletions(-)

(limited to 'src/filters/log.rs')

diff --git a/src/filters/log.rs b/src/filters/log.rs
index 8b84bf3..8d4e0b5 100644
--- a/src/filters/log.rs
+++ b/src/filters/log.rs
@@ -19,13 +19,7 @@ use num_traits::FromPrimitive as _;
 pub trait LogFilter = Filter<PartialEvtc, LogResult>;
 
 #[derive(Debug, Clone)]
-pub struct BossFilter(HashSet<Boss>);
-
-impl BossFilter {
-    pub fn new(bosses: HashSet<Boss>) -> Box<dyn LogFilter> {
-        Box::new(BossFilter(bosses))
-    }
-}
+struct BossFilter(HashSet<Boss>);
 
 impl Filter<PartialEvtc, LogResult> for BossFilter {
     fn filter_early(&self, partial_evtc: &PartialEvtc) -> Inclusion {
@@ -40,26 +34,14 @@ impl Filter<PartialEvtc, LogResult> for BossFilter {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct OutcomeFilter(HashSet<FightOutcome>);
-
-impl OutcomeFilter {
-    pub fn new(outcomes: HashSet<FightOutcome>) -> Box<dyn LogFilter> {
-        Box::new(OutcomeFilter(outcomes))
-    }
+/// A `LogFilter` that only accepts logs with one of the given bosses.
+pub fn boss(bosses: HashSet<Boss>) -> Box<dyn LogFilter> {
+    Box::new(BossFilter(bosses))
+}
 
-    pub fn success() -> Box<dyn LogFilter> {
-        let mut outcomes = HashSet::new();
-        outcomes.insert(FightOutcome::Success);
-        Self::new(outcomes)
-    }
 
-    pub fn wipe() -> Box<dyn LogFilter> {
-        let mut outcomes = HashSet::new();
-        outcomes.insert(FightOutcome::Wipe);
-        Self::new(outcomes)
-    }
-}
+#[derive(Debug, Clone)]
+struct OutcomeFilter(HashSet<FightOutcome>);
 
 impl Filter<PartialEvtc, LogResult> for OutcomeFilter {
     fn filter(&self, log: &LogResult) -> bool {
@@ -67,30 +49,49 @@ impl Filter<PartialEvtc, LogResult> for OutcomeFilter {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct WeekdayFilter(HashSet<Weekday>);
+/// A `LogFilter` that only accepts logs with one of the given outcomes.
+///
+/// See also [`success`][success] and [`wipe`][wipe].
+pub fn outcome(outcomes: HashSet<FightOutcome>) -> Box<dyn LogFilter> {
+    Box::new(OutcomeFilter(outcomes))
+}
 
-impl WeekdayFilter {
-    pub fn new(weekdays: HashSet<Weekday>) -> Box<dyn LogFilter> {
-        Box::new(WeekdayFilter(weekdays))
-    }
+/// A `LogFilter` that only accepts successful logs.
+///
+/// See also [`outcome`][outcome] and [`wipe`][wipe].
+pub fn success() -> Box<dyn LogFilter> {
+    let mut outcomes = HashSet::new();
+    outcomes.insert(FightOutcome::Success);
+    outcome(outcomes)
+}
+
+/// A `LogFilter` that only accepts failed logs.
+///
+/// See also [`outcome`][outcome] and [`success`][wipe].
+pub fn wipe() -> Box<dyn LogFilter> {
+    let mut outcomes = HashSet::new();
+    outcomes.insert(FightOutcome::Wipe);
+    outcome(outcomes)
 }
 
+#[derive(Debug, Clone)]
+struct WeekdayFilter(HashSet<Weekday>);
+
 impl Filter<PartialEvtc, LogResult> for WeekdayFilter {
     fn filter(&self, log: &LogResult) -> bool {
         self.0.contains(&log.time.weekday())
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct TimeFilter(Option<NaiveDateTime>, Option<NaiveDateTime>);
-
-impl TimeFilter {
-    pub fn new(after: Option<NaiveDateTime>, before: Option<NaiveDateTime>) -> Box<dyn LogFilter> {
-        Box::new(TimeFilter(after, before))
-    }
+/// A `LogFilter` that only accepts logs if they were done on one of the given weekdays.
+pub fn weekday(weekdays: HashSet<Weekday>) -> Box<dyn LogFilter> {
+    Box::new(WeekdayFilter(weekdays))
 }
 
+
+#[derive(Debug, Clone)]
+struct TimeFilter(Option<NaiveDateTime>, Option<NaiveDateTime>);
+
 impl Filter<PartialEvtc, LogResult> for TimeFilter {
     fn filter(&self, log: &LogResult) -> bool {
         let after_ok = match self.0 {
@@ -105,3 +106,25 @@ impl Filter<PartialEvtc, LogResult> for TimeFilter {
         after_ok && before_ok
     }
 }
+
+/// A `LogFilter` that only accepts logs in the given time frame.
+///
+/// If a bound is not given, -Infinity is assumed for the lower bound, and Infinity for the upper
+/// bound.
+pub fn time(lower: Option<NaiveDateTime>, upper: Option<NaiveDateTime>) -> Box<dyn LogFilter> {
+    Box::new(TimeFilter(lower, upper))
+}
+
+/// A `LogFilter` that only accepts logs after the given date.
+///
+/// Also see [`time`][time] and [`before`][before].
+pub fn after(when: NaiveDateTime) -> Box<dyn LogFilter> {
+    time(Some(when), None)
+}
+
+/// A `LogFilter` that only accepts logs before the given date.
+///
+/// Also see [`time`][time] and [`after`][after].
+pub fn before(when: NaiveDateTime) -> Box<dyn LogFilter> {
+    time(None, Some(when))
+}
-- 
cgit v1.2.3