progress: Replace Nest

This version doesn't need everyone to have counts.  In particular, you
can have woolly phases.  The otterlib bundle processing will want
this.

Signed-off-by: Ian Jackson <ijackson@chiark.greenend.org.uk>

diff --git a/cli/forgame.rs b/cli/forgame.rs
index ff8c0a794fcb079d92b2712ef749c4488b3a078e..3aaea0b654f78550bfa89fc497be65d9f7b8a359 100644 (file)
--- a/cli/forgame.rs
+++ b/cli/forgame.rs
@@ -143,8 +143,11 @@ mod reset_game {
             clear_game(&ma, &mut chan)?;
           }
           let progress = ma.progressbar()?;
-          let mut progress = termprogress::NestEqual::new(local.len(), progress);
-          for bundle in local {
+          let n_bundles = local.len();
+          let mut progress = termprogress::Nest::new(progress);
+          for (i, bundle) in local.into_iter().enumerate() {
+            progress.start_phase((i as f32)/(n_bundles as f32),
+                                 format!("{}/{}", i, n_bundles));
             bundle.upload(&ma, &mut chan, &mut progress)?;
           }
         },

diff --git a/support/termprogress.rs b/support/termprogress.rs
index 8426df76715763c5cae21bb8ae706122ecf24a21..5082cd4477ec04c3c9b380f9a454a9f2f0cd2f70 100644 (file)
--- a/support/termprogress.rs
+++ b/support/termprogress.rs
@@ -161,57 +161,52 @@ impl Drop for TermReporter {
   }
 }
 
-pub struct NestEqual {
-  outer_n: usize,
-  outer_i: usize,
-  inner_last_frac: f32,
+pub struct Nest {
+  outer_phase_base: f32,
+  outer_phase_size: f32,
+  desc_prefix: String,
   actual_reporter: Box<dyn Reporter>,
 }
 
-impl NestEqual {
+impl Nest {
   /// Assumes that every inner phase is of the same length as the first
-  pub fn new(outer_count: usize, actual_reporter: Box<dyn Reporter>)
-             -> Self { NestEqual {
+  pub fn new(actual_reporter: Box<dyn Reporter>)
+             -> Self { Nest {
     actual_reporter,
-    outer_n: outer_count,
-    outer_i: 0,
-    inner_last_frac: 0.,
+    outer_phase_base: 0.,
+    outer_phase_size: 0.,
+    desc_prefix: default(),
   } }
+
+  /// Starts an outer phase which is `frac` of the whole
+  ///
+  /// From now on, when reports are issued, the inner phases are each
+  /// mapped to the range "now" to "now" `frac`
+  pub fn start_phase(&mut self, frac: f32, desc_prefix: String) {
+    self.outer_phase_base = self.outer_phase_size;
+    self.outer_phase_size = frac;
+    self.desc_prefix = desc_prefix;
+  }
 }
 
-impl Reporter for NestEqual {
+impl Reporter for Nest {
   fn report(&mut self, inner_pi: &ProgressInfo<'_>) {
-    use progress::Value;
-
-    // Autodetect new outer phase item, when inner pahse rewinds
     let inner_frac = inner_pi.phase.value.fraction();
-    if inner_frac < self.inner_last_frac {
-      self.outer_i += 1;
-    }
-    self.inner_last_frac = inner_frac;
-
-    let desc = if self.outer_n > 1 {
-      format!("{}/{} {}", self.outer_i, self.outer_n,
-              &inner_pi.phase.desc).into()
-    } else  {
-      inner_pi.phase.desc.clone()
+    let outer_frac =
+      self.outer_phase_size * inner_frac +
+      self.outer_phase_base;
+
+    let desc = if self.desc_prefix != "" {
+      format!("{} {}", &self.desc_prefix, inner_pi.phase.desc).into()
+    } else {
+      (*inner_pi.phase.desc).into()
     };
 
-    let outer_value = match inner_pi.phase.value {
-      Value::Exact { i, n } => Value::Exact {
-        i: i + n * self.outer_i,
-        n:     n * self.outer_n,
-      },
-      Value::Fraction { f } => Value::Fraction {
-        f: f * (1.0 / self.outer_n as f32)
-           + Value::Exact { i: self.outer_i, n: self.outer_n }.fraction(),
-      },
-    };
+    let outer_value = progress::Value::Fraction { f: outer_frac };
     let outer_phase = progress::Count {
       desc,
       value: outer_value,
     };
-
     let outer_pi = ProgressInfo {
       phase: outer_phase,
       item:  inner_pi.item.clone(),