Merge pull request #4428 from jfinkels/dd-copy-function

dd: move dd_out() function up to module level

src/uu/dd/src/dd.rs

@@ -138,7 +138,7 @@ impl Read for Source {
 ///
 /// Use the [`Input::new_stdin`] or [`Input::new_file`] functions to
 /// construct a new instance of this struct. Then pass the instance to
-/// the [`Output::dd_out`] function to execute the main copy operation
+/// the [`dd_copy`] function to execute the main copy operation
 /// for `dd`.
 struct Input<'a> {
     /// The source from which bytes will be read.
@@ -449,7 +449,7 @@ impl Write for Dest {
 ///
 /// Use the [`Output::new_stdout`] or [`Output::new_file`] functions
 /// to construct a new instance of this struct. Then use the
-/// [`Output::dd_out`] function to execute the main copy operation for
+/// [`dd_copy`] function to execute the main copy operation for
 /// `dd`.
 struct Output<'a> {
     /// The destination to which bytes will be written.
@@ -579,19 +579,20 @@ impl<'a> Output<'a> {
             Ok(())
         }
     }
+}
 
-    /// Copy the given input data to this output, consuming both.
-    ///
-    /// This method contains the main loop for the `dd` program. Bytes
-    /// are read in blocks from `i` and written in blocks to this
-    /// output. Read/write statistics are reported to stderr as
-    /// configured by the `status` command-line argument.
-    ///
-    /// # Errors
-    ///
-    /// If there is a problem reading from the input or writing to
-    /// this output.
-    fn dd_out(mut self, mut i: Input) -> std::io::Result<()> {
+/// Copy the given input data to this output, consuming both.
+///
+/// This method contains the main loop for the `dd` program. Bytes
+/// are read in blocks from `i` and written in blocks to this
+/// output. Read/write statistics are reported to stderr as
+/// configured by the `status` command-line argument.
+///
+/// # Errors
+///
+/// If there is a problem reading from the input or writing to
+/// this output.
+fn dd_copy(mut i: Input, mut o: Output) -> std::io::Result<()> {
     // The read and write statistics.
     //
     // These objects are counters, initialized to zero. After each
@@ -613,7 +614,7 @@ impl<'a> Output<'a> {
     //
     // This is an educated guess about a good buffer size based on
     // the input and output block sizes.
-        let bsize = calc_bsize(i.settings.ibs, self.settings.obs);
+    let bsize = calc_bsize(i.settings.ibs, o.settings.obs);
 
     // Start a thread that reports transfer progress.
     //
@@ -632,7 +633,7 @@ impl<'a> Output<'a> {
     // Optimization: if no blocks are to be written, then don't
     // bother allocating any buffers.
     if let Some(Num::Blocks(0) | Num::Bytes(0)) = i.settings.count {
-            return self.finalize(rstat, wstat, start, &prog_tx, output_thread);
+        return finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread);
     };
 
     // Create a common buffer with a capacity of the block size.
@@ -651,13 +652,12 @@ impl<'a> Output<'a> {
         // As an optimization, make an educated guess about the
         // best buffer size for reading based on the number of
         // blocks already read and the number of blocks remaining.
-            let loop_bsize =
-                calc_loop_bsize(&i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
+        let loop_bsize = calc_loop_bsize(&i.settings.count, &rstat, &wstat, i.settings.ibs, bsize);
         let rstat_update = read_helper(&mut i, &mut buf, loop_bsize)?;
         if rstat_update.is_empty() {
             break;
         }
-            let wstat_update = self.write_blocks(&buf)?;
+        let wstat_update = o.write_blocks(&buf)?;
 
         // Update the read/write stats and inform the progress thread once per second.
         //
@@ -673,20 +673,20 @@ impl<'a> Output<'a> {
             prog_tx.send(prog_update).unwrap_or(());
         }
     }
-        self.finalize(rstat, wstat, start, &prog_tx, output_thread)
-    }
+    finalize(&mut o, rstat, wstat, start, &prog_tx, output_thread)
+}
 
-    /// Flush output, print final stats, and join with the progress thread.
-    fn finalize<T>(
-        &mut self,
+/// Flush output, print final stats, and join with the progress thread.
+fn finalize<T>(
+    output: &mut Output,
     rstat: ReadStat,
     wstat: WriteStat,
     start: time::Instant,
     prog_tx: &mpsc::Sender<ProgUpdate>,
     output_thread: thread::JoinHandle<T>,
-    ) -> std::io::Result<()> {
+) -> std::io::Result<()> {
     // Flush the output, if configured to do so.
-        self.sync()?;
+    output.sync()?;
 
     // Truncate the file to the final cursor location.
     //
@@ -696,8 +696,8 @@ impl<'a> Output<'a> {
     // suppress the error by calling `Result::ok()`. This matches
     // the behavior of GNU `dd` when given the command-line
     // argument `of=/dev/null`.
-        if !self.settings.oconv.notrunc {
-            self.dst.truncate().ok();
+    if !output.settings.oconv.notrunc {
+        output.dst.truncate().ok();
     }
 
     // Print the final read/write statistics.
@@ -708,7 +708,6 @@ impl<'a> Output<'a> {
         .join()
         .expect("Failed to join with the output thread.");
     Ok(())
-    }
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -925,7 +924,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         }
         None => Output::new_stdout(&settings)?,
     };
-    o.dd_out(i).map_err_context(|| "IO error".to_string())
+    dd_copy(i, o).map_err_context(|| "IO error".to_string())
 }
 
 pub fn uu_app() -> Command {