Refactor navi/segdense

navi/segdense/src/error.rs

@@ -5,39 +5,49 @@ use std::fmt::Display;
  */
 #[derive(Debug)]
 pub enum SegDenseError {
-  IoError(std::io::Error),
-  Json(serde_json::Error),
-  JsonMissingRoot,
-  JsonMissingObject,
-  JsonMissingArray,
-  JsonArraySize,
-  JsonMissingInputFeature,
+    IoError(std::io::Error),
+    Json(serde_json::Error),
+    JsonMissingRoot,
+    JsonMissingObject,
+    JsonMissingArray,
+    JsonArraySize,
+    JsonMissingInputFeature,
 }
 
 impl Display for SegDenseError {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    match self {
-      SegDenseError::IoError(io_error) => write!(f, "{}", io_error),
-      SegDenseError::Json(serde_json) => write!(f, "{}", serde_json),
-      SegDenseError::JsonMissingRoot => write!(f, "{}", "SegDense JSON: Root Node note found!"),
-      SegDenseError::JsonMissingObject => write!(f, "{}", "SegDense JSON: Object note found!"),
-      SegDenseError::JsonMissingArray => write!(f, "{}", "SegDense JSON: Array Node note found!"),
-      SegDenseError::JsonArraySize => write!(f, "{}", "SegDense JSON: Array size not as expected!"),
-      SegDenseError::JsonMissingInputFeature => write!(f, "{}", "SegDense JSON: Missing input feature!"),
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SegDenseError::IoError(io_error) => write!(f, "{io_error}"),
+            SegDenseError::Json(serde_json) => write!(f, "{serde_json}"),
+            SegDenseError::JsonMissingRoot => {
+                write!(f, "SegDense JSON: Root Node note found!")
+            }
+            SegDenseError::JsonMissingObject => {
+                write!(f, "SegDense JSON: Object note found!")
+            }
+            SegDenseError::JsonMissingArray => {
+                write!(f, "SegDense JSON: Array Node note found!")
+            }
+            SegDenseError::JsonArraySize => {
+                write!(f, "SegDense JSON: Array size not as expected!")
+            }
+            SegDenseError::JsonMissingInputFeature => {
+                write!(f, "SegDense JSON: Missing input feature!")
+            }
+        }
     }
-  }
 }
 
 impl std::error::Error for SegDenseError {}
 
 impl From<std::io::Error> for SegDenseError {
-  fn from(err: std::io::Error) -> Self {
-    SegDenseError::IoError(err)
-  }
+    fn from(err: std::io::Error) -> Self {
+        SegDenseError::IoError(err)
+    }
 }
 
 impl From<serde_json::Error> for SegDenseError {
-  fn from(err: serde_json::Error) -> Self {
-    SegDenseError::Json(err)
-  }
+    fn from(err: serde_json::Error) -> Self {
+        SegDenseError::Json(err)
+    }
 }

navi/segdense/src/lib.rs

@@ -1,4 +1,4 @@
 pub mod error;
-pub mod segdense_transform_spec_home_recap_2022; 
 pub mod mapper;
-pub mod util;
+pub mod segdense_transform_spec_home_recap_2022;
+pub mod util;

navi/segdense/src/main.rs

@@ -5,19 +5,18 @@ use segdense::error::SegDenseError;
 use segdense::util;
 
 fn main() -> Result<(), SegDenseError> {
-  env_logger::init();
-  let args: Vec<String> = env::args().collect();
-
-  let schema_file_name: &str = if args.len() == 1 {
-    "json/compact.json"
-  } else {
-    &args[1]
-  };
+    env_logger::init();
+    let args: Vec<String> = env::args().collect();
 
-  let json_str = fs::read_to_string(schema_file_name)?;
+    let schema_file_name: &str = if args.len() == 1 {
+        "json/compact.json"
+    } else {
+        &args[1]
+    };
 
-  util::safe_load_config(&json_str)?;
+    let json_str = fs::read_to_string(schema_file_name)?;
 
-  Ok(())
-}
+    util::safe_load_config(&json_str)?;
 
+    Ok(())
+}

navi/segdense/src/mapper.rs

