z_check and z_null made internal

Cargo.toml

@@ -32,7 +32,11 @@ build = "build.rs"
 
 [features]
 logger-autoinit = []
-shared-memory = ["zenoh/shared-memory", "dep:zenoh-ext", "zenoh-ext/shared-memory"]
+shared-memory = [
+    "zenoh/shared-memory",
+    "dep:zenoh-ext",
+    "zenoh-ext/shared-memory",
+]
 unstable = ["zenoh/unstable", "zenoh-ext/unstable", "dep:zenoh-ext"]
 default = ["zenoh/default"]
 
@@ -52,10 +56,12 @@ rand = "0.8.5"
 spin = "0.9.5"
 unwrap-infallible = "0.1.5"
 const_format = "0.2.32"
-zenoh = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0", default-features = false, features = ["internal"] }
-zenoh-ext = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0" , optional = true }
+zenoh = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0", default-features = false, features = [
+    "internal",
+] }
+zenoh-ext = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0", optional = true }
 zenoh-runtime = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0" }
-zenoh-util = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0"  }
+zenoh-util = { version = "1.0.0-dev", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "dev/1.0.0" }
 flume = "*"
 
 [build-dependencies]

build.rs

@@ -992,15 +992,15 @@ pub fn create_generics_header(path_in: &str, path_out: &str) {
 
     if drops != nulls {
         msgs.push(format!(
-            "the list of z_xxx_drop and z_xxx_null functions are different:\n missing z_xxx_null for {:?}\n missing z_xxx_drop for {:?}",
+            "the list of z_xxx_drop and z_internal_xxx_null functions are different:\n missing z_internal_xxx_null for {:?}\n missing z_xxx_drop for {:?}",
             drops.difference(&nulls),
             nulls.difference(&drops)
         ));
     }
 
     if drops != checks {
         msgs.push(format!(
-            "the list of z_xxx_drop and z_xxx_check functions are different:\n missing z_xxx_check for {:?}\n missing z_xxx_drop for {:?}",
+            "the list of z_xxx_drop and z_internal_xxx_check functions are different:\n missing z_internal_xxx_check for {:?}\n missing z_xxx_drop for {:?}",
             drops.difference(&checks),
             checks.difference(&drops)
         ));
@@ -1244,15 +1244,15 @@ pub fn find_drop_functions(path_in: &str) -> Vec<FunctionSignature> {
 
 pub fn find_null_functions(path_in: &str) -> Vec<FunctionSignature> {
     let bindings = std::fs::read_to_string(path_in).unwrap();
-    let re = Regex::new(r"(\w+)_null\(struct (\w+) \*(\w+)\);").unwrap();
+    let re = Regex::new(r" (z.?_internal_\w+_null)\(struct (\w+) \*(\w+)\);").unwrap();
     let mut res = Vec::<FunctionSignature>::new();
 
     for (_, [func_name, arg_type, arg_name]) in re.captures_iter(&bindings).map(|c| c.extract()) {
         let (_, _, semantic, _) = split_type_name(arg_type);
         let f = FunctionSignature::new(
             semantic,
             "void",
-            func_name.to_string() + "_null",
+            func_name.to_string(),
             vec![FuncArg::new(&(arg_type.to_string() + "*"), arg_name)],
         );
         res.push(f);
@@ -1262,15 +1262,15 @@ pub fn find_null_functions(path_in: &str) -> Vec<FunctionSignature> {
 
 pub fn find_check_functions(path_in: &str) -> Vec<FunctionSignature> {
     let bindings = std::fs::read_to_string(path_in).unwrap();
-    let re = Regex::new(r"bool (\w+)_check\(const struct (\w+) \*(\w+)\);").unwrap();
+    let re = Regex::new(r"bool (z.?_internal_\w+_check)\(const struct (\w+) \*(\w+)\);").unwrap();
     let mut res = Vec::<FunctionSignature>::new();
 
     for (_, [func_name, arg_type, arg_name]) in re.captures_iter(&bindings).map(|c| c.extract()) {
         let (_, _, semantic, _) = split_type_name(arg_type);
         let f = FunctionSignature::new(
             semantic,
             "bool",
-            func_name.to_string() + "_check",
+            func_name.to_string(),
             vec![FuncArg::new(
                 &("const ".to_string() + arg_type + "*"),
                 arg_name,
@@ -1415,7 +1415,7 @@ pub fn generate_take_functions(macro_func: &[FunctionSignature]) -> String {
     for sig in macro_func {
         let (prefix, _, semantic, _) = split_type_name(&sig.args[0].typename.typename);
         out += &format!(
-            "static inline void {}({} {}, {} {}) {{ *{} = {}->_this; {}_{}_null(&{}->_this); }}\n",
+            "static inline void {}({} {}, {} {}) {{ *{} = {}->_this; {}_internal_{}_null(&{}->_this); }}\n",
             sig.func_name,
             sig.args[0].typename.typename,
             sig.args[0].name,
@@ -1460,11 +1460,11 @@ pub fn generate_move_functions_cpp(macro_func: &[FunctionSignature]) -> String {
 }
 
 pub fn generate_generic_null_c(macro_func: &[FunctionSignature]) -> String {
-    generate_generic_c(macro_func, "z_null", false)
+    generate_generic_c(macro_func, "z_internal_null", false)
 }
 
 pub fn generate_generic_check_c(macro_func: &[FunctionSignature]) -> String {
-    generate_generic_c(macro_func, "z_check", true)
+    generate_generic_c(macro_func, "z_internal_check", true)
 }
 
 pub fn generate_generic_call_c(macro_func: &[FunctionSignature]) -> String {
@@ -1589,11 +1589,11 @@ pub fn generate_generic_take_cpp(macro_func: &[FunctionSignature]) -> String {
 }
 
 pub fn generate_generic_null_cpp(macro_func: &[FunctionSignature]) -> String {
-    generate_generic_cpp(macro_func, "z_null", false)
+    generate_generic_cpp(macro_func, "z_internal_null", false)
 }
 
 pub fn generate_generic_check_cpp(macro_func: &[FunctionSignature]) -> String {
-    generate_generic_cpp(macro_func, "z_check", true)
+    generate_generic_cpp(macro_func, "z_internal_check", true)
 }
 
 pub fn generate_generic_call_cpp(macro_func: &[FunctionSignature]) -> String {