Support base / implementation / application data types

autosar-data-abstraction/src/communication/cluster/mod.rs

@@ -17,12 +17,13 @@ pub trait AbstractCluster: AbstractionElement {
             let path = self.element().path().ok()?;
             let refs = model.get_references_to(&path);
 
-            for system in refs
+            if let Some(system) = refs
                 .iter()
                 .filter_map(|weak| weak.upgrade())
                 .filter(|elem| elem.element_name() == ElementName::FibexElementRef)
                 .filter_map(|elem| elem.named_parent().ok().flatten())
                 .filter_map(|parent| System::try_from(parent).ok())
+                .next()
             {
                 return Some(system);
             }
@@ -76,3 +77,46 @@ impl From<FlexrayCluster> for Cluster {
         Cluster::FlexRay(value)
     }
 }
+
+//##################################################################
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ArPackage;
+    use autosar_data::{AutosarModel, AutosarVersion};
+
+    #[test]
+    fn cluster_system() {
+        let model = AutosarModel::new();
+        let _file = model.create_file("test.arxml", AutosarVersion::LATEST).unwrap();
+        let package = ArPackage::get_or_create(&model, "/Test").unwrap();
+        let system = System::new("System", &package, crate::SystemCategory::EcuExtract).unwrap();
+        let settings = CanClusterSettings::default();
+        let can_cluster = CanCluster::new("CanCluster", &package, &settings).unwrap();
+
+        assert!(can_cluster.system().is_none());
+        system.create_fibex_element_ref(can_cluster.element()).unwrap();
+        assert_eq!(can_cluster.system().unwrap(), system);
+    }
+
+    #[test]
+    fn cluster_conversion() {
+        let model = AutosarModel::new();
+        let _file = model.create_file("test.arxml", AutosarVersion::LATEST).unwrap();
+        let package = ArPackage::get_or_create(&model, "/Test").unwrap();
+        let can_settings = CanClusterSettings::default();
+        let can_cluster = CanCluster::new("CanCluster", &package, &can_settings).unwrap();
+        let ethernet_cluster = EthernetCluster::new("EthernetCluster", &package).unwrap();
+        let flexray_settings = FlexrayClusterSettings::default();
+        let flexray_cluster = FlexrayCluster::new("FlexrayCluster", &package, &flexray_settings).unwrap();
+
+        let can: Cluster = can_cluster.into();
+        let ethernet: Cluster = ethernet_cluster.into();
+        let flexray: Cluster = flexray_cluster.into();
+
+        assert_eq!(can.element().item_name().unwrap(), "CanCluster");
+        assert_eq!(ethernet.element().item_name().unwrap(), "EthernetCluster");
+        assert_eq!(flexray.element().item_name().unwrap(), "FlexrayCluster");
+    }
+}

autosar-data-abstraction/src/communication/controller/ethernet.rs

@@ -196,7 +196,7 @@ impl EthernetCommunicationController {
                     .get_or_create_sub_element(ElementName::VlanMemberships)
                     .and_then(|vms| vms.create_sub_element(ElementName::VlanMembership))
                     .and_then(|vm| vm.create_sub_element(ElementName::VlanRef))
-                    .and_then(|vr| vr.set_reference_target(&eth_channel.element()))?;
+                    .and_then(|vr| vr.set_reference_target(eth_channel.element()))?;
             }
         }
 

autosar-data-abstraction/src/communication/controller/mod.rs

@@ -46,3 +46,31 @@ impl From<FlexrayCommunicationController> for CommunicationController {
         CommunicationController::Flexray(value)
     }
 }
+
+//##################################################################
+
+#[cfg(test)]
+mod tests {
+    use crate::{ArPackage, EcuInstance};
+    use super::*;
+    use autosar_data::{AutosarModel, AutosarVersion};
+
+    #[test]
+    fn test_communication_controller() {
+        let model = AutosarModel::new();
+        let _file = model.create_file("test.arxml", AutosarVersion::LATEST).unwrap();
+        let package = ArPackage::get_or_create(&model, "/test").unwrap();
+        let ecu = EcuInstance::new("ecu", &package).unwrap();
+        let can = CanCommunicationController::new("can", &ecu).unwrap();
+        let ethernet = EthernetCommunicationController::new("ethernet", &ecu, None).unwrap();
+        let flexray = FlexrayCommunicationController::new("flexray", &ecu).unwrap();
+
+        let can_cc: CommunicationController = can.into();
+        let ethernet_cc: CommunicationController = ethernet.into();
+        let flexray_cc: CommunicationController = flexray.into();
+
+        assert_eq!(can_cc.element().item_name().unwrap(), "can");
+        assert_eq!(ethernet_cc.element().item_name().unwrap(), "ethernet");
+        assert_eq!(flexray_cc.element().item_name().unwrap(), "flexray");
+    }
+}

