bandaid over 0.15 writer upgrade

Author: Rexicon226

src/reader.zig

@@ -22,7 +22,7 @@ pub const Reader = struct {
         self.decompressor.deinit();
     }
 
-    pub const R = std.io.Reader(*Reader, Error, read);
+    pub const R = std.io.GenericReader(*Reader, Error, read);
     pub fn reader(self: *Reader) R {
         return .{ .context = self };
     }

src/tests.zig

@@ -7,6 +7,7 @@ comptime {
 
 test "writing & reading" {
     std.testing.log_level = std.log.Level.err;
+    const allocator = std.testing.allocator;
 
     const test_data = blk: {
         var bytes: [32]u8 = undefined;
@@ -18,21 +19,21 @@ test "writing & reading" {
         break :blk bytes ++ "Foo Bar Baz".* ++ bytes;
     };
 
-    var compressed_data = std.ArrayList(u8).init(std.testing.allocator);
+    var compressed_data: std.io.Writer.Allocating = .init(allocator);
     defer compressed_data.deinit();
 
     const compressor = try zstd.Compressor.init(.{});
     defer compressor.deinit();
     var buffer: [128]u8 = undefined;
-    const writer_ctx = zstd.writerCtx(compressed_data.writer(), &compressor, &buffer);
+    const writer_ctx = zstd.writerCtx(&compressed_data.writer, &compressor, &buffer);
     const writer = writer_ctx.writer();
 
     try writer.writeAll(&test_data);
     try writer_ctx.finish();
 
-    try std.testing.expect(compressed_data.items.len <= test_data.len);
+    try std.testing.expect(compressed_data.written().len <= test_data.len);
 
-    var reader_state = try zstd.Reader.init(compressed_data.items);
+    var reader_state = try zstd.Reader.init(compressed_data.written());
     defer reader_state.deinit();
     const reader = reader_state.reader();
 

src/writer.zig

@@ -7,70 +7,66 @@ const OutBuffer = types.OutBuffer;
 const ZstdError = @import("error.zig").Error;
 
 pub inline fn writerCtx(
-    inner_writer: anytype,
+    inner_writer: *std.io.Writer,
     compressor: *const Compressor,
     out_buffer: []u8,
-) WriterCtx(@TypeOf(inner_writer)) {
+) Writer {
     return .{
         .inner = inner_writer,
         .compressor = compressor,
         .out_buffer = out_buffer,
     };
 }
 
-pub fn WriterCtx(comptime InnerWriter: type) type {
-    return struct {
-        inner: InnerWriter,
-        compressor: *const Compressor,
-        out_buffer: []u8,
-        const Self = @This();
+pub const Writer = struct {
+    inner: *std.io.Writer,
+    compressor: *const Compressor,
+    out_buffer: []u8,
 
-        const Error = ZstdError || InnerWriter.Error;
-        pub const Writer = std.io.Writer(Self, Error, zstdWrite);
+    const Error = ZstdError || std.io.Writer.Error;
 
-        pub inline fn writer(ctx: Self) Writer {
-            return .{ .context = ctx };
-        }
+    pub inline fn writer(ctx: Writer) std.io.GenericWriter(Writer, Error, zstdWrite) {
+        return .{ .context = ctx };
+    }
 
-        /// This must be called after writing all the data that has to be compressed.
-        /// After doing so, all of the internal buffers of the compressor will have been
-        /// flushed to the destination writer, allowing re-use and re-configuration of
-        /// the referenced Compressor.
-        pub fn finish(ctx: Self) Error!void {
-            while (true) {
-                var out_buffer: OutBuffer = .{
-                    .dst = ctx.out_buffer.ptr,
-                    .size = ctx.out_buffer.len,
-                    .pos = 0,
-                };
-                var in_buffer: InBuffer = .{
-                    .src = "",
-                    .size = 0,
-                    .pos = 0,
-                };
-                const remaining = try ctx.compressor.compressStream(&in_buffer, &out_buffer, .end);
-                try ctx.inner.writeAll(out_buffer.dst[0..out_buffer.pos]);
-                if (remaining == 0) break;
-            }
+    /// This must be called after writing all the data that has to be compressed.
+    /// After doing so, all of the internal buffers of the compressor will have been
+    /// flushed to the destination writer, allowing re-use and re-configuration of
+    /// the referenced Compressor.
+    pub fn finish(ctx: Writer) Error!void {
+        while (true) {
+            var out_buffer: OutBuffer = .{
+                .dst = ctx.out_buffer.ptr,
+                .size = ctx.out_buffer.len,
+                .pos = 0,
+            };
+            var in_buffer: InBuffer = .{
+                .src = "",
+                .size = 0,
+                .pos = 0,
+            };
+            const remaining = try ctx.compressor.compressStream(&in_buffer, &out_buffer, .end);
+            try ctx.inner.writeAll(out_buffer.dst[0..out_buffer.pos]);
+            if (remaining == 0) break;
         }
+    }
 
-        fn zstdWrite(ctx: Self, bytes: []const u8) Error!usize {
-            var in_buffer: InBuffer = .{
-                .src = bytes.ptr,
-                .size = bytes.len,
+    fn zstdWrite(ctx: Writer, bytes: []const u8) Error!usize {
+        var in_buffer: InBuffer = .{
+            .src = bytes.ptr,
+            .size = bytes.len,
+            .pos = 0,
+        };
+        while (true) {
+            var out_buffer: OutBuffer = .{
+                .dst = ctx.out_buffer.ptr,
+                .size = ctx.out_buffer.len,
                 .pos = 0,
             };
-            while (true) {
-                var out_buffer: OutBuffer = .{
-                    .dst = ctx.out_buffer.ptr,
-                    .size = ctx.out_buffer.len,
-                    .pos = 0,
-                };
-                const remaining = try ctx.compressor.compressStream(&in_buffer, &out_buffer, .continue_);
-                try ctx.inner.writeAll(out_buffer.dst[0..out_buffer.pos]);
-                if (remaining == 0 or in_buffer.pos == in_buffer.size) break;
-            }
-            return bytes.len;
+            const remaining = try ctx.compressor.compressStream(&in_buffer, &out_buffer, .continue_);
+            try ctx.inner.writeAll(out_buffer.dst[0..out_buffer.pos]);
+            if (remaining == 0 or in_buffer.pos == in_buffer.size) break;
         }
-    };
-}
+        return bytes.len;
+    }
+};