first attempt at sorting output

This does currently not work yet, as we cannot call .finish() on dyn
Aggregator. This needs to be adjusted.

However, this provides the basic infrastructure for producing sorted
output, including the required command line parsing.

1 files changed, 41 insertions, 5 deletions

diff --git a/src/output/aggregators.rs b/src/output/aggregators.rs
index 1b04af3..4fa2558 100644
--- a/src/output/aggregators.rs
+++ b/src/output/aggregators.rs
@@ -6,12 +6,15 @@
 //!
 //! Aggregators must be shareable across threads, as the search will be multi-threaded. This is why
 //! an Aggregator must make sure that the data is protected by a mutex or similar.
-use super::{super::LogResult, formats::Format};
+use super::{super::LogResult, formats::Format, sorting::Sorting};
 
-use std::io::Write;
+use std::{
+    io::Write,
+    sync::Mutex,
+};
 
 pub trait Aggregator: Sync {
-    fn push_item(&self, item: &LogResult, format: &dyn Format, stream: &mut dyn Write);
+    fn push_item(&self, item: LogResult, format: &dyn Format, stream: &mut dyn Write);
     fn finish(self, format: &dyn Format, stream: &mut dyn Write);
 }
 
@@ -20,11 +23,44 @@ pub trait Aggregator: Sync {
 pub struct WriteThrough;
 
 impl Aggregator for WriteThrough {
-    fn push_item(&self, item: &LogResult, format: &dyn Format, stream: &mut dyn Write) {
-        let text = format.format_result(item);
+    fn push_item(&self, item: LogResult, format: &dyn Format, stream: &mut dyn Write) {
+        let text = format.format_result(&item);
         stream.write_all(text.as_bytes()).unwrap();
         stream.flush().unwrap();
     }
 
     fn finish(self, _: &dyn Format, _: &mut dyn Write) {}
 }
+
+/// An aggregator that keeps all found logs in memory and sorts them before outputting them.
+#[derive(Debug)]
+pub struct SortedOutput {
+    sorting: Sorting,
+    items: Mutex<Vec<LogResult>>,
+}
+
+impl SortedOutput {
+    pub fn new(sorting: Sorting) -> Self {
+        SortedOutput {
+            sorting,
+            items: Mutex::new(vec![]),
+        }
+    }
+}
+
+impl Aggregator for SortedOutput {
+    fn push_item(&self, item: LogResult, _: &dyn Format, _: &mut dyn Write) {
+        self.items.lock().unwrap().push(item)
+    }
+
+    fn finish(self, format: &dyn Format, stream: &mut dyn Write) {
+        let SortedOutput { sorting, items } = self;
+        let mut items = items.into_inner().unwrap();
+        items.sort_unstable_by(|a, b| sorting.cmp(a, b));
+        for item in items {
+            let text = format.format_result(&item);
+            stream.write_all(text.as_bytes()).unwrap();
+        }
+        stream.flush().unwrap();
+    }
+}