Documentation alignment

README.md

@@ -25,14 +25,14 @@ use rustecal::{Ecal, EcalComponents, TypedPublisher};
 use rustecal_types_string::StringMessage;
 
 fn main() {
-    // eCAL init
+    // Initialize eCAL
     Ecal::initialize(Some("hello publisher"), EcalComponents::DEFAULT).unwrap();
 
     // create a string publisher on "hello"
     let publisher = TypedPublisher::<StringMessage>::new("hello").unwrap();
 
     // prepare the message to send
-    let message = StringMessage(Arc::from("Hello from Rust!"));
+    let message = StringMessage { data: Arc::from("Hello from Rust") };
 
     // publish until eCAL shuts down
     while Ecal::ok() {
@@ -52,19 +52,17 @@ fn main() {
 ```rust
 use rustecal::{Ecal, EcalComponents, TypedSubscriber};
 use rustecal_types_string::StringMessage;
-use rustecal::pubsub::typed_subscriber::Received;
 
 fn main() {
-    // eCAL init
+    // Initialize eCAL
     Ecal::initialize(Some("hello subscriber"), EcalComponents::DEFAULT).unwrap();
 
     // create a string subscriber on “hello”
     let mut subscriber = TypedSubscriber::<StringMessage>::new("hello").unwrap();
 
     // print each incoming message
-    subscriber.set_callback(|msg: Received<StringMessage>| {
-        let StringMessage(text) = msg.msg;
-        println!("Received: {}", text);
+    subscriber.set_callback(|message| {
+        println!("Received: {}", message.payload.data)
     });
 
     // keep the thread alive so callbacks can run
@@ -88,7 +86,7 @@ use rustecal::service::server::ServiceServer;
 use rustecal::service::types::MethodInfo;
 
 fn main() {
-    // eCAL init
+    // Initialize eCAL
     Ecal::initialize(Some("mirror server"), EcalComponents::DEFAULT).unwrap();
 
     // create a service server for "mirror"
@@ -127,7 +125,7 @@ use rustecal::service::client::ServiceClient;
 use rustecal::service::types::ServiceRequest;
 
 fn main() {
-    // eCAL init
+    // Initialize eCAL
     Ecal::initialize(Some("mirror client"), EcalComponents::DEFAULT).unwrap();
 
     // create a service client for "mirror"

docs/src/api/ecal.md

@@ -5,7 +5,7 @@ The `Ecal` struct manages initialization and finalization of the eCAL system.
 ## Example
 
 ```rust
-use rustecal::Ecal;
+use rustecal::{Ecal, EcalComponents};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ecal::initialize(Some("my ecal app"), EcalComponents::DEFAULT)?;

docs/src/api/message_types.md

@@ -15,8 +15,10 @@ Used for binary `Vec<u8>` payloads.
 Supports publishing/receiving of Protobuf types that implement `Message` and `Default`.
 
 ```rust
-use rustecal_types_protobuf::ProtobufMessage;
-use my_proto::MyProto;
+use rustecal_types_protobuf::{ProtobufMessage, IsProtobufType};
 
-let publisher = Publisher::<ProtobufMessage<MyProto>>::builder("proto_topic").create()?;
+use people::Person;
+impl IsProtobufType for Person {}
+
+let publisher = TypedPublisher::<ProtobufMessage<Person>>::new("person").unwrap();
 ```

docs/src/api/publisher.md

@@ -5,9 +5,12 @@ The `Publisher<T>` allows you to publish messages of type `T` on a topic.
 ## Example
 
 ```rust
-use rustecal::pubsub::Publisher;
-use rustecal_types::StringMessage;
+use std::sync::Arc;
+use rustecal::{Ecal, EcalComponents, TypedPublisher};
+use rustecal_types_string::StringMessage;
 
-let publisher = Publisher::<StringMessage>::builder("my_topic").create()?;
-publisher.send("Rust rocks!")?;
+let publisher = TypedPublisher::<StringMessage>::new("hello").unwrap();
+
+let message = StringMessage { data: Arc::from("Hello from Rust") };
+publisher.send(&message);
 ```

docs/src/api/service_client.md

@@ -18,11 +18,15 @@ use rustecal::service::types::ServiceRequest;
 let request = ServiceRequest {
     payload: b"stressed".to_vec(),
 };
+```
+
+To broadcast call all connected instances:
 
-let response = client.call("echo", request, Some(1000));
+```rust
+let responses = client.call("echo", request, Some(1000));
 ```
 
-To call all connected instances:
+To call (and filter) all connected instances separately:
 
 ```rust
 for instance in client.get_client_instances() {
@@ -48,4 +52,4 @@ match response {
 
 ## Runtime Compatibility
 
-This API is fully compatible with the C++ `mirror_client.cpp` and C `mirror_client_c.c` examples.
+This API is fully compatible with the C++ `mirror_client.cpp`, the C `mirror_client_c.c` and the C# `mirror_client_csharp.cs` example.

docs/src/api/service_server.md

@@ -47,4 +47,4 @@ Response : desserts
 
 ## Runtime Compatibility
 
-This API is fully compatible with the C++ `mirror_server.cpp` and C `mirror_server_c.c` examples.
+This API is fully compatible with the C++ `mirror_server.cpp`, the C `mirror_server_c.c` and the C# `mirror_client_csharp.cs` example.

docs/src/api/subscriber.md

@@ -5,11 +5,10 @@ The `Subscriber<T>` enables you to subscribe to messages of type `T` on a topic.
 ## Example
 
 ```rust
-use rustecal::pubsub::Subscriber;
-use rustecal_types::StringMessage;
+use rustecal::{Ecal, EcalComponents, TypedSubscriber};
+use rustecal_types_string::StringMessage;
 
-let subscriber = Subscriber::<StringMessage>::builder("my_topic").create()?;
-subscriber.set_callback(|msg| {
-    println!("Received: {}", msg.data());
-});
+let mut subscriber = TypedSubscriber::<StringMessage>::new("hello")?;
+subscriber.set_callback(|message| {
+    println!("Received: {}", message.payload.data)
 ```

docs/src/examples/binary.md

@@ -16,7 +16,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     while Ecal::ok() {
         let buf = vec![counter; 1024];
         counter = counter.wrapping_add(1);
-        publisher.send(&BytesMessage(Arc::from(buf)));
+
+        let message = BytesMessage { data: Arc::from(buf) };
+        publisher.send(&message);
 
         std::thread::sleep(std::time::Duration::from_millis(500));
     }
@@ -36,8 +38,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ecal::initialize(Some("blob subscriber"), EcalComponents::DEFAULT)?;
 
     let mut subscriber = TypedSubscriber::<BytesMessage>::new("blob")?;
-    subscriber.set_callback(|msg| {
-        println!("Received blob of {} bytes", msg.payload.data.len());
+    subscriber.set_callback(|message| {
+        println!("Received blob of {} bytes", message.payload.data.len());
     });
 
     while Ecal::ok() {

docs/src/examples/logging.md

@@ -10,7 +10,6 @@ use std::{thread, time::Duration};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize only the logging subsystem
     Ecal::initialize(Some("logging_receive_sample"), EcalComponents::LOGGING)?;
-    println!("eCAL initialized. Entering logging loop…");
 
     while Ecal::ok() {
         let entries = Log::get_logging()?;

docs/src/examples/monitoring.md

@@ -10,7 +10,6 @@ use std::{thread, time::Duration};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize only the monitoring subsystem
     Ecal::initialize(Some("monitoring_receive_sample"), EcalComponents::MONITORING)?;
-    println!("eCAL initialized. Entering monitoring loop…");
 
     while Ecal::ok() {
         let snap = Monitoring::get_snapshot()?;

docs/src/examples/protobuf.md

@@ -21,7 +21,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     while Ecal::ok() {
         let person = Person { id: 1, name: "Alice".into(), ..Default::default() };
-        publisher.send(&ProtobufMessage(Arc::from(person)));
+
+        let message = ProtobufMessage { data : Arc::from(person) };
+        publisher.send(&message);
 
         std::thread::sleep(std::time::Duration::from_millis(500));
     }
@@ -48,8 +50,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ecal::initialize(Some("protobuf subscriber"), EcalComponents::DEFAULT)?;
 
     let mut subscriber = TypedSubscriber::<ProtobufMessage<Person>>::new("person")?;
-    subscriber.set_callback(|msg| {
-        println!("Received person: {}", msg.payload.data.name)
+    subscriber.set_callback(|message| {
+        println!("Received person: {}", message.payload.data.name)
     });
 
     while Ecal::ok() {

docs/src/examples/string.md

@@ -3,6 +3,7 @@
 ## Publisher
 
 ```rust
+use std::sync::Arc;
 use rustecal::{Ecal, EcalComponents, TypedPublisher};
 use rustecal_types_string::StringMessage;
 
@@ -12,8 +13,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let publisher = TypedPublisher::<StringMessage>::new("hello")?;
 
     while Ecal::ok() {
-        let msg = StringMessage(Arc::from("Hello from Rust"));
-        publisher.send(&msg);
+        let message = StringMessage { data: Arc::from("Hello from Rust") };
+        publisher.send(&message);
 
         std::thread::sleep(std::time::Duration::from_millis(500));
     }
@@ -33,8 +34,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ecal::initialize(Some("string subscriber"), EcalComponents::DEFAULT)?;
 
     let mut subscriber = TypedSubscriber::<StringMessage>::new("hello")?;
-    subscriber.set_callback(|msg| {
-        println!("Received: {}", msg.payload.data)
+    subscriber.set_callback(|message| {
+        println!("Received: {}", message.payload.data)
     });
 
     while Ecal::ok() {

rustecal-samples/monitoring/logging_receive/src/main.rs

@@ -3,7 +3,7 @@ use rustecal_core::log::Log;
 use std::{thread, time::Duration};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Initialize only the logging component
+    // Initialize eCAL (only the logging component)
     Ecal::initialize(Some("logging receive sample"), EcalComponents::LOGGING)?;
     println!("eCAL initialized. Entering logging loop…");
 
@@ -18,7 +18,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         thread::sleep(Duration::from_secs(1));
     }
 
-    // Clean shutdown
+    // clean up and finalize eCAL
     Ecal::finalize();
     Ok(())
 }

rustecal-samples/monitoring/monitoring_receive/src/main.rs

@@ -3,7 +3,7 @@ use rustecal_core::monitoring::Monitoring;
 use std::{thread, time::Duration};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Initialize only the monitoring component
+    // Initialize eCAL (only the monitoring component)
     Ecal::initialize(Some("monitoring receive sample"), EcalComponents::MONITORING)?;
     println!("eCAL initialized. Entering monitoring loop…");
 
@@ -22,7 +22,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         thread::sleep(Duration::from_secs(1));
     }
 
-    // Clean shutdown
+    // clean up and finalize eCAL
     Ecal::finalize();
     Ok(())
 }

rustecal-samples/pubsub/blob_receive/src/main.rs

@@ -2,12 +2,12 @@ use rustecal::{Ecal, EcalComponents, TypedSubscriber};
 use rustecal::pubsub::typed_subscriber::Received;
 use rustecal_types_bytes::BytesMessage;
 
-fn main() {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize eCAL
     Ecal::initialize(Some("blob receive rust"), EcalComponents::DEFAULT)
         .expect("eCAL initialization failed");
 
-    let mut subscriber = TypedSubscriber::<BytesMessage>::new("blob")
-        .expect("Failed to create subscriber");
+    let mut subscriber = TypedSubscriber::<BytesMessage>::new("blob")?;
 
     subscriber.set_callback(|msg: Received<BytesMessage>| {
         let buffer = &msg.payload.data;
@@ -33,11 +33,14 @@ fn main() {
         println!("------------------------------------------\n");
     });
 
-    println!("Waiting for binary blobs on topic 'blob'...");
+    println!("Waiting for messages on topic 'blob'...");
 
+    // keep the thread alive so callbacks can run
     while Ecal::ok() {
         std::thread::sleep(std::time::Duration::from_millis(100));
     }
 
+    // clean up and finalize eCAL
     Ecal::finalize();
+    Ok(())
 }

rustecal-samples/pubsub/blob_send/src/main.rs

@@ -2,15 +2,14 @@ use std::sync::Arc;
 use rustecal::{Ecal, EcalComponents, TypedPublisher};
 use rustecal_types_bytes::BytesMessage;
 
-fn main() {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize eCAL
     Ecal::initialize(Some("blob send rust"), EcalComponents::DEFAULT)
         .expect("eCAL initialization failed");
 
-    let publisher = TypedPublisher::<BytesMessage>::new("blob")
-        .expect("Failed to create publisher");
+    let publisher = TypedPublisher::<BytesMessage>::new("blob")?;
 
     let mut counter: u8 = 0;
-
     while Ecal::ok() {
         // Fill 1024-byte buffer with the current counter value
         let buffer = vec![counter; 1024];
@@ -24,5 +23,7 @@ fn main() {
         std::thread::sleep(std::time::Duration::from_millis(500));
     }
 
+    // clean up and finalize eCAL
     Ecal::finalize();
+    Ok(())
 }

rustecal-samples/pubsub/hello_receive/src/main.rs

@@ -2,12 +2,12 @@ use rustecal::{Ecal, EcalComponents, TypedSubscriber};
 use rustecal::pubsub::typed_subscriber::Received;
 use rustecal_types_string::StringMessage;
 
-fn main() {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize eCAL
     Ecal::initialize(Some("hello receive rust"), EcalComponents::DEFAULT)
         .expect("eCAL initialization failed");
 
-    let mut subscriber = TypedSubscriber::<StringMessage>::new("hello")
-        .expect("Failed to create subscriber");
+    let mut subscriber = TypedSubscriber::<StringMessage>::new("hello")?;
 
     subscriber.set_callback(|msg: Received<StringMessage>| {
         println!("------------------------------------------");
@@ -27,9 +27,12 @@ fn main() {
 
     println!("Waiting for messages on topic 'hello'...");
 
+    // keep the thread alive so callbacks can run
     while Ecal::ok() {
         std::thread::sleep(std::time::Duration::from_millis(100));
     }
 
+    // clean up and finalize eCAL
     Ecal::finalize();
+    Ok(())
 }

rustecal-samples/pubsub/hello_send/src/main.rs

@@ -2,12 +2,12 @@ use std::sync::Arc;
 use rustecal::{Ecal, EcalComponents, TypedPublisher};
 use rustecal_types_string::StringMessage;
 
-fn main() {
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize eCAL
     Ecal::initialize(Some("hello send rust"), EcalComponents::DEFAULT)
         .expect("eCAL initialization failed");
 
-    let publisher: TypedPublisher<StringMessage> = TypedPublisher::<StringMessage>::new("hello")
-        .expect("Failed to create publisher");
+    let publisher: TypedPublisher<StringMessage> = TypedPublisher::<StringMessage>::new("hello")?;
 
     let mut cnt = 0;
     while Ecal::ok() {
@@ -22,5 +22,7 @@ fn main() {
         std::thread::sleep(std::time::Duration::from_millis(500));
     }
 
+    // clean up and finalize eCAL
     Ecal::finalize();
-}
+    Ok(())
+}