Move SpecifiedValue into its own module

app-proto/src/assembly.rs

@@ -1,15 +1,14 @@
 use nalgebra::{DMatrix, DVector, DVectorView, Vector3};
 use rustc_hash::FxHashMap;
 use slab::Slab;
-use std::{
-    collections::BTreeSet,
-    num::ParseFloatError,
-    sync::atomic::{AtomicU64, Ordering}
-};
+use std::{collections::BTreeSet, sync::atomic::{AtomicU64, Ordering}};
 use sycamore::prelude::*;
 use web_sys::{console, wasm_bindgen::JsValue}; /* DEBUG */
 
-use crate::engine::{Q, local_unif_to_std, realize_gram, ConfigSubspace, PartialMatrix};
+use crate::{
+    engine::{Q, local_unif_to_std, realize_gram, ConfigSubspace, PartialMatrix},
+    specified::{SpecifiedValue, SpecifiedValue::{Absent, Present}}
+};
 
 // the types of the keys we use to access an assembly's elements and regulators
 pub type ElementKey = usize;
@@ -118,61 +117,6 @@ impl Element {
     }
 }
 
-// to construct a `SpecifiedValue` that might be `Present`, use the associated
-// function `try_from`. this ensures that `spec` is always a valid specification
-// of `value` according to the format discussed at the implementation of
-// `TryFrom<String>`
-pub enum SpecifiedValue {
-    Absent,
-    Present {
-        spec: String,
-        value: f64
-    }
-}
-
-use SpecifiedValue::*;
-
-impl SpecifiedValue {
-    // get the specification for this value. the associated function `try_from`
-    // is essentially a left inverse of this method:
-    //
-    //   SpecifiedValue::try_from(x.spec()) == Ok(x)
-    //
-    pub fn spec(&self) -> String {
-        match self {
-            Absent => String::new(),
-            Present { spec, .. } => spec.clone()
-        }
-    }
-    
-    fn is_present(&self) -> bool {
-        match self {
-            Absent => false,
-            Present { .. } => true
-        }
-    }
-}
-
-// we can try to turn a specification string into a `SpecifiedValue`. if the
-// specification is empty, the `SpecifiedValue` is `Absent`. if the
-// specification parses to a floating-point value `x`, the `SpecifiedValue` is
-// `Present`, with a `value` of `x`, and the specification is stored in `spec`.
-// these are currently the only valid specifications; any other produces an
-// error
-impl TryFrom<String> for SpecifiedValue {
-    type Error = ParseFloatError;
-    
-    fn try_from(spec: String) -> Result<Self, Self::Error> {
-        if spec.is_empty() {
-            Ok(Absent)
-        } else {
-            spec.parse::<f64>().map(
-                |value| Present { spec: spec, value: value }
-            )
-        }
-    }
-}
-
 #[derive(Clone, Copy)]
 pub struct Regulator {
     pub subjects: (ElementKey, ElementKey),

app-proto/src/main.rs

@@ -3,6 +3,7 @@ mod assembly;
 mod display;
 mod engine;
 mod outline;
+mod specified;
 
 use rustc_hash::FxHashSet;
 use sycamore::prelude::*;

app-proto/src/outline.rs

@@ -12,10 +12,9 @@ use crate::{
     assembly::{
         ElementKey,
         Regulator,
-        RegulatorKey,
-        SpecifiedValue,
-        SpecifiedValue::*
-    }
+        RegulatorKey
+    },
+    specified::{SpecifiedValue, SpecifiedValue::{Absent, Present}}
 };
 
 // an editable view of a regulator

app-proto/src/specified.rs

@@ -0,0 +1,56 @@
+use std::num::ParseFloatError;
+
+// to construct a `SpecifiedValue` that might be `Present`, use the associated
+// function `try_from`. this ensures that `spec` is always a valid specification
+// of `value` according to the format discussed at the implementation of
+// `TryFrom<String>`
+pub enum SpecifiedValue {
+    Absent,
+    Present {
+        spec: String,
+        value: f64
+    }
+}
+
+use SpecifiedValue::{Absent, Present};
+
+impl SpecifiedValue {
+    // get the specification for this value. the associated function `try_from`
+    // is essentially a left inverse of this method:
+    //
+    //   SpecifiedValue::try_from(x.spec()) == Ok(x)
+    //
+    pub fn spec(&self) -> String {
+        match self {
+            Absent => String::new(),
+            Present { spec, .. } => spec.clone()
+        }
+    }
+    
+    pub fn is_present(&self) -> bool {
+        match self {
+            Absent => false,
+            Present { .. } => true
+        }
+    }
+}
+
+// we can try to turn a specification string into a `SpecifiedValue`. if the
+// specification is empty, the `SpecifiedValue` is `Absent`. if the
+// specification parses to a floating-point value `x`, the `SpecifiedValue` is
+// `Present`, with a `value` of `x`, and the specification is stored in `spec`.
+// these are currently the only valid specifications; any other produces an
+// error
+impl TryFrom<String> for SpecifiedValue {
+    type Error = ParseFloatError;
+    
+    fn try_from(spec: String) -> Result<Self, Self::Error> {
+        if spec.is_empty() {
+            Ok(Absent)
+        } else {
+            spec.parse::<f64>().map(
+                |value| Present { spec: spec, value: value }
+            )
+        }
+    }
+}