prepare

src/product.rs

@@ -1,6 +1,6 @@
 use crate::error::UnexpectedError;
 use bzip2::{read::BzDecoder, Decompress};
-use flate2::GzBuilder;
+use flate2::read::GzDecoder;
 use std::{
     fs,
     io::{Read, Seek},
@@ -34,29 +34,36 @@ struct ProductLoader<'a>(&'a Path);
 trait RadarType {}
 
 trait RecordParseStrategy {
-    fn parse(&self) -> Box<dyn RadarType>;
+    fn parse<T:AsRef<[u8]>>(raw:T) -> Box<dyn RadarType>;
 }
 
 struct DataLoader<'a, T: RecordParseStrategy>(&'a Path, T);
 
 impl<'a, T: RecordParseStrategy> DataLoader<'a, T> {
-    fn prepare(&self) -> Result<&[u8], UnexpectedError> {
+    fn prepare(&self) -> Result<Vec<u8>, UnexpectedError> {
         let _p = self.0;
         let mut _f = fs::File::open(_p)?;
         let mut _magic: [u8; 3] = [0, 0, 0];
+
         _f.read(&mut _magic)?;
 
-        match _magic {
+        let mut buffer = Vec::new();
-            [66, 90, 104] => BzDecoder::new(r),
+
-            [1, 1, 1] => {}
+        _f.read_to_end(&mut buffer)?;
-            _ => {
+
-                return Err(UnexpectedError::UnknownFormat);
+        match _magic {
-            }
+            [66, 90, 104] => Ok(BzDecoder::new(_f).read_to_end(&mut buffer)?),
-        }
+            [1, 1, 1] => Ok(GzDecoder::new(_f).read_to_end(&mut buffer)?),
+            _ => Err(UnexpectedError::UnknownFormat),
+        }
+        .map(move |_x| buffer)
+    }
+    pub fn parse(&self) {
+        let _prepard_value = self.prepare().unwrap();
+
+        self.1.parse(_prepard_value);
 
-        return Ok(());
     }
-    pub fn parse(&self) {}
 }
 
 // impl<'a, T: RecordParseStrategy> Loader for DataLoader<'a, T> {