Finished generic compression algorithms.

src/bin/zap.rs

@@ -5,7 +5,7 @@ use std::{
 
 use clap::{Parser, Subcommand, ValueEnum};
 use zapf::{pack_files, unpack_files};
-
+use zap::compression::algorithms::lz4_encoder;
 #[derive(Debug, Parser)]
 #[command(
     author,
@@ -66,7 +66,7 @@ impl Command {
         zap::compress_directory(
             &input, 
             "/tmp/stuff",
-            zap::compression::lz4_writer
+            lz4_encoder
         ).await?;
 
         let out_file = File::create(&output).expect("Could not create file");

src/compression/algorithms.rs

@@ -0,0 +1,54 @@
+// Internal
+use super::Cleanup;
+
+// External
+use std::io::{
+    Error,
+    ErrorKind,
+    Write,
+};
+use lz4_flex::frame::{
+    FrameEncoder,
+    FrameDecoder
+};
+
+pub fn lz4_encoder<T>(input: Result<T, std::io::Error>) -> Result<Lz4_Encoder<T>, std::io::Error>
+where T: Write
+{
+    Ok( Lz4_Encoder { 
+        inner: (FrameEncoder::new(input?)) 
+    })
+}
+
+pub struct Lz4_Encoder<T>
+where T: Write
+{
+    inner: FrameEncoder<T>
+}
+
+impl<T> Write for Lz4_Encoder<T>
+where T: Write
+{
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.inner.flush()
+    }
+
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.inner.write(buf)
+    }
+}
+
+impl<T> Cleanup<T> for Lz4_Encoder<T>
+where T: Write
+{
+    fn cleanup(self) -> Result<T, Error>
+    {
+        match self.inner.finish()
+        {
+            Ok(w) => Ok(w),
+            Err(e) => Err(Error::from(
+                ErrorKind::Interrupted
+            ))
+        }
+    }
+}

src/compression.rs → src/compression/mod.rs

@@ -1,17 +1,22 @@
+pub mod algorithms;
+
 use std::{
-    fs,
+    fs::{self, File},
     io::{self},
 };
+use std::io::Write;
+
 
-pub fn lz4_writer<T>(
-    input: Result<T, io::Error>
-) -> Result<lz4_flex::frame::FrameEncoder<T>, io::Error>
-where
-T: io::Write
+pub trait Cleanup<T>
 {
-    Ok(lz4_flex::frame::FrameEncoder::new(input?))
+    fn cleanup(self) ->  Result<T, io::Error>;
 }
 
+pub fn lz4<T>(input: Result<T, io::Error>) -> Result<lz4_flex::frame::FrameEncoder<T>, io::Error>
+where T: io::Write
+{
+    Ok(lz4_flex::frame::FrameEncoder::new(input?))
+}
 /// Compress the input file and write it to the output file.
 /// The output file is encrypted if the keys are supplied.
 pub fn compress_lz4(input_file: fs::File, output_file: fs::File) {

src/encryption.rs → src/encryption/mod.rs

@@ -8,7 +8,3 @@ use openssl::{
 
 };
 
-pub fn encrypt(input: String)
-{
-
-}

src/internal.rs

@@ -10,17 +10,19 @@ use openssl::symm::{
     Cipher,
     encrypt
 };
-use std::fmt::Debug;
 
-pub fn compress<T, U>(mut input: T, mut output: Result<U, Error>) -> Result<(), Error>
+use crate::compression::Cleanup;
+
+pub fn compress<T, U, V>(mut input: T, output: Result<U, Error>) -> Result<(), Error>
 where 
 T: Read,
-U: Write+Debug
+U: Write+Cleanup<V>,
+V: Write
 {
     let mut out = output?;
     let len = copy(&mut input, &mut out)?;
     dbg!(len);
-    out.flush().unwrap();
+    out.cleanup();
     Ok(())
 }
 

src/lib.rs

@@ -8,15 +8,16 @@ use std::{
     path,
 };
 
-use compression::{decompress_lz4};
+use compression::{decompress_lz4, Cleanup};
 use walkdir::WalkDir;
 use rpassword::prompt_password;
 
-pub async fn compress_directory(
+pub async fn compress_directory<T: 'static>(
     input_folder_path: &str,
     output_folder_path: &str,
-    compression_algorithm: fn(Result<fs::File, io::Error>) -> Result<lz4_flex::frame::FrameEncoder<fs::File>, io::Error>
+    compression_algorithm: fn(Result<fs::File, io::Error>) -> Result<T, io::Error>
 ) -> io::Result<()> 
+where T: io::Write+Cleanup<fs::File>
 {
     let mut task_list = Vec::with_capacity(800);
 
@@ -53,13 +54,13 @@ pub async fn compress_directory(
         let func = compression_algorithm.clone();
         // Rewrite to return errors
         let compress_task = tokio::spawn(async move {
-            dbg!(internal::compress(
+            internal::compress(
                 fs::File::open(entry_path).expect("Failed to open input file"),
                 internal::process_unit(
                     fs::File::create(output_path),
                     func
                 )
-            ));
+            );
         });
 
         task_list.push(compress_task);