fmt

Author: Rickard Lundin

src/chunked/arrow_converter.rs

@@ -76,10 +76,9 @@ pub(crate) struct Slice2Arrow<'a> {
     pub(crate) fn_line_break_len: FnLineBreakLen,
     pub(crate) masterbuilders: MasterBuilders,
     pub(crate) consistent_counter: ConsistentCounter,
-    pub(crate) threaded_write: (Sender<RecordBatch>,JoinHandle<Result<Stats>>)
+    pub(crate) threaded_write: (Sender<RecordBatch>, JoinHandle<Result<Stats>>),
 }
 
-
 pub(crate) struct MasterBuilders {
     builders: Vec<Vec<Box<dyn Sync + Send + ColumnBuilder>>>,
     outfile: PathBuf,

src/chunked/threaded_file_output.rs

@@ -48,6 +48,7 @@ use super::{
     Stats,
 };
 use crate::chunked;
+use crate::cli::Targets;
 use crate::datatype::DataType;
 use crate::schema;
 use arrow::datatypes::{Field, Schema, SchemaRef};
@@ -66,22 +67,27 @@ use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use thread::spawn;
 use Compression::SNAPPY;
-use crate::cli::Targets;
 
 pub(crate) struct parquet_file_out {
     pub(crate) sender: Option<Sender<RecordBatch>>,
 }
-pub(crate) fn output_factory (target: Targets,schema: SchemaRef,_outfile:PathBuf) -> (Sender<RecordBatch>, JoinHandle<Result<Stats>>) {
+pub(crate) fn output_factory(
+    target: Targets,
+    schema: SchemaRef,
+    _outfile: PathBuf,
+) -> (Sender<RecordBatch>, JoinHandle<Result<Stats>>) {
     match target {
         Targets::Parquet => {
-             let mut pfo: Box<dyn arrow_file_output> = Box::new(parquet_file_out { sender: None });
-             pfo.setup(schema, _outfile)
+            let mut pfo: Box<dyn arrow_file_output> = Box::new(parquet_file_out { sender: None });
+            pfo.setup(schema, _outfile)
         }
         Targets::IPC => {
             let mut pfo: Box<dyn arrow_file_output> = Box::new(ipc_file_out { sender: None });
             pfo.setup(schema, _outfile)
         }
-        Targets::None => {todo!()}
+        Targets::None => {
+            todo!()
+        }
     }
 }
 impl arrow_file_output for parquet_file_out {

src/cli.rs

@@ -33,23 +33,23 @@ use log::info;
 #[cfg(feature = "rayon")]
 use parquet::arrow::ArrowWriter;
 
+use arrow::datatypes::SchemaRef;
+use atomic_counter::ConsistentCounter;
 #[cfg(feature = "rayon")]
 use std::fs;
 #[cfg(feature = "rayon")]
 use std::fs::File;
 use std::path::PathBuf;
-use arrow::datatypes::SchemaRef;
-use atomic_counter::ConsistentCounter;
 
 #[cfg(feature = "rayon")]
 use crate::chunked::arrow_converter::{MasterBuilders, Slice2Arrow};
 #[cfg(feature = "rayon")]
 use crate::chunked::residual_slicer::ResidualSlicer;
 #[cfg(feature = "rayon")]
 use crate::chunked::self_converter::SampleSliceAggregator;
+use crate::chunked::threaded_file_output::output_factory;
 #[cfg(feature = "rayon")]
 use crate::chunked::{find_last_nl, line_break_len_cr, Converter as ChunkedConverter, Slicer};
-use crate::chunked::threaded_file_output::output_factory;
 use crate::converter::Converter;
 use crate::error::Result;
 use crate::mocker::Mocker;
@@ -107,7 +107,6 @@ pub struct Cli {
     n_threads: usize,
 }
 
-
 #[derive(Subcommand)]
 enum Commands {
     /// Convert a fixed-length file (.flf) to parquet.
@@ -294,14 +293,18 @@ impl Cli {
                             schema.to_path_buf(),
                             n_threads as i16,
                         );
-                        let sc=master_builders.schema_factory();
-                        
+                        let sc = master_builders.schema_factory();
+
                         let s2a: Box<Slice2Arrow> = Box::new(Slice2Arrow {
                             fn_line_break: find_last_nl,
                             fn_line_break_len: line_break_len_cr,
                             masterbuilders: master_builders,
                             consistent_counter: ConsistentCounter::new(0),
-                            threaded_write: output_factory(self.target.clone(),sc ,out_file.clone().to_path_buf()),
+                            threaded_write: output_factory(
+                                self.target.clone(),
+                                sc,
+                                out_file.clone().to_path_buf(),
+                            ),
                         });
                         s2a
                     }