Rust::com Error Enums Optimization

* Updated Example app
* Producer Builder error returning update

Author: bharatGoswami8

score/mw/com/example/com-api-example/basic-consumer-producer.rs

@@ -115,18 +115,18 @@ fn create_consumer<R: Runtime>(runtime: &R, service_id: InstanceSpecifier) -> Ve
         runtime.find_service::<VehicleInterface>(FindServiceSpecifier::Specific(service_id));
     let available_service_instances = consumer_discovery
         .get_available_instances()
-        .unwrap_or_else(|e| panic!("{:?}", e));
+        .expect("Failed to get available service instances");
 
     // Select service instance at specific handle_index
     let handle_index = 0; // or any index you need from vector of instances
     let consumer_builder = available_service_instances
         .into_iter()
         .nth(handle_index)
-        .unwrap();
+        .expect("Failed to get consumer builder at specified handle index");
 
     consumer_builder
         .build()
-        .unwrap_or_else(|e| panic!("{:?}", e))
+        .expect("Failed to build consumer instance")
 }
 
 #[allow(dead_code)]
@@ -140,16 +140,16 @@ async fn create_consumer_async<R: Runtime>(
     let available_service_instances = consumer_discovery
         .get_available_instances_async()
         .await
-        .unwrap();
+        .expect("Failed to get available service instances asynchronously");
 
     // Select service instance at specific handle_index
     let handle_index = 0; // or any index you need from vector of instances
     let consumer_builder = available_service_instances
         .into_iter()
         .nth(handle_index)
-        .unwrap();
+        .expect("Failed to get consumer builder at specified handle index");
 
-    consumer_builder.build().unwrap()
+    consumer_builder.build().expect("Failed to build consumer instance")
 }
 
 // Create a producer for the specified service identifier
@@ -160,18 +160,16 @@ fn create_producer<R: Runtime>(
     let producer_builder = runtime.producer_builder::<VehicleInterface>(service_id);
     let producer = producer_builder
         .build()
-        .unwrap_or_else(|e| panic!("{:?}", e));
-    producer.offer().unwrap_or_else(|e| panic!("{:?}", e))
+        .expect("Failed to build producer instance");
+    producer.offer().expect("Failed to offer producer instance")
 }
 
 // Run the example with the specified runtime
 fn run_with_runtime<R: Runtime>(name: &str, runtime: &R) {
     println!("\n=== Running with {name} runtime ===");
 
-    let service_id = match InstanceSpecifier::new("/Vehicle/Service1/Instance") {
-        Ok(specifier) => specifier,
-        Err(e) => panic!("{:?}", e),
-    };
+    let service_id = InstanceSpecifier::new("/Vehicle/Service1/Instance")
+        .expect("Failed to create InstanceSpecifier");
     let producer = create_producer(runtime, service_id.clone());
     let consumer = create_consumer(runtime, service_id);
     let monitor = VehicleMonitor::new(consumer, producer).unwrap();

score/mw/com/impl/rust/com-api/com-api-runtime-lola/consumer.rs

@@ -32,6 +32,7 @@ use core::future::Future;
 use core::marker::PhantomData;
 use core::mem::ManuallyDrop;
 use core::ops::{Deref, DerefMut};
+use core::panic;
 use futures::task::{AtomicWaker, Context, Poll};
 use std::cmp::Ordering;
 use std::fmt::Debug;
@@ -595,11 +596,10 @@ impl<'a, T: CommData> Future for ReceiveFuture<'a, T> {
                 if self.total_received >= new_samples {
                     //event_guard will be dropped here, allowing new receive calls to access the proxy event
                     self.event_guard = None;
-                    return Poll::Ready(
-                        self.scratch
-                            .take()
-                            .ok_or(Error::ReceiveError(ReceiveFailedReason::BufferUnavailable)),
-                    );
+                    return Poll::Ready(Ok(self
+                        .scratch
+                        .take()
+                        .expect("SampleContainer is not available when returning Future result")));
                 }
                 // Have some samples but not enough yet, wait for more via waker
                 Poll::Pending
@@ -659,6 +659,7 @@ where
 
     fn get_available_instances(&self) -> Result<Self::ServiceEnumerator> {
         //If ANY Support is added in Lola, then we need to return all available instances
+        //Once FFI layer error handling is in place (SWP-253124), we should convert this error to a proper FFI error instead of using map_err here
         let instance_specifier_lola =
             mw_com::InstanceSpecifier::try_from(self.instance_specifier.as_ref())
                 .map_err(|_| Error::ServiceError(ServiceFailedReason::InstanceSpecifierInvalid))?;
@@ -692,6 +693,7 @@ where
         let instance_specifier = self.instance_specifier.clone();
 
         // Convert to Lola InstanceSpecifier early
+        //Once FFI layer error handling is in place (SWP-253124), we should convert this error to a proper FFI error instead of using map_err here
         let instance_specifier_lola =
             mw_com::InstanceSpecifier::try_from(instance_specifier.as_ref())
                 .map_err(|_| Error::ServiceError(ServiceFailedReason::InstanceSpecifierInvalid));

score/mw/com/impl/rust/com-api/com-api-runtime-lola/producer.rs

@@ -444,6 +444,7 @@ impl<I: Interface> ProducerBuilder<I, LolaRuntimeImpl> for SampleProducerBuilder
 
 impl<I: Interface> Builder<I::Producer<LolaRuntimeImpl>> for SampleProducerBuilder<I> {
     fn build(self) -> Result<I::Producer<LolaRuntimeImpl>> {
+        //Once FFI layer error handling is in place (SWP-253124), we should convert this error to a proper FFI error instead of using map_err here
         let instance_specifier_runtime = mw_com::InstanceSpecifier::try_from(
             self.instance_specifier.as_ref(),
         )
@@ -458,7 +459,6 @@ impl<I: Interface> Builder<I::Producer<LolaRuntimeImpl>> for SampleProducerBuild
         };
 
         I::Producer::new(instance_info)
-            .map_err(|_| Error::ProducerError(ProducerFailedReason::BuilderCreationFailed))
     }
 }