refactor(msg): rename NativeCdrSerdes->CdrSerdes, SerdeCdrSerdes->CdrCompatSerdes

Author: YuanYuYuan

crates/ros-z-codegen/src/python_msgspec_generator.rs

@@ -644,7 +644,7 @@ fn generate_serialize_to_zbuf(
             match_arms.push(quote! {
                 #full_name => {
                     let rust_msg = <ros::#package_ident::#name_ident>::from_py(msg)?;
-                    Ok(::ros_z::msg::NativeCdrSerdes::serialize(&rust_msg))
+                    Ok(::ros_z::msg::CdrSerdes::serialize(&rust_msg))
                 }
             });
         }
@@ -660,7 +660,7 @@ fn generate_serialize_to_zbuf(
         match_arms.push(quote! {
             #req_full_name => {
                 let rust_msg = <ros::#package_ident::#req_name_ident>::from_py(msg)?;
-                Ok(::ros_z::msg::NativeCdrSerdes::serialize(&rust_msg))
+                Ok(::ros_z::msg::CdrSerdes::serialize(&rust_msg))
             }
         });
 
@@ -670,7 +670,7 @@ fn generate_serialize_to_zbuf(
         match_arms.push(quote! {
             #resp_full_name => {
                 let rust_msg = <ros::#package_ident::#resp_name_ident>::from_py(msg)?;
-                Ok(::ros_z::msg::NativeCdrSerdes::serialize(&rust_msg))
+                Ok(::ros_z::msg::CdrSerdes::serialize(&rust_msg))
             }
         });
     }

crates/ros-z-console/src/core/dynamic_subscriber.rs

@@ -7,7 +7,7 @@ use std::{sync::Arc, time::Duration};
 
 use flume::Receiver;
 use ros_z::{
-    dynamic::{DynamicMessage, DynamicSerdeCdrSerdes, MessageSchema},
+    dynamic::{DynamicCdrCompatSerdes, DynamicMessage, MessageSchema},
     node::ZNode,
     pubsub::ZSub,
 };
