From 9f2da3c30f30ec2fd9dccb46bc382f2355388610 Mon Sep 17 00:00:00 2001
From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Mon, 16 May 2022 03:09:08 +0100
Subject: [PATCH] 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>
---
 cli/forgame.rs          |  7 +++--
 support/termprogress.rs | 65 +++++++++++++++++++----------------------
 2 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/cli/forgame.rs b/cli/forgame.rs
index ff8c0a79..3aaea0b6 100644
--- 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 8426df76..5082cd44 100644
--- 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(),
-- 
2.30.2