SerializerRenderer supports more use-cases

e.g. not casting to StaticSim; different file names

src/render.rs

@@ -664,30 +664,52 @@ impl<S: GenericSim> SerializedFrame<S> {
 }
 
 pub struct SerializerRenderer {
-    out_base: String
+    fmt_str: String,
+    prefer_static: bool,
 }
 
 impl SerializerRenderer {
-    pub fn new(out_base: &str) -> Self {
+    /// `fmt_str` is a format string which will be formatted with
+    /// `{step_no}` set to the relevant simulation step.
+    pub fn new(fmt_str: &str) -> Self {
         Self {
-            out_base: out_base.into(),
+            fmt_str: fmt_str.into(),
+            prefer_static: false,
+        }
+    }
+
+    /// Same as `new`, but cast to StaticSim before serializing. This tends to result in a smaller
+    /// file.
+    pub fn new_static(fmt_str: &str) -> Self {
+        Self {
+            fmt_str: fmt_str.into(),
+            prefer_static: true,
         }
     }
 }
 
-impl<S: GenericSim + Clone + Serialize> Renderer<S> for SerializerRenderer {
-    fn render_z_slice(&self, state: &S, z: u32, measurements: &[Box<dyn AbstractMeasurement>], config: RenderConfig) {
-        default_render_z_slice(self, state, z, measurements, config)
-    }
-    fn render(&self, state: &S, measurements: &[Box<dyn AbstractMeasurement>], _config: RenderConfig) {
+impl SerializerRenderer {
+    fn serialize<S: GenericSim + Serialize>(&self, state: &S, measurements: &[Box<dyn AbstractMeasurement>]) {
         let frame = SerializedFrame {
-            // N.B.: `to_static` isn't 100% necessary here, but it tends to result in a smaller file.
-            state: state.to_static(),
+            state,
             measurements: measurements.iter().cloned().collect(),
         };
-        let name = format!("{}{}.bc", self.out_base, frame.state.step_no());
+        let name = self.fmt_str.replace("{step_no}", &*frame.state.step_no().to_string());
         let out = BufWriter::new(File::create(name).unwrap());
         //serde_cbor::to_writer(out, &snap).unwrap();
         bincode::serialize_into(out, &frame).unwrap();
     }
 }
+
+impl<S: GenericSim + Serialize> Renderer<S> for SerializerRenderer {
+    fn render_z_slice(&self, state: &S, z: u32, measurements: &[Box<dyn AbstractMeasurement>], config: RenderConfig) {
+        default_render_z_slice(self, state, z, measurements, config)
+    }
+    fn render(&self, state: &S, measurements: &[Box<dyn AbstractMeasurement>], _config: RenderConfig) {
+        if self.prefer_static {
+            self.serialize(&state.to_static(), measurements);
+        } else {
+            self.serialize(state, measurements);
+        }
+    }
+}