feat(zig-compat): add compatibility layer for multiple Zig versions

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
         strategy:
             matrix:
                 os: [ubuntu-latest]
-                version: [0.14.0, 0.15.1, ""]
+                version: [0.14.1, 0.15.1, master]
             fail-fast: false
         runs-on: ${{ matrix.os }}
         steps:

build.zig

@@ -21,6 +21,12 @@ pub fn build(b: *std.Build) void {
         .root_source_file = b.path(b.pathJoin(&.{ "src", "test.zig" })),
         .target = target,
         .optimize = optimize,
+    }) else if (builtin.zig_version.minor >= 16) b.addTest(.{
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(b.pathJoin(&.{ "src", "test.zig" })),
+            .target = target,
+            .optimize = optimize,
+        }),
     }) else b.addTest(.{
         .root_module = b.addModule("test", .{
             .root_source_file = b.path(b.pathJoin(&.{ "src", "test.zig" })),
@@ -39,6 +45,13 @@ fn generateDocs(b: *Build, optimize: OptimizeMode, target: Build.ResolvedTarget)
         .root_source_file = b.path(b.pathJoin(&.{ "src", "msgpack.zig" })),
         .target = target,
         .optimize = optimize,
+    }) else if (builtin.zig_version.minor >= 16) b.addObject(.{
+        .name = "zig-msgpack",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path(b.pathJoin(&.{ "src", "msgpack.zig" })),
+            .target = target,
+            .optimize = optimize,
+        }),
     }) else b.addObject(.{
         .name = "zig-msgpack",
         .root_module = b.addModule("msgpack", .{

src/compat.zig

@@ -0,0 +1,63 @@
+// Compatibility layer for different Zig versions
+const std = @import("std");
+const builtin = @import("builtin");
+const current_zig = builtin.zig_version;
+
+// BufferStream implementation for Zig 0.16+
+// This mimics the behavior of the old FixedBufferStream
+pub const BufferStream = if (current_zig.minor >= 16) struct {
+    buffer: []u8,
+    pos: usize,
+
+    const Self = @This();
+
+    pub const WriteError = error{NoSpaceLeft};
+    pub const ReadError = error{EndOfStream};
+
+    pub fn init(buffer: []u8) Self {
+        return .{
+            .buffer = buffer,
+            .pos = 0,
+        };
+    }
+
+    pub fn write(self: *Self, bytes: []const u8) WriteError!usize {
+        const available = self.buffer.len - self.pos;
+        if (bytes.len > available) return error.NoSpaceLeft;
+        @memcpy(self.buffer[self.pos..][0..bytes.len], bytes);
+        self.pos += bytes.len;
+        return bytes.len;
+    }
+
+    pub fn read(self: *Self, dest: []u8) ReadError!usize {
+        // Read from current position in buffer
+        const available = self.buffer.len - self.pos;
+        if (available == 0) return 0;
+
+        const to_read = @min(dest.len, available);
+        @memcpy(dest[0..to_read], self.buffer[self.pos..][0..to_read]);
+        self.pos += to_read;
+        return to_read;
+    }
+
+    pub fn reset(self: *Self) void {
+        self.pos = 0;
+    }
+
+    pub fn seekTo(self: *Self, pos: usize) !void {
+        self.pos = pos;
+    }
+
+    pub fn getPos(self: Self) usize {
+        return self.pos;
+    }
+
+    pub fn getEndPos(self: Self) usize {
+        return self.pos;
+    }
+} else std.io.FixedBufferStream([]u8);
+
+pub const fixedBufferStream = if (current_zig.minor >= 16)
+    BufferStream.init
+else
+    std.io.fixedBufferStream;