* Refactor storage and transport_inner into their own modules

* Section off utils
* Start of vsomeip applications is done in a graceful manner, using signaling

Cargo.toml

@@ -41,6 +41,7 @@ async-trait = { version = "0.1" }
 bimap = { version = "0.6.3" }
 bytes = { version = "1.5" }
 console-subscriber = { version = "0.3.0" }
+crossbeam-channel = { version = "0.5.13" }
 cxx = { version = "1.0" }
 rand = { version = "0.8" }
 regex = { version = "1.10" }

up-transport-vsomeip/Cargo.toml

@@ -31,6 +31,7 @@ async-trait = { workspace = true }
 bimap = { workspace = true }
 bytes = { workspace = true }
 console-subscriber = { workspace = true }
+crossbeam-channel = { workspace = true }
 cxx = { workspace = true }
 rand = { workspace = true }
 regex = { workspace = true }

up-transport-vsomeip/src/determine_message_type.rs

@@ -14,6 +14,8 @@
 use crate::{ClientId, UeId};
 use up_rust::{UStatus, UUri};
 
+/// Registration type containing the [ClientId] of the [vsomeip_sys::vsomeip::application]
+/// which should be used for this message
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) enum RegistrationType {
     Publish(ClientId),
@@ -23,6 +25,8 @@ pub(crate) enum RegistrationType {
 }
 
 impl RegistrationType {
+    /// Get the [ClientId] of the [vsomeip_sys::vsomeip::application]
+    /// which should be used for this message
     pub fn client_id(&self) -> ClientId {
         match self {
             RegistrationType::Publish(client_id) => *client_id,
@@ -33,7 +37,7 @@ impl RegistrationType {
     }
 }
 
-// infer the type of message desired based on the filters provided
+/// infer the type of message desired based on the filters provided in a registration / unregistration
 pub(crate) fn determine_registration_type(
     source_filter: &UUri,
     sink_filter: &Option<UUri>,
@@ -47,18 +51,21 @@ pub(crate) fn determine_registration_type(
     )
 }
 
+/// infer the type of message desired based on the source and sink contained in a message
 pub(crate) fn determine_send_type(
     source_filter: &UUri,
     sink_filter: &Option<UUri>,
 ) -> Result<RegistrationType, UStatus> {
     determine_type(source_filter, sink_filter, None, DeterminationType::Send)
 }
 
+/// Whether the [determine_type] function should treat this as a registration / unregistration or send
 enum DeterminationType {
     Register,
     Send,
 }
 
+/// Determines [RegistrationType] of a source and sink filter [UUri]
 fn determine_type(
     source_filter: &UUri,
     sink_filter: &Option<UUri>,