refactor: reorganize RepublisherNode in lib.rs implementation and update example references for clarity

Author: roboticswithjulia

docs/writing-your-first-rclrs-node.md

@@ -138,7 +138,8 @@ impl RepublisherNode {
            _data,
        })
    }
-}```
+}
+```
 
 If that seems needlessly complicated – maybe it is, in the sense that `rclrs` could potentially introduce new abstractions to improve the ergonomics of this use case. This is to be discussed.
 
@@ -149,22 +150,22 @@ If you couldn't follow the explanation involving borrowing, closures etc. above,
 The node still doesn't republish the received messages. First, let's add a publisher to the node:
 
 ```
-<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../examples/minimal_pub_sub/src/first_rclrs_node.rs&lines=5-10) -->
+<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../rclrs/src/lib.rs&lines=78-83) -->
 <!-- MARKDOWN-AUTO-DOCS:END -->
 ```
 
 Create a publisher and add it to the newly instantiated `RepublisherNode`:
 
 ```
-<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../examples/minimal_pub_sub/src/first_rclrs_node.rs&lines=23-29) -->
+<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../rclrs/src/lib.rs&lines=96-102) -->
 <!-- MARKDOWN-AUTO-DOCS:END -->
 ```
 
 
 Then, let's add a `republish()` function to the `RepublisherNode` that publishes the latest message received, or does nothing if none was received:
 
 ```
-<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../examples/minimal_pub_sub/src/first_rclrs_node.rs&lines=32-37) -->
+<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../rclrs/src/lib.rs&lines=105-110) -->
 <!-- MARKDOWN-AUTO-DOCS:END -->
 ```
 
@@ -197,7 +198,7 @@ But wait, this doesn't work – there is an error about the thread closure needi
 The solution is also the same as above: Shared ownership with `Arc`. Only this time, `Mutex` isn't needed since both the `rclcpp::spin()` and the `republish()` function only require a shared reference:
 
 ```
-<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../examples/minimal_pub_sub/src/first_rclrs_node.rs&lines=40-55) -->
+<!-- MARKDOWN-AUTO-DOCS:START (CODE:src=../rclrs/src/lib.rs&lines=113-128) -->
 <!-- MARKDOWN-AUTO-DOCS:END -->
 ```
 

examples/minimal_pub_sub/Cargo.toml

@@ -25,11 +25,6 @@ path = "src/zero_copy_subscriber.rs"
 name = "zero_copy_publisher"
 path = "src/zero_copy_publisher.rs"
 
-[[bin]]
-name = "first_rclrs_node"
-path = "src/first_rclrs_node.rs"
-
-
 [dependencies]
 anyhow = {version = "1", features = ["backtrace"]}
 

examples/minimal_pub_sub/src/first_rclrs_node.rs

@@ -33,6 +33,11 @@ rosidl_runtime_rs = "0.4"
 serde = { version = "1", optional = true, features = ["derive"] }
 serde-big-array = { version = "0.5.1", optional = true }
 
+# Needed for the examples in lib.rs
+[dependencies.std_msgs]
+version = "*"
+
+
 [dev-dependencies]
 # Needed for e.g. writing yaml files in tests
 tempfile = "3.3.0"

rclrs/Cargo.toml

@@ -20,6 +20,8 @@
   <depend>rcl_interfaces</depend>
   <depend>rosgraph_msgs</depend>
 
+  <build_depend>std_msgs</build_depend>
+  
   <test_depend>test_msgs</test_depend>
 
   <export>

rclrs/package.xml

@@ -48,3 +48,81 @@ pub use subscription::*;
 pub use time::*;
 use time_source::*;
 pub use wait::*;
+
+
+/// # rclrs - ROS 2 Client Library for Rust
+/// 
+/// `rclrs` provides Rust bindings and idiomatic wrappers for ROS 2 (Robot Operating System).
+/// It enables writing ROS 2 nodes, publishers, subscribers, services and clients in Rust.
+///
+/// ## Features
+///
+/// - Native Rust implementation of core ROS 2 concepts
+/// - Safe wrappers around rcl C API
+/// - Support for publishers, subscribers, services, clients
+/// - Async/await support for services and clients
+/// - Quality of Service (QoS) configuration
+/// - Parameter services
+/// - Logging integration
+///
+/// ## Example
+/// Here's a simple publisher-subscriber node:
+
+use std::sync::{Arc, Mutex};
+use std_msgs::msg::String as StringMsg;
+
+/// ## Write the basic node structure
+/// Since Rust doesn't have inheritance, it's not possible to inherit from `Node` as is common practice in `rclcpp` or `rclpy`.
+///
+/// Instead, you can store the node as a regular member. Let's use a struct that contains the node, a subscription, and a field for the last message that was received to `main.rs`:
+pub struct RepublisherNode {
+    _node: Arc<Node>,
+    _subscription: Arc<Subscription<StringMsg>>,
+    _publisher: Arc<Publisher<StringMsg>>,
+    _data: Arc<Mutex<Option<StringMsg>>>,
+}
+
+impl RepublisherNode {
+    fn _new(executor: &Executor) -> Result<Self, RclrsError> {
+        let _node = executor.create_node("republisher")?;
+        let _data = Arc::new(Mutex::new(None));
+        let data_cb = Arc::clone(&_data);
+        let _subscription = _node.create_subscription(
+            "in_topic".keep_last(10).transient_local(),
+            move |msg: StringMsg| {
+                *data_cb.lock().unwrap() = Some(msg);
+            },
+        )?;
+        let _publisher = _node.create_publisher::<std_msgs::msg::String>("out_topic")?;
+        Ok(Self {
+            _node,
+            _subscription,
+            _publisher,
+            _data,
+        })
+    }
+
+    fn _republish(&self) -> Result<(), RclrsError> {
+        if let Some(s) = &*self._data.lock().unwrap() {
+            self._publisher.publish(s)?;
+        }
+        Ok(())
+    }
+}
+
+fn _main() -> Result<(), RclrsError> {
+    let context = Context::default_from_env()?;
+    let mut executor = context.create_basic_executor();
+    let republisher = RepublisherNode::_new(&executor)?;
+    std::thread::spawn(move || -> Result<(), RclrsError> {
+        loop {
+            use std::time::Duration;
+            std::thread::sleep(Duration::from_millis(1000));
+            republisher._republish()?;
+        }
+    });
+    executor
+        .spin(SpinOptions::default())
+        .first_error()
+        .map_err(|err| err.into())
+}