serialize parameters state with msgpack

Author: bandithedoge

build.zig

@@ -76,6 +76,12 @@ pub fn build(b: *std.Build) !void {
             });
         }
 
+        if (b.lazyDependency("msgpack", .{
+            .target = target,
+            .optimize = optimize,
+        })) |msgpack|
+            clap_module.addImport("msgpack", msgpack.module("msgpack"));
+
         const clap_tests = b.addTest(.{ .root_module = clap_module });
         const run_clap_tests = b.addRunArtifact(clap_tests);
         test_step.dependOn(&run_clap_tests.step);

build.zig.zon

@@ -10,6 +10,11 @@
             .hash = "N-V-__8AABAqOwDxKlwerqbiBlg183KUY751DdoGwZ9N-ZuE",
             .lazy = true,
         },
+        .msgpack = .{
+            .url = "https://github.com/zigcc/zig-msgpack/archive/refs/tags/0.0.16.tar.gz",
+            .hash = "zig_msgpack-0.0.14-evvueHImBQA5zzdD7c4Sl9yJ4JECWb4JaWgvbInsk7Zt",
+            .lazy = true,
+        },
     },
     .paths = .{
         "src",

src/clap/extensions/state.zig

@@ -1,11 +1,6 @@
-// TODO: use some sort of actual binary serialization
-// libs to consider:
-// - https://github.com/ziglibs/s2s
-// - https://github.com/SeanTheGleaming/zig-serialization
-// - https://codeberg.org/hDS9HQLN/ztsl
-
 const c = @import("clap_c");
 const clap = @import("clap");
+const msgpack = @import("msgpack");
 
 const std = @import("std");
 const log = std.log.scoped(.zigplug_clap_state);
@@ -75,27 +70,45 @@ const Reader = struct {
     }
 };
 
-pub fn extension(comptime _: type) *const c.clap_plugin_state {
+pub fn extension(comptime Plugin: type) *const c.clap_plugin_state {
     const state = struct {
         pub fn save(clap_plugin: [*c]const c.clap_plugin, stream: [*c]const c.clap_ostream) callconv(.c) bool {
             const data = clap.Data.fromClap(clap_plugin);
+
             var clap_writer = Writer.init(stream);
             const writer = &clap_writer.writer;
 
-            for (data.plugin.parameters.?.slice) |parameter| {
-                switch (parameter.*) {
-                    inline else => |p| {
-                        const value = p.get();
-                        const bytes = std.mem.asBytes(&value);
-                        writer.writeAll(bytes) catch {
-                            log.err("failed to save parameter '{s}' = {}", .{ p.options.name, value });
+            var reader = std.Io.Reader.failing;
+            var packer = msgpack.packIO(&reader, writer);
+
+            var map = msgpack.Payload.mapPayload(data.plugin.allocator);
+            defer map.free(data.plugin.allocator);
+
+            inline for (data.plugin.parameters.?.slice, std.meta.fields(Plugin.Parameters)) |parameter, field| {
+                map.mapPut(field.name, switch (parameter.*) {
+                    .bool => |p| .boolToPayload(p.get()),
+                    .float => |p| .floatToPayload(p.get()),
+                    .int => |p| .intToPayload(p.get()),
+                    .uint => |p| .uintToPayload(p.get()),
+                }) catch {
+                    switch (parameter.*) {
+                        inline else => |p| {
+                            log.err("failed to save parameter '{s}' = {any}", .{ p.options.name, p.get() });
                             return false;
-                        };
-                        log.debug("saved parameter '{s}' = {any}", .{ p.options.name, value });
-                    },
+                        },
+                    }
+                };
+
+                switch (parameter.*) {
+                    inline else => |p| log.debug("saved parameter '{s}' = {any}", .{ field.name, p.get() }),
                 }
             }
 
+            packer.write(map) catch {
+                log.err("failed to save parameters", .{});
+                return false;
+            };
+
             return true;
         }
 
@@ -104,21 +117,34 @@ pub fn extension(comptime _: type) *const c.clap_plugin_state {
             var clap_reader = Reader.init(stream);
             const reader = &clap_reader.reader;
 
-            for (data.plugin.parameters.?.slice) |parameter| switch (parameter.*) {
-                inline else => |*p| {
-                    var value = p.get();
-                    const buffer = std.mem.asBytes(&value);
-                    reader.readSliceAll(buffer) catch {
-                        log.err("failed to load parameter '{s}'", .{p.options.name});
-                        return false;
-                    };
-                    p.set(value);
-
-                    log.debug("loaded parameter '{s}' = {any}", .{ p.options.name, value });
-                },
+            var writer = std.Io.Writer.failing;
+            var packer = msgpack.packIO(reader, &writer);
+
+            const decoded = packer.read(data.plugin.allocator) catch {
+                log.err("failed to read parameters", .{});
+                return false;
             };
+            defer decoded.free(data.plugin.allocator);
+
+            inline for (data.plugin.parameters.?.slice, std.meta.fields(Plugin.Parameters)) |parameter, field| {
+                if (decoded.mapGet(field.name) catch {
+                    log.err("failed to read parameter '{s}'", .{field.name});
+                    return false;
+                }) |value| {
+                    switch (parameter.*) {
+                        .bool => |*p| p.set(value.bool),
+                        .float => |*p| p.set(value.float),
+                        .int => |*p| p.set(value.int),
+                        .uint => |*p| p.set(value.uint),
+                    }
+                }
 
-            return false;
+                switch (parameter.*) {
+                    inline else => |p| log.debug("read parameter '{s}' = {any}", .{ field.name, p.get() }),
+                }
+            }
+
+            return true;
         }
     };