autosar-data-abstraction/src/communication/pdu/isignal_idpu.rs

@@ -72,8 +72,7 @@ impl ISignalIPdu {
             if self
                 .mapped_signals()
                 .filter_map(|mapping| mapping.signal_group())
-                .find(|grp| grp == &signal_group)
-                .is_none()
+                .any(|grp| grp == signal_group)
             {
                 return Err(AutosarAbstractionError::InvalidParameter(
                     "Cannot map signal to pdu, because it is part of an unmapped signal group.".to_string(),
@@ -83,7 +82,7 @@ impl ISignalIPdu {
 
         // add a pdu triggering for the newly mapped PDU to each frame triggering of this frame
         for pt in self.pdu_triggerings() {
-            let st = pt.add_signal_triggering(&signal)?;
+            let st = pt.add_signal_triggering(signal)?;
             for pdu_port in pt.pdu_ports() {
                 if let (Some(ecu), Some(direction)) = (pdu_port.ecu(), pdu_port.communication_direction()) {
                     st.connect_to_ecu(&ecu, direction)?;
@@ -103,7 +102,7 @@ impl ISignalIPdu {
         ISignalToIPduMapping::new(
             &name,
             &mappings,
-            &signal,
+            signal,
             start_position,
             byte_order,
             update_bit,
@@ -122,7 +121,7 @@ impl ISignalIPdu {
 
         // add a pdu triggering for the newly mapped PDU to each frame triggering of this frame
         for pt in self.pdu_triggerings() {
-            let st = pt.add_signal_group_triggering(&signal_group)?;
+            let st = pt.add_signal_group_triggering(signal_group)?;
             for pdu_port in pt.pdu_ports() {
                 if let (Some(ecu), Some(direction)) = (pdu_port.ecu(), pdu_port.communication_direction()) {
                     st.connect_to_ecu(&ecu, direction)?;
@@ -139,7 +138,7 @@ impl ISignalIPdu {
             .element()
             .get_or_create_sub_element(ElementName::ISignalToPduMappings)?;
 
-        ISignalToIPduMapping::new_group(&name, &mappings, &signal_group)
+        ISignalToIPduMapping::new_group(&name, &mappings, signal_group)
     }
 
     pub fn pdu_triggerings(&self) -> PduTriggeringsIterator {

autosar-data-abstraction/src/communication/physical_channel/ethernet.rs

@@ -364,7 +364,8 @@ impl EthernetPhysicalChannel {
 
 //##################################################################
 
-///
+/// A SocketConnectionBundle describes a connection between a server port and multiple client ports.
+/// It contains multiple bundled connections, each transporting one or more PDUs.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SocketConnectionBundle(Element);
 abstraction_element!(SocketConnectionBundle, SocketConnectionBundle);
@@ -458,7 +459,7 @@ impl SocketConnectionBundle {
 
 //##################################################################
 
-///
+/// A socketConnection inside a SocketConnectionBundle describes a single connection to a specific client port.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SocketConnection(Element);
 abstraction_element!(SocketConnection, SocketConnection);
@@ -675,7 +676,9 @@ impl SocketConnection {
 
 //##################################################################
 
-///
+/// A static socket connection is a connection between two sockets.
+/// 
+/// This is the new way to establish a connection. It was introduced in Autosar 4.5.0 (AUTOSAR_00048).
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StaticSocketConnection(Element);
 abstraction_element!(StaticSocketConnection, StaticSocketConnection);
@@ -738,7 +741,7 @@ impl StaticSocketConnection {
 
 //##################################################################
 
-///
+/// A SocketConnectionIpduIdentifierSet contains a set of SoConIPduIdentifiers, which are used in static socket connections.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SocketConnectionIpduIdentifierSet(Element);
 abstraction_element!(SocketConnectionIpduIdentifierSet, SocketConnectionIpduIdentifierSet);
@@ -777,7 +780,7 @@ impl SocketConnectionIpduIdentifierSet {
 
 //##################################################################
 
-///
+/// A SoConIPduIdentifier describes a PDU that is transported over a static socket connection.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SoConIPduIdentifier(Element);
 abstraction_element!(SoConIPduIdentifier, SoConIPduIdentifier);
@@ -898,6 +901,7 @@ impl SoConIPduIdentifier {
 
 //##################################################################
 
+/// The role of a TCP connection in a static socket connection cna either be `Connect` (=client) or `Listen` (=server).
 pub enum TcpRole {
     Connect,
     Listen,