give up on gen

Author: kj4tmp

build.zig

@@ -75,6 +75,7 @@ pub fn build(b: *std.Build) void {
         .target = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl }),
         .root_source_file = zenoh_c_dep.path("include/zenoh.h"),
     });
+    zenoh.addImport("zenoh_c", translate_c.createModule());
     const gen_tool = b.addExecutable(.{
         .name = "generate_bindings",
         .root_source_file = b.path("tools/generate_bindings.zig"),

examples/examples.zig

@@ -21,46 +21,46 @@ fn publish() !void {
 
 var got_message: bool = false;
 
-fn data_handler(sample: [*c]zenoh.c.LoanedSample, arg: ?*anyopaque) callconv(.c) void {
+fn data_handler(sample: [*c]zenoh.c.z_loaned_sample_t, arg: ?*anyopaque) callconv(.c) void {
     _ = sample;
     _ = arg;
     std.log.info("Got sample!", .{});
     got_message = true;
 }
 
 fn subscribe() !void {
-    var config: zenoh.c.Config = undefined;
+    var config: zenoh.c.z_owned_config_t = undefined;
     _ = zenoh.c.z_config_default(&config);
-    defer zenoh.c.z_config_drop(&config);
+    defer zenoh.c.z_config_drop(zenoh.c.z_config_move(&config));
 
-    var options: zenoh.c.OpenOptions = undefined;
+    var options: zenoh.c.z_open_options_t = undefined;
     zenoh.c.z_open_options_default(&options);
-    var session: zenoh.c.Session = undefined;
-    if (zenoh.c.z_open(&session, &config, &options) != 0) {
+    var session: zenoh.c.z_owned_session_t = undefined;
+    if (zenoh.c.z_open(&session, zenoh.c.z_config_move(&config), &options) != 0) {
         std.log.err("Failed to open zenoh session.", .{});
         return error.OpenSessionFailure;
     }
-    defer zenoh.c.z_session_drop(&session);
+    defer zenoh.c.z_session_drop(zenoh.c.z_session_move(&session));
 
-    var callback: zenoh.c.ClosureSample = undefined;
+    var callback: zenoh.c.z_owned_closure_sample_t = undefined;
     zenoh.c.z_closure_sample(&callback, &data_handler, null, null);
 
-    var key_expr: zenoh.c.ViewKeyexpr = undefined;
+    var key_expr: zenoh.c.z_view_keyexpr_t = undefined;
     _ = zenoh.c.z_view_keyexpr_from_str(&key_expr, "key/expression");
 
-    var subscriber: zenoh.c.Subscriber = undefined;
+    var subscriber: zenoh.c.z_owned_subscriber_t = undefined;
 
     if (zenoh.c.z_declare_subscriber(
         zenoh.c.z_session_loan_mut(&session),
         &subscriber,
         zenoh.c.z_view_keyexpr_loan(&key_expr),
-        &callback,
+        zenoh.c.z_closure_sample_move(&callback),
         null,
     ) != 0) {
         std.log.err("Failed to create zenoh subscriber", .{});
         return error.DeclareSubscriberFailure;
     }
-    defer zenoh.c.z_subscriber_drop(&subscriber);
+    defer zenoh.c.z_subscriber_drop(zenoh.c.z_subscriber_move(&subscriber));
 
     var timer = std.time.Timer.start() catch @panic("timer unsupported");
 

examples/z_bytes.zig

@@ -4,9 +4,9 @@ const std = @import("std");
 const zenoh = @import("zenoh");
 
 test "wrapping raw bytes into a z_bytes_t" {
-    var payload: zenoh.c.Bytes = undefined;
+    var payload: zenoh.c.z_owned_bytes_t = undefined;
     const input_bytes: []const u8 = &[_]u8{ 1, 2, 3, 4 };
-    var output_bytes: zenoh.c.Slice = undefined;
+    var output_bytes: zenoh.c.z_owned_slice_t = undefined;
     _ = zenoh.c.z_bytes_copy_from_buf(&payload, input_bytes.ptr, 4);
     _ = zenoh.c.z_bytes_to_slice(zenoh.c.z_bytes_loan_mut(&payload), &output_bytes);
     // try std.testing.expectEqualSlices(u8, input_bytes, zenoh.c.z_slice_data(zenoh.c.z_slice_loan(&output_bytes)));

src/root.zig

@@ -1,44 +1,46 @@
 const std = @import("std");
 
-pub const c = @import("c.zig");
+pub const c = @import("zenoh_c");
+
+// pub const c = @import("c.zig");
 
 pub const Error = error{ZenohError};
 
-pub fn err(code: c.Result) Error!void {
+pub fn err(code: c.z_result_t) Error!void {
     if (code < 0) {
         return error.ZenohError;
     }
 }
 
 pub const Config = struct {
-    _c: c.Config,
+    _c: c.z_owned_config_t,
 
     pub fn initDefault() Error!Config {
-        var c_config: c.Config = undefined;
+        var c_config: c.z_owned_config_t = undefined;
         try err(c.z_config_default(&c_config));
         return Config{ ._c = c_config };
     }
 
     pub fn initFromEnv() Error!Config {
-        var c_config: c.Config = undefined;
+        var c_config: c.z_owned_config_t = undefined;
         try err(c.zc_config_from_env(&c_config));
         return Config{ ._c = c_config };
     }
 
     pub fn initFromFile(path: [:0]const u8) Error!Config {
-        var c_config: c.Config = undefined;
+        var c_config: c.z_owned_config_t = undefined;
         try err(c.zc_config_from_file(&c_config, path.ptr));
         return Config{ ._c = c_config };
     }
 
     pub fn initFromString(str: [:0]const u8) Error!Config {
-        var c_config: c.Config = undefined;
+        var c_config: c.z_owned_config_t = undefined;
         try err(c.zc_config_from_str(&c_config, str.ptr));
         return Config{ ._c = c_config };
     }
 
     pub fn deinit(self: *Config) void {
-        c.z_config_drop(&self._c);
+        c.z_config_drop(c.z_config_move(&self._c));
     }
 };
 
@@ -51,48 +53,48 @@ pub const ZID = struct {
 };
 
 pub const Session = struct {
-    _c: c.Session,
+    _c: c.z_owned_session_t,
 
     pub const OpenOptions = struct {
-        _c: c.OpenOptions,
+        _c: c.z_open_options_t,
 
         pub fn init() OpenOptions {
-            var c_openoptions: c.OpenOptions = undefined;
+            var c_openoptions: c.z_open_options_t = undefined;
             c.z_open_options_default(&c_openoptions);
             return OpenOptions{ ._c = c_openoptions };
         }
     };
 
     pub fn open(config: *Config, options: *const OpenOptions) Error!Session {
-        var c_session: c.Session = undefined;
-        try err(c.z_open(&c_session, &config._c, &options._c));
+        var c_session: c.z_owned_session_t = undefined;
+        try err(c.z_open(&c_session, c.z_config_move(&config._c), &options._c));
         return Session{ ._c = c_session };
     }
 
     pub fn deinit(self: *Session) void {
-        c.z_session_drop(&self._c);
+        c.z_session_drop(c.z_session_move(&self._c));
     }
 
     pub const CloseOptions = struct {
-        _c: c.CloseOptions,
+        _c: c.z_close_options_t,
 
         pub fn init() CloseOptions {
-            var c_closeoptions: c.CloseOptions = undefined;
+            var c_closeoptions: c.z_close_options_t = undefined;
             c.z_close_options_default(&c_closeoptions);
             return CloseOptions{ ._c = c_closeoptions };
         }
     };
 
     pub fn close(self: *Session, options: *CloseOptions) Error!void {
-        try err(c.z_close(c.z_session_loan_mut(self), options));
+        try err(c.z_close(c.z_session_loan_mut(self), &options._c));
     }
 
     pub fn isClosed(self: *const Session) bool {
-        return c.z_session_is_closed(c.z_session_loan(self));
+        return c.z_session_is_closed(c.z_session_loan(&self._c));
     }
 
     pub fn infoZid(self: *const Session) error{InvalidSession}!ZID {
-        const c_zid = c.z_info_zid(c.z_session_loan(self));
+        const c_zid = c.z_info_zid(c.z_session_loan(&self._c));
         const zid = ZID{ ._c = c_zid };
         if (!zid.isValid()) return error.InvalidSession;
         return zid;
@@ -101,48 +103,48 @@ pub const Session = struct {
     // TODO: other zid stuff
 
     pub const PutOptions = struct {
-        _c: c.PutOptions,
+        _c: c.z_put_options_t,
 
         pub fn init() PutOptions {
-            var c_options: c.PutOptions = undefined;
+            var c_options: c.z_put_options_t = undefined;
             c.z_put_options_default(&c_options);
             return PutOptions{ ._c = c_options };
         }
     };
 
     pub fn put(self: *const Session, key_expr: [:0]const u8, bytes: *Bytes, options: *PutOptions) Error!void {
-        var view_keyexpr: c.ViewKeyexpr = undefined;
+        var view_keyexpr: c.z_view_keyexpr_t = undefined;
         try err(c.z_view_keyexpr_from_str(&view_keyexpr, key_expr.ptr));
 
         try err(c.z_put(
             c.z_session_loan(&self._c),
             c.z_view_keyexpr_loan(&view_keyexpr),
-            &bytes._c,
+            c.z_bytes_move(&bytes._c),
             &options._c,
         ));
     }
 };
 
 pub const Bytes = struct {
-    _c: c.Bytes,
+    _c: c.z_owned_bytes_t,
 
     pub fn initFromStaticString(string: [:0]const u8) Error!Bytes {
-        var c_bytes: c.Bytes = undefined;
+        var c_bytes: c.z_owned_bytes_t = undefined;
         try err(c.z_bytes_from_static_str(&c_bytes, string.ptr));
         return Bytes{ ._c = c_bytes };
     }
 
     pub fn deinit(self: *Bytes) void {
-        c.z_bytes_drop(&self._c);
+        c.z_bytes_drop(c.z_bytes_move(&self._c));
     }
 };
 
 pub const KeyExpr = struct {
-    _c: c.Keyexpr,
+    _c: c.z_owned_keyexpr_t,
 };
 
 pub const ViewKeyExpr = struct {
-    _c: c.ViewKeyexpr,
+    _c: c.z_view_keyexpr_t,
 };
 
 test "sanity check" {