Move memory into its own module

execution-plan/src/lib.rs

@@ -11,33 +11,19 @@ use std::fmt;
 use api_endpoint::ApiEndpoint;
 use kittycad_modeling_cmds::{each_cmd, id::ModelingCmdId};
 use kittycad_modeling_session::{RunCommandError, Session as ModelingSession};
+use memory::Memory;
 use serde::{Deserialize, Serialize};
-use value::Value;
 
 use self::{arithmetic::Arithmetic, primitive::Primitive};
 
 mod api_endpoint;
 mod arithmetic;
+mod memory;
 mod primitive;
 #[cfg(test)]
 mod tests;
 mod value;
 
-/// KCEP's program memory. A flat, linear list of values.
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct Memory {
-    addresses: Vec<Option<Primitive>>,
-}
-
-impl Default for Memory {
-    fn default() -> Self {
-        Self {
-            addresses: vec![None; 1024],
-        }
-    }
-}
-
 /// An address in KCEP's program memory.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct Address(usize);
@@ -54,42 +40,6 @@ impl From<usize> for Address {
     }
 }
 
-impl Memory {
-    /// Get a value from KCEP's program memory.
-    pub fn get(&self, Address(addr): &Address) -> Option<&Primitive> {
-        self.addresses[*addr].as_ref()
-    }
-
-    /// Store a value in KCEP's program memory.
-    pub fn set(&mut self, Address(addr): Address, value: Primitive) {
-        // If isn't big enough for this value, double the size of memory until it is.
-        while addr > self.addresses.len() {
-            self.addresses.extend(vec![None; self.addresses.len()]);
-        }
-        self.addresses[addr] = Some(value);
-    }
-
-    /// Store a value value (i.e. a value which takes up multiple addresses in memory).
-    /// Store its parts in consecutive memory addresses starting at `start`.
-    /// Returns how many memory addresses the data took up.
-    pub fn set_composite<T: Value>(&mut self, start: Address, composite_value: T) -> usize {
-        let parts = composite_value.into_parts().into_iter();
-        let mut total_addrs = 0;
-        for (value, addr) in parts.zip(start.0..) {
-            self.addresses[addr] = Some(value);
-            total_addrs += 1;
-        }
-        total_addrs
-    }
-
-    /// Get a value value (i.e. a value which takes up multiple addresses in memory).
-    /// Its parts are stored in consecutive memory addresses starting at `start`.
-    pub fn get_composite<T: Value>(&self, start: Address) -> Result<T> {
-        let mut values = self.addresses.iter().skip(start.0).cloned();
-        T::from_parts(&mut values)
-    }
-}
-
 /// One step of the execution plan.
 #[derive(Serialize, Deserialize)]
 pub enum Instruction {

execution-plan/src/memory.rs

@@ -0,0 +1,57 @@
+use super::Result;
+use crate::{primitive::Primitive, value::Value, Address};
+
+/// KCEP's program memory. A flat, linear list of values.
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct Memory {
+    addresses: Vec<Option<Primitive>>,
+}
+
+impl Default for Memory {
+    fn default() -> Self {
+        Self {
+            addresses: vec![None; 1024],
+        }
+    }
+}
+
+impl Memory {
+    /// Get a value from KCEP's program memory.
+    pub fn get(&self, Address(addr): &Address) -> Option<&Primitive> {
+        self.addresses[*addr].as_ref()
+    }
+
+    /// Store a value in KCEP's program memory.
+    pub fn set(&mut self, Address(addr): Address, value: Primitive) {
+        // If isn't big enough for this value, double the size of memory until it is.
+        while addr > self.addresses.len() {
+            self.addresses.extend(vec![None; self.addresses.len()]);
+        }
+        self.addresses[addr] = Some(value);
+    }
+
+    /// Store a value value (i.e. a value which takes up multiple addresses in memory).
+    /// Store its parts in consecutive memory addresses starting at `start`.
+    /// Returns how many memory addresses the data took up.
+    pub fn set_composite<T: Value>(&mut self, start: Address, composite_value: T) -> usize {
+        let parts = composite_value.into_parts().into_iter();
+        let mut total_addrs = 0;
+        for (value, addr) in parts.zip(start.0..) {
+            self.addresses[addr] = Some(value);
+            total_addrs += 1;
+        }
+        total_addrs
+    }
+
+    /// Get a value value (i.e. a value which takes up multiple addresses in memory).
+    /// Its parts are stored in consecutive memory addresses starting at `start`.
+    pub fn get_composite<T: Value>(&self, start: Address) -> Result<T> {
+        let mut values = self.addresses.iter().skip(start.0).cloned();
+        T::from_parts(&mut values)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (usize, &Option<Primitive>)> {
+        self.addresses.iter().enumerate()
+    }
+}

execution-plan/src/tests.rs

@@ -303,9 +303,7 @@ fn debug_dump_memory(mem: &Memory) -> String {
         value: String,
     }
     let table_data: Vec<_> =
-        mem.addresses
-            .iter()
-            .enumerate()
+        mem.iter()
             .filter_map(|(i, val)| {
                 if let Some(val) = val {
                     let (val_type, value) = val.pretty_print();