@@ -19,13 +19,13 @@ pub struct FeatureMapper {
 impl FeatureMapper {
     pub fn new() -> FeatureMapper {
         FeatureMapper {
-            map: HashMap::new()
+            map: HashMap::new(),
         }
     }
 }
 
 pub trait MapWriter {
-    fn set(&mut self, feature_id: i64, info: FeatureInfo); 
+    fn set(&mut self, feature_id: i64, info: FeatureInfo);
 }
 
 pub trait MapReader {

navi/segdense/src/segdense_transform_spec_home_recap_2022.rs

@@ -164,7 +164,6 @@ pub struct ComplexFeatureTypeTransformSpec {
     pub tensor_shape: Vec<i64>,
 }
 
-
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InputFeatureMapRecord {

navi/segdense/src/util.rs

@@ -1,23 +1,21 @@
+use log::debug;
 use std::fs;
-use log::{debug};
 
-use serde_json::{Value, Map};
+use serde_json::Value;
 
 use crate::error::SegDenseError;
-use crate::mapper::{FeatureMapper, FeatureInfo, MapWriter};
+use crate::mapper::{FeatureInfo, FeatureMapper, MapWriter};
 use crate::segdense_transform_spec_home_recap_2022::{self as seg_dense, InputFeature};
 
 pub fn load_config(file_name: &str) -> seg_dense::Root {
-    let json_str = fs::read_to_string(file_name).expect(
-        &format!("Unable to load segdense file {}", file_name));
-    let seg_dense_config = parse(&json_str).expect(
-        &format!("Unable to parse segdense file {}", file_name));
-    return seg_dense_config;
+    let json_str = fs::read_to_string(file_name)
+        .unwrap_or_else(|_| panic!("Unable to load segdense file {file_name}"));
+    parse(&json_str).unwrap_or_else(|_| panic!("Unable to parse segdense file {file_name}"))
 }
 
 pub fn parse(json_str: &str) -> Result<seg_dense::Root, SegDenseError> {
     let root: seg_dense::Root = serde_json::from_str(json_str)?;
-    return Ok(root);
+    Ok(root)
 }
 
 /**
@@ -41,72 +39,60 @@ pub fn parse(json_str: &str) -> Result<seg_dense::Root, SegDenseError> {
  */
 pub fn safe_load_config(json_str: &str) -> Result<FeatureMapper, SegDenseError> {
     let root = parse(json_str)?;
-    load_from_parsed_config(root)
+    load_from_parsed_config(&root)
 }
 
 pub fn load_from_parsed_config_ref(root: &seg_dense::Root) -> FeatureMapper {
-    load_from_parsed_config(root.clone()).unwrap_or_else(
-      |error| panic!("Error loading all_config.json - {}", error))
+    load_from_parsed_config(root)
+        .unwrap_or_else(|error| panic!("Error loading all_config.json - {error}"))
 }
 
-// Perf note : make 'root' un-owned
-pub fn load_from_parsed_config(root: seg_dense::Root) ->
-    Result<FeatureMapper, SegDenseError> {
-
-    let v = root.input_features_map;
-
+pub fn load_from_parsed_config(root: &seg_dense::Root) -> Result<FeatureMapper, SegDenseError> {
     // Do error check
-    let map: Map<String, Value> = match v {
-        Value::Object(map) => map,
-        _ => return Err(SegDenseError::JsonMissingObject),
+    let map = if let Value::Object(ref map) = root.input_features_map {
+        map
+    } else {
+        return Err(SegDenseError::JsonMissingObject);
     };
 
     let mut fm: FeatureMapper = FeatureMapper::new();
 
-    let items = map.values();
-
-    // Perf : Consider a way to avoid clone here
-    for item in items.cloned() {
-        let mut vec = match item {
+    for item in map.values() {
+        let vec = match item {
             Value::Array(v) => v,
             _ => return Err(SegDenseError::JsonMissingArray),
         };
 
-        if vec.len() != 1 {
+        let len = vec.len();
+        if len != 1 {
             return Err(SegDenseError::JsonArraySize);
         }
 
-        let val = vec.pop().unwrap();
+        let val = vec[len - 1].clone();
 
         let input_feature: seg_dense::InputFeature = serde_json::from_value(val)?;
         let feature_id = input_feature.feature_id;
         let feature_info = to_feature_info(&input_feature);
 
-        match feature_info {
-            Some(info) => {
-                debug!("{:?}", info);
-                fm.set(feature_id, info)
-            },
-            None => (),
+        if let Some(info) = feature_info {
+            debug!("{info:?}");
+            fm.set(feature_id, info)
         }
     }
 
     Ok(fm)
 }
 #[allow(dead_code)]
-fn add_feature_info_to_mapper(feature_mapper: &mut FeatureMapper, input_features: &Vec<InputFeature>) {
+fn add_feature_info_to_mapper(feature_mapper: &mut FeatureMapper, input_features: &[InputFeature]) {
     for input_feature in input_features.iter() {
-            let feature_id = input_feature.feature_id;
-            let feature_info = to_feature_info(input_feature);
-
-            match feature_info {
-                Some(info) => {
-                    debug!("{:?}", info);
-                    feature_mapper.set(feature_id, info)
-                },
-                None => (),
-            }
+        let feature_id = input_feature.feature_id;
+        let feature_info = to_feature_info(input_feature);
+
+        if let Some(info) = feature_info {
+            debug!("{info:?}");
+            feature_mapper.set(feature_id, info)
         }
+    }
 }
 
 pub fn to_feature_info(input_feature: &seg_dense::InputFeature) -> Option<FeatureInfo> {
@@ -139,7 +125,7 @@ pub fn to_feature_info(input_feature: &seg_dense::InputFeature) -> Option<Featur
             2 => 0,
             3 => 2,
             _ => -1,
-        }
+        },
     };
 
     if input_feature.index < 0 {
@@ -156,4 +142,3 @@ pub fn to_feature_info(input_feature: &seg_dense::InputFeature) -> Option<Featur
         index_within_tensor: input_feature.index,
     })
 }
-