Add OpticPorts to OpticNode / Optical

src/error.rs

@@ -2,5 +2,6 @@
 pub enum OpossumError {
   OpticScenery(String),
   OpticGroup(String),
+  OpticPort(String),
   Other(String)
 }
\ No newline at end of file

src/lib.rs

@@ -4,7 +4,7 @@
 pub mod optic_scenery;
 /// The basic structure representing an optical element
 pub mod optic_node;
-pub mod optic_port;
+pub mod optic_ports;
 
 pub mod nodes;
 

src/optic_node.rs

 use std::fmt::Debug;
+
+use crate::optic_ports::OpticPorts;
 /// An [`OpticNode`] is the basic struct representing an optical component.
 pub struct OpticNode {
     name: String,
     node: Box<dyn Optical>,
     inverted: bool,
+    ports: OpticPorts
 }
 
 impl OpticNode {
@@ -18,11 +21,13 @@ impl OpticNode {
     ///
     /// let node=OpticNode::new("My node", Box::new(NodeDummy));
     /// ```
-    pub fn new(name: &str, node: Box<dyn Optical>) -> Self {
+    pub fn new(name: &str, node_type: Box<dyn Optical>) -> Self {
+        let ports=node_type.ports();
         Self {
             name: name.into(),
-            node: node,
+            node: node_type,
             inverted: false,
+            ports: ports
         }
     }
     /// Sets the name of this [`OpticNode`].
@@ -52,6 +57,10 @@ impl OpticNode {
     pub fn inverted(&self) -> bool {
         self.inverted
     }
+    /// Returns a reference to the [`OpticPorts`] of this [`OpticNode`].
+    pub fn ports(&self) -> &OpticPorts {
+        &self.ports
+    }
 }
 
 impl Debug for OpticNode {
@@ -71,6 +80,9 @@ pub trait Optical {
         let inv_string = if inverted { "(inv)" } else { "" };
         format!("  {} [label=\"{}{}\"]\n", node_index, name, inv_string)
     }
+    fn ports(&self) -> OpticPorts {
+        OpticPorts::default()
+    }
 }
 
 #[cfg(test)]

src/optic_port.rs

-#[derive(Debug, PartialEq, Clone)]
-pub enum OpticPortDirection {
-    Incoming,
-    Outgoing,
-}
-impl OpticPortDirection {
-    fn invert(self) -> OpticPortDirection {
-        if self == OpticPortDirection::Incoming {
-            OpticPortDirection::Outgoing
-        } else {
-            OpticPortDirection::Incoming
-        }
-    }
-}
-#[derive(Debug)]
-pub struct OpticPort {
-    name: String,
-    direction: OpticPortDirection,
-}
-
-impl OpticPort {
-    pub fn new(name: &str, direction: OpticPortDirection) -> Self {
-        Self{ name: name.into(), direction: direction }
-    }
-
-    pub fn set_name(&mut self, name: &str) {
-        self.name = name.into();
-    }
-
-    pub fn name(&self) -> &str {
-        self.name.as_ref()
-    }
-
-    pub fn set_direction(&mut self, direction: OpticPortDirection) {
-        self.direction = direction;
-    }
-
-    pub fn direction(&self) -> &OpticPortDirection {
-        &self.direction
-    }
-
-    pub fn invert(&mut self) {
-        self.direction = self.direction.clone().invert();
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::optic_port::{OpticPort,OpticPortDirection};
-    #[test]
-    fn new() {
-        let port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        assert_eq!(port.name, "Test");
-        assert_eq!(port.direction, OpticPortDirection::Incoming);
-    }
-    #[test]
-    fn set_name() {
-        let mut port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        port.set_name("Test2");
-        assert_eq!(port.name, "Test2");
-        assert_eq!(port.direction, OpticPortDirection::Incoming);
-    }
-    #[test]
-    fn name() {
-        let port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        assert_eq!(port.name(), "Test");
-    }
-    #[test]
-    fn set_direction() {
-        let mut port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        port.set_direction(OpticPortDirection::Outgoing);
-        assert_eq!(port.name, "Test");
-        assert_eq!(port.direction, OpticPortDirection::Outgoing);
-    }
-    #[test]
-    fn direction() {
-        let port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        assert_eq!(port.direction(), &OpticPortDirection::Incoming);
-    }
-    #[test]
-    fn invert() {
-        let mut port = OpticPort::new("Test", OpticPortDirection::Incoming);
-        port.invert();
-        assert_eq!(port.direction, OpticPortDirection::Outgoing);
-        assert_eq!(port.name, "Test");
-    }
-}

src/optic_ports.rs

+use std::{collections::HashSet, mem::swap};
+use crate::error::OpossumError;
+
+#[derive(Default, Debug)]
+pub struct OpticPorts {
+    inputs: HashSet<String>,
+    outputs: HashSet<String>,
+}
+
+impl OpticPorts {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn inputs(&self) -> Vec<String> {
+        let v = self.inputs.clone().into_iter().collect::<Vec<String>>();
+        v
+    }
+    pub fn outputs(&self) -> Vec<String> {
+        let v = self.outputs.clone().into_iter().collect::<Vec<String>>();
+        v
+    }
+    pub fn add_input(&mut self, name: &str) -> Result<(),OpossumError> {
+        if self.inputs.insert(name.into()) {
+            Ok(()) }
+            else {
+                Err(OpossumError::OpticPort(format!("input port with name {} already exists",name)))
+            }
+    }
+    pub fn add_output(&mut self, name: &str) -> Result<(),OpossumError> {
+        if self.outputs.insert(name.into()) {
+            Ok(()) }
+            else {
+                Err(OpossumError::OpticPort(format!("output port with name {} already exists",name)))
+            }
+    }
+    pub fn invert(&mut self) {
+        swap(&mut self.inputs,&mut self.outputs);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::optic_ports::{OpticPorts};
+    #[test]
+    fn new() {
+        let ports = OpticPorts::new();
+        assert_eq!(ports.inputs.len(), 0);
+        assert_eq!(ports.outputs.len(), 0);
+    }
+    #[test]
+    fn add_input_ok() {
+        let mut ports = OpticPorts::new();
+        assert!(ports.add_input("Test").is_ok());
+        assert_eq!(ports.inputs.len(), 1);
+    }
+    #[test]
+    fn add_input_twice() {
+        let mut ports = OpticPorts::new();
+        assert!(ports.add_input("Test").is_ok());
+        assert!(ports.add_input("Test").is_err());
+        assert_eq!(ports.inputs.len(), 1);
+    }
+    #[test]
+    fn add_output_ok() {
+        let mut ports = OpticPorts::new();
+        assert!(ports.add_output("Test").is_ok());
+        assert_eq!(ports.outputs.len(), 1);
+    }
+    #[test]
+    fn add_output_twice() {
+        let mut ports = OpticPorts::new();
+        assert!(ports.add_output("Test").is_ok());
+        assert!(ports.add_output("Test").is_err());
+        assert_eq!(ports.outputs.len(), 1);
+    }
+    #[test]
+    fn inputs() {
+        let mut ports = OpticPorts::new();
+        ports.add_input("Test1").unwrap();
+        ports.add_input("Test2").unwrap();
+        let mut v=ports.inputs();
+        v.sort();
+        assert_eq!(v, vec!["Test1".to_string(), "Test2".to_string()]);
+    }
+    #[test]
+    fn outputs() {
+        let mut ports = OpticPorts::new();
+        ports.add_output("Test1").unwrap();
+        ports.add_output("Test2").unwrap();
+        let mut v=ports.outputs();
+        v.sort();
+        assert_eq!(v, vec!["Test1".to_string(), "Test2".to_string()]);
+    }
+}