Create C++ functions for constructing service clients

libraries/extensions/ros2-bridge/msg-gen/src/lib.rs

@@ -27,6 +27,8 @@ where
     let mut message_topic_impls = Vec::new();
     let mut service_defs = Vec::new();
     let mut service_impls = Vec::new();
+    let mut service_creation_defs = Vec::new();
+    let mut service_creation_impls = Vec::new();
     let mut aliases = Vec::new();
     for package in &packages {
         for message in &package.messages {
@@ -44,6 +46,12 @@ where
             let (def, imp) = service.struct_token_stream(&package.name, create_cxx_bridge);
             service_defs.push(def);
             service_impls.push(imp);
+            if create_cxx_bridge {
+                let (service_creation_def, service_creation_impl) =
+                    service.cxx_service_creation_functions(&package.name);
+                service_creation_defs.push(service_creation_def);
+                service_creation_impls.push(service_creation_impl);
+            }
         }
 
         aliases.push(package.aliases_token_stream());
@@ -67,6 +75,7 @@ where
                     fn qos_default() -> Ros2QosPolicies;
 
                     #(#message_topic_defs)*
+                    #(#service_creation_defs)*
                 }
 
                 #[derive(Debug, Clone)]
@@ -235,6 +244,7 @@ where
 
         #cxx_bridge_impls
         #(#message_topic_impls)*
+        #(#service_creation_impls)*
 
 
         #(#service_impls)*

libraries/extensions/ros2-bridge/msg-gen/src/types/service.rs

@@ -76,6 +76,47 @@ impl Service {
         }
     }
 
+    pub fn cxx_service_creation_functions(
+        &self,
+        package_name: &str,
+    ) -> (impl ToTokens, impl ToTokens) {
+        let client_name = format_ident!("Client__{package_name}__{}", self.name);
+        let cxx_client_name = format_ident!("Client_{}", self.name);
+        let create_client = format_ident!("new_Client__{package_name}__{}", self.name);
+        let cxx_create_client = format!("create_client_{package_name}_{}", self.name);
+
+        let package = format_ident!("{package_name}");
+        let self_name = format_ident!("{}", self.name);
+        let self_name_str = &self.name;
+
+        let def = quote! {
+            #[namespace = #package_name]
+            #[cxx_name = #cxx_client_name]
+            type #client_name;
+            #[cxx_name = #cxx_create_client]
+            fn #create_client(self: &mut Ros2Node, name_space: &str, base_name: &str, qos: Ros2QosPolicies) -> Result<Box<#client_name>>;
+        };
+        let imp = quote! {
+            #[allow(non_camel_case_types)]
+            pub struct #client_name(ros2_client::service::Client< #package :: service :: #self_name >);
+
+            impl Ros2Node {
+                #[allow(non_snake_case)]
+                pub fn #create_client(&mut self, name_space: &str, base_name: &str, qos: ffi::Ros2QosPolicies) -> eyre::Result<Box<#client_name>> {
+                    let client = self.0.create_client::< #package :: service :: #self_name >(
+                        ros2_client::ServiceMapping::Enhanced,
+                        &ros2_client::Name::new(name_space, base_name).unwrap(),
+                        &ros2_client::ServiceTypeName::new(#package_name, #self_name_str),
+                        qos.clone().into(),
+                        qos.into(),
+                    )?;
+                    Ok(Box::new(#client_name(client)))
+                }
+            }
+        };
+        (def, imp)
+    }
+
     pub fn token_stream_with_mod(&self) -> impl ToTokens {
         let mod_name = format_ident!("_{}", self.name.to_snake_case());
         let inner = self.token_stream();