Proceedings from Rust API workshop #6

Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
-members = ["com-api", "com-api-example"]
+members = ["com-api", "com-api-example", "com-api-sample-instance", "com-api-sample-interface", "com-api-sample-runtime"]
 resolver = "3"

com-api-example/Cargo.toml

@@ -6,3 +6,10 @@ publish = ["common"]
 license = "Apache-2.0"
 
 [dependencies]
+
+[dev-dependencies]
+com-api = { path = "../com-api" }
+com-api-sample-runtime = { path = "../com-api-sample-runtime" }
+com-api-sample-interface = { path = "../com-api-sample-interface" }
+com-api-sample-instance = { path = "../com-api-sample-instance" }
+futures = "0.3"

com-api-example/src/main.rs

@@ -12,3 +12,87 @@
 fn main() {
     println!("Hello, world!");
 }
+
+#[cfg(test)]
+mod test {
+    use com_api::{Builder, Instance, SampleMaybeUninit, SampleMut, Subscriber};
+    use com_api_sample_interface::AutoInterface;
+    use com_api_sample_runtime::InstanceSpecifier;
+    use std::time::{Duration, SystemTime};
+
+    #[test]
+    fn create_producer() {
+        // Factory
+        let runtime_builder = com_api_sample_runtime::RuntimeBuilderImpl::new();
+        let runtime = runtime_builder.build().unwrap();
+        let instance_builder = com_api_sample_instance::InstanceBuilder::<AutoInterface>::new(
+            &runtime,
+            InstanceSpecifier {},
+        );
+        //.key_str("key", "value");
+        let _producer = instance_builder.producer().build().unwrap();
+        let consumer = instance_builder.consumer().build().unwrap();
+
+        // Business logic
+        match consumer
+            .linkes_rad
+            .receive_until(SystemTime::now() + Duration::from_secs(5))
+        {
+            Ok(sample) => println!("{:?}", *sample),
+            Err(com_api::Error::Timeout) => panic!("No sample received"),
+            Err(e) => panic!("{:?}", e),
+        }
+    }
+
+    #[test]
+    fn receive_stuff() {
+        let test_subscriber = com_api_sample_runtime::SubscriberImpl::<u32>::new();
+        for _ in 0..10 {
+            match test_subscriber.receive_until(SystemTime::now() + Duration::from_secs(5)) {
+                Ok(sample) => println!("{}", *sample),
+                Err(com_api::Error::Timeout) => panic!("No sample received"),
+                Err(e) => panic!("{:?}", e),
+            }
+        }
+    }
+
+    #[test]
+    fn receive_async_stuff() {
+        let test_subscriber = com_api_sample_runtime::SubscriberImpl::<u32>::new();
+        // block on an asynchronous reception of data from test_subscriber
+        futures::executor::block_on(async {
+            match test_subscriber.receive().await {
+                Ok(sample) => println!("{}", *sample),
+                Err(e) => panic!("{:?}", e),
+            }
+        })
+    }
+
+    #[test]
+    fn send_stuff() {
+        let test_publisher = com_api_sample_runtime::Publisher::new();
+        for _ in 0..5 {
+            let sample = test_publisher.allocate();
+            match sample {
+                Ok(mut sample) => {
+                    let init_sample = unsafe {
+                        *sample.as_mut_ptr() = 42u32;
+                        sample.assume_init_2()
+                    };
+                    assert!(init_sample.send().is_ok());
+                }
+                Err(e) => eprintln!("Oh my! {:?}", e),
+            }
+        }
+    }
+
+    fn is_sync<T: Sync>(_val: T) {}
+
+    #[test]
+    fn builder_is_sync() {
+        is_sync(com_api_sample_runtime::RuntimeBuilderImpl::new());
+    }
+
+    #[test]
+    fn build_production_runtime() {}
+}

com-api-sample-instance/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "com-api-sample-instance"
+version = "0.1.0"
+edition = "2024"
+publish = ["common"]
+
+[dependencies]
+com-api-sample-runtime = { path = "../com-api-sample-runtime" }
+com-api-sample-interface = { path = "../com-api-sample-interface" }
+com-api = { path = "../com-api" }

com-api-sample-instance/src/lib.rs

@@ -0,0 +1,68 @@
+use com_api::{Interface, Runtime};
+use com_api_sample_runtime::InstanceSpecifier;
+use std::marker::PhantomData;
+
+pub struct InstanceBuilder<I: Interface> {
+    _interface: PhantomData<I>,
+    _instance_specifier: InstanceSpecifier,
+}
+
+impl<I: Interface> InstanceBuilder<I> {
+    pub fn new<R: Runtime>(_runtime: &R, instance_specifier: InstanceSpecifier) -> Self {
+        Self {
+            _interface: PhantomData,
+            _instance_specifier: instance_specifier,
+        }
+    }
+}
+
+impl com_api::Instance<com_api_sample_runtime::RuntimeImpl>
+    for InstanceBuilder<com_api_sample_interface::AutoInterface>
+{
+    type Interface = com_api_sample_interface::AutoInterface;
+
+    type ProducerBuilder = AutoProducerBuilder;
+    type ConsumerBuilder = AutoConsumerBuilder;
+
+    fn producer(&self) -> Self::ProducerBuilder {
+        AutoProducerBuilder {}
+    }
+
+    fn consumer(&self) -> Self::ConsumerBuilder {
+        AutoConsumerBuilder {}
+    }
+}
+
+pub struct AutoProducerBuilder {}
+
+impl com_api::Builder for AutoProducerBuilder {
+    type Output = AutoProducer;
+
+    fn build(self) -> com_api::Result<Self::Output> {
+        todo!()
+    }
+}
+
+impl com_api::ProducerBuilder<com_api_sample_runtime::RuntimeImpl> for AutoProducerBuilder {}
+
+pub struct AutoConsumerBuilder {}
+
+impl com_api::Builder for AutoConsumerBuilder {
+    type Output = AutoConsumer;
+
+    fn build(self) -> com_api::Result<Self::Output> {
+        todo!()
+    }
+}
+
+impl com_api::ConsumerBuilder<com_api_sample_runtime::RuntimeImpl> for AutoConsumerBuilder {}
+
+pub struct AutoProducer {
+    pub linkes_rad: com_api_sample_runtime::Publisher<com_api_sample_interface::Rad>,
+    pub auspuff: com_api_sample_runtime::Publisher<com_api_sample_interface::Auspuff>,
+}
+
+pub struct AutoConsumer {
+    pub linkes_rad: com_api_sample_runtime::SubscriberImpl<com_api_sample_interface::Rad>,
+    pub auspuff: com_api_sample_runtime::SubscriberImpl<com_api_sample_interface::Auspuff>,
+}

com-api-sample-interface/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "com-api-sample-interface"
+version = "0.1.0"
+edition = "2024"
+publish = ["common"]
+
+[dependencies]
+com-api = { path = "../com-api" }