@@ -25,7 +25,7 @@ pub struct DynamicTopicSubscriber {
     /// Channel for receiving messages asynchronously
     message_rx: Receiver<DynamicMessage>,
     /// Subscriber handle (kept alive to maintain subscription)
-    _subscriber: Arc<ZSub<DynamicMessage, Sample, DynamicSerdeCdrSerdes>>,
+    _subscriber: Arc<ZSub<DynamicMessage, Sample, DynamicCdrCompatSerdes>>,
 }
 
 impl DynamicTopicSubscriber {

crates/ros-z-msgs/tests/shm_size_estimation.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 use ros_z::{
     ZBuf,
-    msg::{NativeCdrSerdes, ZMessage, ZSerdes},
+    msg::{CdrSerdes, ZMessage, ZSerdes},
     shm::ShmProviderBuilder,
 };
 use zenoh_buffers::buffer::Buffer;
@@ -83,7 +83,7 @@ fn test_pointcloud2_shm_serialization_with_accurate_estimate() {
 
     // Serialize to SHM - should not panic!
     let result =
-        <NativeCdrSerdes as ZSerdes<PointCloud2>>::serialize_to_shm(&cloud, estimated, &provider);
+        <CdrSerdes as ZSerdes<PointCloud2>>::serialize_to_shm(&cloud, estimated, &provider);
 
     assert!(result.is_ok(), "SHM serialization should succeed");
 
@@ -149,8 +149,7 @@ fn test_image_shm_serialization_with_accurate_estimate() {
             .expect("Failed to create SHM provider"),
     );
 
-    let result =
-        <NativeCdrSerdes as ZSerdes<Image>>::serialize_to_shm(&image, estimated, &provider);
+    let result = <CdrSerdes as ZSerdes<Image>>::serialize_to_shm(&image, estimated, &provider);
     assert!(result.is_ok(), "SHM serialization should succeed");
 
     let (zbuf, actual_size) = result.unwrap();
@@ -207,8 +206,7 @@ fn test_laserscan_shm_serialization_with_accurate_estimate() {
             .expect("Failed to create SHM provider"),
     );
 
-    let result =
-        <NativeCdrSerdes as ZSerdes<LaserScan>>::serialize_to_shm(&scan, estimated, &provider);
+    let result = <CdrSerdes as ZSerdes<LaserScan>>::serialize_to_shm(&scan, estimated, &provider);
     assert!(result.is_ok(), "SHM serialization should succeed");
 
     let (zbuf, actual_size) = result.unwrap();
@@ -259,7 +257,7 @@ fn test_compressed_image_shm_serialization() {
     );
 
     let result =
-        <NativeCdrSerdes as ZSerdes<CompressedImage>>::serialize_to_shm(&img, estimated, &provider);
+        <CdrSerdes as ZSerdes<CompressedImage>>::serialize_to_shm(&img, estimated, &provider);
     assert!(result.is_ok(), "SHM serialization should succeed");
 
     let (zbuf, actual_size) = result.unwrap();
@@ -301,8 +299,7 @@ fn test_multiple_messages_share_shm_pool() {
         };
 
         let estimated = image.estimated_serialized_size();
-        let result =
-            <NativeCdrSerdes as ZSerdes<Image>>::serialize_to_shm(&image, estimated, &provider);
+        let result = <CdrSerdes as ZSerdes<Image>>::serialize_to_shm(&image, estimated, &provider);
 
         assert!(
             result.is_ok(),

crates/ros-z-msgs/tests/size_estimation_performance.rs

@@ -7,7 +7,7 @@ use std::time::Instant;
 
 use ros_z::{
     ZBuf,
-    msg::{NativeCdrSerdes, ZMessage, ZSerdes},
+    msg::{CdrSerdes, ZMessage, ZSerdes},
 };
 use ros_z_msgs::{builtin_interfaces::Time, sensor_msgs::*, std_msgs::Header};
 use zenoh_buffers::buffer::Buffer;
@@ -33,13 +33,13 @@ fn test_pointcloud2_serialization_performance() {
 
     // Warm up
     for _ in 0..5 {
-        let _ = NativeCdrSerdes::serialize(&cloud);
+        let _ = CdrSerdes::serialize(&cloud);
     }
 
     // Benchmark with accurate size estimation (current implementation)
     let start = Instant::now();
     for _ in 0..100 {
-        let zbuf = NativeCdrSerdes::serialize(&cloud);
+        let zbuf = CdrSerdes::serialize(&cloud);
         assert!(zbuf.len() > 1_000_000);
     }
     let with_estimation = start.elapsed();
@@ -71,13 +71,13 @@ fn test_image_serialization_performance() {
 
     // Warm up
     for _ in 0..5 {
-        let _ = NativeCdrSerdes::serialize(&image);
+        let _ = CdrSerdes::serialize(&image);
     }
 
     // Benchmark
     let start = Instant::now();
     for _ in 0..100 {
-        let zbuf = NativeCdrSerdes::serialize(&image);
+        let zbuf = CdrSerdes::serialize(&image);
         assert!(zbuf.len() > 920_000);
     }
     let elapsed = start.elapsed();
@@ -108,7 +108,7 @@ fn test_estimated_size_matches_actual() {
     };
 
     let estimated = cloud.estimated_serialized_size();
-    let zbuf = NativeCdrSerdes::serialize(&cloud);
+    let zbuf = CdrSerdes::serialize(&cloud);
     let actual = zbuf.len();
 
     println!("PointCloud2: estimated={}, actual={}", estimated, actual);
@@ -133,7 +133,7 @@ fn test_estimated_size_matches_actual() {
     };
 
     let estimated = image.estimated_serialized_size();
-    let zbuf = NativeCdrSerdes::serialize(&image);
+    let zbuf = CdrSerdes::serialize(&image);
     let actual = zbuf.len();
 
     println!("Image: estimated={}, actual={}", estimated, actual);
@@ -161,7 +161,7 @@ fn test_estimated_size_matches_actual() {
     };
 
     let estimated = scan.estimated_serialized_size();
-    let zbuf = NativeCdrSerdes::serialize(&scan);
+    let zbuf = CdrSerdes::serialize(&scan);
     let actual = zbuf.len();
 
     println!("LaserScan: estimated={}, actual={}", estimated, actual);
@@ -191,12 +191,12 @@ fn test_capacity_hint_api() {
 
     // Test serialize_with_hint (capacity hint API)
     let hint = cloud.estimated_serialized_size();
-    let zbuf = <NativeCdrSerdes as ZSerdes<PointCloud2>>::serialize_with_hint(&cloud, hint);
+    let zbuf = <CdrSerdes as ZSerdes<PointCloud2>>::serialize_with_hint(&cloud, hint);
 
     assert!(zbuf.len() > 50_000);
     println!("Serialized with explicit hint: {} bytes", zbuf.len());
 
     // Both serialize paths should produce the same length
-    let zbuf2 = NativeCdrSerdes::serialize(&cloud);
+    let zbuf2 = CdrSerdes::serialize(&cloud);
     assert_eq!(zbuf.len(), zbuf2.len());
 }

crates/ros-z-py/src/service.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
-use ros_z::msg::{SerdeCdrSerdes, ZMessage, ZSerdes, ZService};
+use ros_z::msg::{CdrCompatSerdes, ZMessage, ZSerdes, ZService};
 use ros_z::service::{QueryKey, ZClient, ZServer};
 use std::time::Duration;
 
@@ -31,7 +31,7 @@ where
 {
     fn send_request_serialized(&self, data: &[u8]) -> Result<()> {
         // Deserialize the request from CDR bytes
-        let request = <SerdeCdrSerdes as ZSerdes<T::Request>>::deserialize(data)
+        let request = <CdrCompatSerdes as ZSerdes<T::Request>>::deserialize(data)
             .map_err(|e| anyhow::anyhow!("Failed to deserialize request: {:?}", e))?;
 
         // Send the request (this is async in Rust, but we'll block here for Python)
@@ -57,7 +57,7 @@ where
             .map_err(|e| anyhow::anyhow!("Failed to receive response: {}", e))?;
 
         // Serialize the response to CDR bytes
-        Ok(<SerdeCdrSerdes as ZSerdes<T::Response>>::serialize_to_vec(
+        Ok(<CdrCompatSerdes as ZSerdes<T::Response>>::serialize_to_vec(
             &response,
         ))
     }
@@ -66,7 +66,7 @@ where
         // Use a minimal timeout for non-blocking behavior
         match self.inner.take_response_timeout(Duration::from_millis(1)) {
             Ok(response) => Ok(Some(
-                <SerdeCdrSerdes as ZSerdes<T::Response>>::serialize_to_vec(&response),
+                <CdrCompatSerdes as ZSerdes<T::Response>>::serialize_to_vec(&response),
             )),
             Err(e) => {
                 let err_str = e.to_string();
@@ -122,13 +122,13 @@ where
         // Serialize the request to CDR bytes
         Ok((
             key,
-            <SerdeCdrSerdes as ZSerdes<T::Request>>::serialize_to_vec(&request),
+            <CdrCompatSerdes as ZSerdes<T::Request>>::serialize_to_vec(&request),
         ))
     }
 
     fn send_response_serialized(&self, data: &[u8], key: &QueryKey) -> Result<()> {
         // Deserialize the response from CDR bytes
-        let response = <SerdeCdrSerdes as ZSerdes<T::Response>>::deserialize(data)
+        let response = <CdrCompatSerdes as ZSerdes<T::Response>>::deserialize(data)
             .map_err(|e| anyhow::anyhow!("Failed to deserialize response: {:?}", e))?;
 
         let mut server = self

crates/ros-z-tests/tests/type_description_interop.rs

@@ -24,7 +24,7 @@ use common::*;
 use ros_z::{
     Builder,
     dynamic::{
-        DynamicMessage, DynamicSerdeCdrSerdes, MessageSchema, type_description_msg_to_schema,
+        DynamicCdrCompatSerdes, DynamicMessage, MessageSchema, type_description_msg_to_schema,
     },
 };
 use ros_z_msgs::type_description_interfaces::{
@@ -423,7 +423,7 @@ fn test_dynamic_subscriber_from_type_description() {
             println!("Step 3: Creating dynamic subscriber...");
             let zsub = node
                 .create_sub_impl::<DynamicMessage>("chatter", None)
-                .with_serdes::<DynamicSerdeCdrSerdes>()
+                .with_serdes::<DynamicCdrCompatSerdes>()
                 .with_dyn_schema(schema.clone())
                 .build()
                 .expect("Failed to create dynamic subscriber");

crates/ros-z/examples/dynamic_message/interop.rs

@@ -7,7 +7,7 @@
 
 use ros_z::{
     dynamic::{DynamicMessage, FieldType, MessageSchema},
-    msg::{NativeCdrSerdes, ZSerdes},
+    msg::{CdrSerdes, ZSerdes},
 };
 use ros_z_msgs::{
     geometry_msgs::{Point, Twist, Vector3},
@@ -52,7 +52,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     );
 
     // Serialize static to CDR, then deserialize as dynamic
-    let cdr_bytes = NativeCdrSerdes::serialize_to_vec(&static_point);
+    let cdr_bytes = CdrSerdes::serialize_to_vec(&static_point);
     let dynamic_point = DynamicMessage::from_cdr(&cdr_bytes, &point_schema)?;
     println!(
         "Dynamic Point: x={}, y={}, z={}\n",
@@ -76,7 +76,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Serialize dynamic to CDR, then deserialize as static
     let cdr_bytes = dynamic_point.to_cdr()?;
-    let static_point = <NativeCdrSerdes as ZSerdes<Point>>::deserialize(&cdr_bytes)?;
+    let static_point = <CdrSerdes as ZSerdes<Point>>::deserialize(&cdr_bytes)?;
     println!(
         "Static Point: x={}, y={}, z={}\n",
         static_point.x, static_point.y, static_point.z
@@ -89,7 +89,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
     println!("Static String: \"{}\"", static_string.data);
 
-    let cdr_bytes = NativeCdrSerdes::serialize_to_vec(&static_string);
+    let cdr_bytes = CdrSerdes::serialize_to_vec(&static_string);
     let dynamic_string = DynamicMessage::from_cdr(&cdr_bytes, &string_schema)?;
     println!(
         "Dynamic String: \"{}\"\n",
@@ -120,7 +120,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         static_twist.angular.x, static_twist.angular.y, static_twist.angular.z
     );
 
-    let cdr_bytes = NativeCdrSerdes::serialize_to_vec(&static_twist);
+    let cdr_bytes = CdrSerdes::serialize_to_vec(&static_twist);
     let dynamic_twist = DynamicMessage::from_cdr(&cdr_bytes, &twist_schema)?;
     println!("Dynamic Twist:");
     println!(
@@ -148,7 +148,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     dynamic_msg.set("y", 2.5f64)?;
     dynamic_msg.set("z", 3.5f64)?;
 
-    let static_cdr = NativeCdrSerdes::serialize_to_vec(&static_msg);
+    let static_cdr = CdrSerdes::serialize_to_vec(&static_msg);
     let dynamic_cdr = dynamic_msg.to_cdr()?;
 
     println!("Static CDR:  {} bytes", static_cdr.len());
@@ -175,10 +175,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     );
 
     // Static → CDR → Dynamic → CDR → Static
-    let cdr1 = NativeCdrSerdes::serialize_to_vec(&original);
+    let cdr1 = CdrSerdes::serialize_to_vec(&original);
     let dynamic = DynamicMessage::from_cdr(&cdr1, &point_schema)?;
     let cdr2 = dynamic.to_cdr()?;
-    let recovered = <NativeCdrSerdes as ZSerdes<Point>>::deserialize(&cdr2)?;
+    let recovered = <CdrSerdes as ZSerdes<Point>>::deserialize(&cdr2)?;
 
     println!(
         "Recovered static: ({}, {}, {})",

crates/ros-z/examples/z_custom_message.rs

@@ -5,7 +5,7 @@ use ros_z::{
     Builder, MessageTypeInfo, Result, ServiceTypeInfo,
     context::ZContextBuilder,
     entity::TypeHash,
-    msg::{SerdeCdrSerdes, ZService},
+    msg::{CdrCompatSerdes, ZService},
 };
 use serde::{Deserialize, Serialize};
 
@@ -138,7 +138,7 @@ async fn run_status_publisher(robot_id: String) -> Result<()> {
     let node = ctx.create_node("robot_status_publisher").build()?;
     let zpub = node
         .create_pub::<RobotStatus>("/robot_status")
-        .with_serdes::<SerdeCdrSerdes>()
+        .with_serdes::<CdrCompatSerdes>()
         .build()?;
 
     let mut position_x = 0.0;
@@ -192,7 +192,7 @@ async fn run_status_subscriber() -> Result<()> {
     let node = ctx.create_node("robot_status_subscriber").build()?;
     let zsub = node
         .create_sub::<RobotStatus>("/robot_status")
-        .with_serdes::<SerdeCdrSerdes>()
+        .with_serdes::<CdrCompatSerdes>()
         .build()?;
 
     loop {