refactor: apply rustfmt rules

Author: FilippoVissani

src/core/export.rs

@@ -1,26 +1,25 @@
-use std::any::Any;
-use std::collections::HashMap;
 use crate::core::export::export::Export;
 use crate::core::path::path::path::Path;
+use std::any::Any;
+use std::collections::HashMap;
 
 pub mod export {
+    use crate::core::path::path::path::Path;
     use std::any::Any;
     use std::collections::HashMap;
-    use crate::core::path::path::path::Path;
 
     /// Abstraction for the result of local computation.
     /// It is an AST decorated with the computation value.
     #[derive(Debug)]
-    pub struct Export{
+    pub struct Export {
         pub(crate) map: HashMap<Path, Box<dyn Any>>,
     }
 }
 
 impl Export {
-
     /// Creates an Export with the passed HashMap.
     pub fn new(map: HashMap<Path, Box<dyn Any>>) -> Self {
-        Export{ map }
+        Export { map }
     }
 
     /// Inserts a value in the Export at the given Path.
@@ -30,7 +29,9 @@ impl Export {
 
     /// Returns the value at the given Path.
     pub fn get<A: 'static>(&self, path: &Path) -> Option<&A> {
-        self.map.get(path).and_then(|value| value.downcast_ref::<A>())
+        self.map
+            .get(path)
+            .and_then(|value| value.downcast_ref::<A>())
     }
 
     /// Returns the root value.
@@ -46,8 +47,8 @@ impl Export {
 
 #[cfg(test)]
 mod tests {
-    use crate::core::path::slot::slot::Slot::{Nbr, Rep};
     use super::*;
+    use crate::core::path::slot::slot::Slot::{Nbr, Rep};
 
     #[test]
     fn test_new_empty() {
@@ -78,7 +79,10 @@ mod tests {
         let mut map: HashMap<Path, Box<dyn Any>> = HashMap::new();
         map.insert(Path::new(vec![Rep(0), Nbr(0)]), Box::new(10));
         let export = Export::new(map);
-        assert_eq!(export.get::<i32>(&Path::new(vec![Rep(0), Nbr(0)])).unwrap(), &10);
+        assert_eq!(
+            export.get::<i32>(&Path::new(vec![Rep(0), Nbr(0)])).unwrap(),
+            &10
+        );
     }
 
     #[test]
@@ -107,7 +111,7 @@ mod tests {
     }
 
     #[test]
-    fn test_paths(){
+    fn test_paths() {
         let mut map: HashMap<Path, Box<dyn Any>> = HashMap::new();
         let mut map2: HashMap<Path, Box<dyn Any>> = HashMap::new();
         map.insert(Path::new(vec![]), Box::new(10));

src/core/export_factory.rs

@@ -1,9 +1,9 @@
 pub mod export_factory {
-    use std::any::Any;
-    use std::collections::HashMap;
     use crate::core::export::export::Export;
     use crate::core::path::path::path::Path;
     use crate::core::path::slot::slot::Slot;
+    use std::any::Any;
+    use std::collections::HashMap;
 
     /// Returns an empty Path.
     pub fn empty_path() -> Path {
@@ -22,8 +22,8 @@ pub mod export_factory {
 
     /// Returns an Export with the given HashMap.
     pub fn export_from(exps: Vec<(Path, Box<dyn Any>)>) -> Export {
-        Export{
-            map: HashMap::from_iter(exps.into_iter())
+        Export {
+            map: HashMap::from_iter(exps.into_iter()),
         }
     }
 }
@@ -46,8 +46,14 @@ mod tests {
     fn test_root_path() {
         let mut export: Export = empty_export();
         export.put(empty_path(), String::from("foo"));
-        assert_eq!(export.get::<String>(&empty_path()).unwrap(), export.root::<String>());
-        assert_eq!(export.get::<String>(&empty_path()), Some(&String::from("foo")));
+        assert_eq!(
+            export.get::<String>(&empty_path()).unwrap(),
+            export.root::<String>()
+        );
+        assert_eq!(
+            export.get::<String>(&empty_path()),
+            Some(&String::from("foo"))
+        );
     }
 
     #[test]
@@ -62,7 +68,10 @@ mod tests {
     fn test_overwriting_with_different_type() {
         let mut export: Export = empty_export();
         export.put(empty_path(), String::from("foo"));
-        assert_eq!(export.get::<String>(&empty_path()), Some(&String::from("foo")));
+        assert_eq!(
+            export.get::<String>(&empty_path()),
+            Some(&String::from("foo"))
+        );
         export.put(empty_path(), 77);
         assert_eq!(export.get::<i32>(&empty_path()).unwrap(), &77);
     }

src/core/mod.rs

@@ -1,4 +1,4 @@
-pub mod vm;
-pub mod path;
 pub mod export;
-pub mod export_factory;
+pub mod export_factory;
+pub mod path;
+pub mod vm;

src/core/path/mod.rs

@@ -1,2 +1,2 @@
 pub mod path;
-pub mod slot;
+pub mod slot;

src/core/path/path.rs

@@ -12,7 +12,6 @@ use crate::core::path::path::path::Path;
 use crate::core::path::slot::slot::Slot;
 
 impl Path {
-
     /// Factory method to create a new Path
     pub fn new(slots: Vec<Slot>) -> Self {
         Path { slots }
@@ -41,8 +40,11 @@ impl Path {
     pub fn to_str(&self) -> String {
         let slots = &self.slots;
         let path = String::from("P://");
-        path +
-            &slots.into_iter().map(|slot| slot.to_str()).collect::<Vec<String>>().join("/")
+        path + &slots
+            .into_iter()
+            .map(|slot| slot.to_str())
+            .collect::<Vec<String>>()
+            .join("/")
     }
 
     /// Check if the Path matches another Path
@@ -59,7 +61,7 @@ impl Path {
 #[cfg(test)]
 mod tests {
     use crate::core::path::path::path::Path;
-    use crate::core::path::slot::slot::Slot::{Nbr, Rep, Branch};
+    use crate::core::path::slot::slot::Slot::{Branch, Nbr, Rep};
 
     #[test]
     fn test_is_root() {
@@ -113,4 +115,4 @@ mod tests {
         assert!(path.matches(&Path::new(vec![Rep(0), Nbr(0), Nbr(1), Branch(0)])));
         assert!(!path.matches(&Path::new(vec![Nbr(0), Nbr(1), Branch(0)])))
     }
-}
+}

src/core/path/slot.rs

@@ -2,37 +2,36 @@ use crate::core::path::slot::slot::Slot;
 
 /// A slot is a representation for a construct of the language that forms an execution path.
 pub mod slot {
-    
+
     /// Slot is an enum that represents the different constructs of the language.
     /// Can be Nbr(index), Rep(index), Branch(index) or Exchange(index).
     #[derive(PartialEq, Debug, Clone, Eq, Hash)]
-    pub enum Slot{
+    pub enum Slot {
         Nbr(i32),
         Rep(i32),
         Branch(i32),
         Exchange(i32),
     }
 }
 
-impl Slot{
-    
+impl Slot {
     /// Return a String representation of the Slot.
     pub fn to_str(&self) -> String {
         match self {
-            Slot::Nbr(index) => "Nbr(".to_owned()+&index.to_string()+")",
-            Slot::Rep(index) => "Rep(".to_owned()+&index.to_string()+")",
-            Slot::Branch(index) => "Branch(".to_owned()+&index.to_string()+")",
-            Slot::Exchange(index) => "Exchange(".to_owned()+&index.to_string()+")",
+            Slot::Nbr(index) => "Nbr(".to_owned() + &index.to_string() + ")",
+            Slot::Rep(index) => "Rep(".to_owned() + &index.to_string() + ")",
+            Slot::Branch(index) => "Branch(".to_owned() + &index.to_string() + ")",
+            Slot::Exchange(index) => "Exchange(".to_owned() + &index.to_string() + ")",
         }
     }
 }
 
 #[cfg(test)]
-mod test{
+mod test {
     use super::*;
 
     #[test]
-    fn test_slot_creation(){
+    fn test_slot_creation() {
         let nbr = Slot::Nbr(0);
         let rep = Slot::Rep(0);
         let branch = Slot::Branch(0);
@@ -54,4 +53,4 @@ mod test{
         assert_eq!(branch.to_str(), "Branch(0)");
         assert_eq!(exchange.to_str(), "Exchange(0)");
     }
-}
+}

src/core/vm/mod.rs

@@ -1,2 +1,2 @@
+pub mod round_vm;
 pub mod vm_status;
-pub mod round_vm;

src/core/vm/round_vm.rs

@@ -1,3 +1 @@
-pub mod round_vm {
-
-}
+pub mod round_vm {}

src/core/vm/vm_status.rs

@@ -1,3 +1 @@
-pub mod vm_status {
-
-}
+pub mod vm_status {}