refactor: updated pub/sub example to interoperate with ROS2 talker/listener

ros-z/examples/z_pubsub.rs

@@ -1,34 +1,37 @@
 use std::time::Duration;
 
-use ros_z::{Builder, Result, context::ZContextBuilder};
-use ros_z_msgs::std_msgs::ByteMultiArray;
+use ros_z::{
+    Builder, Result,
+    context::{ZContext, ZContextBuilder},
+};
+use ros_z_msgs::std_msgs::String as RosString;
 
-async fn run_subscriber(topic: String) -> Result<()> {
-    let ctx = ZContextBuilder::default().build()?;
+async fn run_subscriber(ctx: ZContext, topic: String) -> Result<()> {
     let node = ctx.create_node("Sub").build()?;
-    let zsub = node.create_sub::<ByteMultiArray>(&topic).build()?;
-    let mut counter = 1;
+    let zsub = node.create_sub::<RosString>(&topic).build()?;
     while let Ok(msg) = zsub.async_recv().await {
-        println!("sub:>> #{counter}: {}", String::from_utf8_lossy(&msg.data));
-        counter += 1;
+        println!("Hearing:>> {}", msg.data);
     }
     Ok(())
 }
 
-async fn run_publisher(topic: String, period: Duration, payload: String) -> Result<()> {
-    let ctx = ZContextBuilder::default().build()?;
+async fn run_publisher(
+    ctx: ZContext,
+    topic: String,
+    period: Duration,
+    payload: String,
+) -> Result<()> {
     let node = ctx.create_node("Pub").build()?;
-    let zpub = node.create_pub::<ByteMultiArray>(&topic).build()?;
+    let zpub = node.create_pub::<RosString>(&topic).build()?;
 
     let mut count = 0;
     loop {
-        let bs = format!("{payload} - #{count}");
-        println!("pub:>> {bs}");
-        let msg = ByteMultiArray {
-            data: bs.into(),
-            ..Default::default()
+        let str = RosString {
+            data: format!("{payload} - #{count}"),
         };
-        zpub.async_publish(&msg).await?;
+        println!("Telling:>> {}", str.data);
+
+        zpub.async_publish(&str).await?;
         let _ = tokio::time::sleep(period).await;
         count += 1;
     }
@@ -37,16 +40,25 @@ async fn run_publisher(topic: String, period: Duration, payload: String) -> Resu
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
+    let ctx = if let Some(e) = args.endpoint {
+        ZContextBuilder::default()
+            .with_mode(args.mode)
+            .with_connect_endpoints([e])
+            .build()?
+    } else {
+        ZContextBuilder::default().with_mode(args.mode).build()?
+    };
+
     let period = std::time::Duration::from_secs_f64(args.period);
     zenoh::init_log_from_env_or("error");
-    if args.mode == "sub" {
-        run_subscriber(args.topic).await?;
-    } else if args.mode == "pub" {
-        run_publisher(args.topic, period, args.data).await?;
+    if args.role == "listener" {
+        run_subscriber(ctx, args.topic).await?;
+    } else if args.role == "talker" {
+        run_publisher(ctx, args.topic, period, args.data).await?;
     } else {
         println!(
-            "Please use \"pub\" or \"sub\" as mode,  {} is not supported.",
-            args.mode
+            "Please use \"talker\" or \"listener\" as role,  {} is not supported.",
+            args.role
         );
     }
     Ok(())
@@ -57,10 +69,14 @@ use clap::Parser;
 struct Args {
     #[arg(short, long, default_value = "Hello ROS-Z")]
     data: String,
-    #[arg(short, long, default_value = "rosz/hello")]
+    #[arg(short, long, default_value = "/chatter")]
     topic: String,
     #[arg(short, long, default_value = "1.0")]
     period: f64,
-    #[arg(short, long, default_value = "sub")]
+    #[arg(short, long, default_value = "listener")]
+    role: String,
+    #[arg(short, long, default_value = "peer")]
     mode: String,
+    #[arg(short, long)]
+    endpoint: Option<String>,
 }