Skip to content

refactor: use concrete *std.Io.Reader and *std.Io.Writer types #10

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
lalinsky merged 1 commit into from
Oct 26, 2025
Merged

refactor: use concrete *std.Io.Reader and *std.Io.Writer types #10

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
132 changes: 66 additions & 66 deletions src/any.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -75,7 +75,7 @@ pub fn sizeOfPackedAny(comptime T: type, value: T) usize {
@compileError("Unsupported type '" ++ @typeName(T) ++ "'");
}

pub fn packAny(writer: anytype, value: anytype) !void {
pub fn packAny(writer: *std.Io.Writer, value: anytype) !void {
const T = @TypeOf(value);
switch (@typeInfo(T)) {
.void => return packNull(writer),
Expand Down Expand Up @@ -123,7 +123,7 @@ pub fn packAny(writer: anytype, value: anytype) !void {
@compileError("Unsupported type '" ++ @typeName(T) ++ "'");
}

pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
pub fn unpackAny(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
switch (@typeInfo(T)) {
.void => return unpackNull(reader),
.bool => return unpackBool(reader, T),
Expand Down Expand Up @@ -156,74 +156,74 @@ pub fn unpackAny(reader: anytype, allocator: std.mem.Allocator, comptime T: type

test "packAny/unpackAny: bool" {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), true);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, true);

stream.reset();
try std.testing.expectEqual(true, try unpackAny(stream.reader(), std.testing.allocator, bool));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(true, try unpackAny(&reader, std.testing.allocator, bool));
}

test "packAny/unpackAny: optional bool" {
const values = [_]?bool{ true, null };
for (values) |value| {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?bool));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?bool));
}
}

test "packAny/unpackAny: int" {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), -42);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, -42);

stream.reset();
try std.testing.expectEqual(-42, try unpackAny(stream.reader(), std.testing.allocator, i32));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(-42, try unpackAny(&reader, std.testing.allocator, i32));
}

test "packAny/unpackAny: optional int" {
const values = [_]?i32{ -42, null };
for (values) |value| {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?i32));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?i32));
}
}

test "packAny/unpackAny: float" {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), 3.14);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, 3.14);

stream.reset();
try std.testing.expectEqual(3.14, try unpackAny(stream.reader(), std.testing.allocator, f32));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(3.14, try unpackAny(&reader, std.testing.allocator, f32));
}

test "packAny/unpackAny: optional float" {
const values = [_]?f32{ 3.14, null };
for (values) |value| {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
try std.testing.expectEqual(value, try unpackAny(stream.reader(), std.testing.allocator, ?f32));
var reader = std.Io.Reader.fixed(writer.buffered());
try std.testing.expectEqual(value, try unpackAny(&reader, std.testing.allocator, ?f32));
}
}

test "packAny/unpackAny: string" {
var buffer: [32]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), "hello");
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, "hello");

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, []const u8);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, []const u8);
defer std.testing.allocator.free(result);
try std.testing.expectEqualStrings("hello", result);
}
Expand All @@ -232,11 +232,11 @@ test "packAny/unpackAny: optional string" {
const values = [_]?[]const u8{ "hello", null };
for (values) |value| {
var buffer: [32]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const u8);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, ?[]const u8);
defer if (result) |str| std.testing.allocator.free(str);
if (value) |str| {
try std.testing.expectEqualStrings(str, result.?);
Expand All @@ -248,12 +248,12 @@ test "packAny/unpackAny: optional string" {

test "packAny/unpackAny: array" {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
var writer = std.Io.Writer.fixed(&buffer);
const array = [_]i32{ 1, 2, 3, 4, 5 };
try packAny(stream.writer(), &array);
try packAny(&writer, &array);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, []const i32);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, []const i32);
defer std.testing.allocator.free(result);
try std.testing.expectEqualSlices(i32, &array, result);
}
Expand All @@ -263,11 +263,11 @@ test "packAny/unpackAny: optional array" {
const values = [_]?[]const i32{ &array, null };
for (values) |value| {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, ?[]const i32);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, ?[]const i32);
defer if (result) |arr| std.testing.allocator.free(arr);
if (value) |arr| {
try std.testing.expectEqualSlices(i32, arr, result.?);
Expand All @@ -283,12 +283,12 @@ test "packAny/unpackAny: struct" {
y: i32,
};
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
var writer = std.Io.Writer.fixed(&buffer);
const point = Point{ .x = 10, .y = 20 };
try packAny(stream.writer(), point);
try packAny(&writer, point);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, Point);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, Point);
try std.testing.expectEqualDeep(point, result);
}

Expand All @@ -301,11 +301,11 @@ test "packAny/unpackAny: optional struct" {
const values = [_]?Point{ point, null };
for (values) |value| {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, ?Point);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, ?Point);
try std.testing.expectEqualDeep(value, result);
}
}
Expand All @@ -323,11 +323,11 @@ test "packAny/unpackAny: union" {

for (values) |value| {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, Value);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, Value);
try std.testing.expectEqualDeep(value, result);
}
}
Expand All @@ -346,35 +346,35 @@ test "packAny/unpackAny: optional union" {

for (values) |value| {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packAny(stream.writer(), value);
var writer = std.Io.Writer.fixed(&buffer);
try packAny(&writer, value);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, ?Value);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, ?Value);
try std.testing.expectEqualDeep(value, result);
}
}

test "packAny/unpackAny: String struct" {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
var writer = std.Io.Writer.fixed(&buffer);
const str = String{ .data = "hello" };
try packAny(stream.writer(), str);
try packAny(&writer, str);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, String);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, String);
defer std.testing.allocator.free(result.data);
try std.testing.expectEqualStrings("hello", result.data);
}

test "packAny/unpackAny: Binary struct" {
var buffer: [64]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
var writer = std.Io.Writer.fixed(&buffer);
const str = String{ .data = "\x01\x02\x03\x04" };
try packAny(stream.writer(), str);
try packAny(&writer, str);

stream.reset();
const result = try unpackAny(stream.reader(), std.testing.allocator, String);
var reader = std.Io.Reader.fixed(writer.buffered());
const result = try unpackAny(&reader, std.testing.allocator, String);
defer std.testing.allocator.free(result.data);
try std.testing.expectEqualStrings("\x01\x02\x03\x04", result.data);
}
24 changes: 12 additions & 12 deletions src/array.zig
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,7 @@ pub fn sizeOfPackedArray(len: usize) !usize {
return try sizeOfPackedArrayHeader(len) + len;
}

pub fn packArrayHeader(writer: anytype, len: usize) !void {
pub fn packArrayHeader(writer: *std.Io.Writer, len: usize) !void {
if (len <= hdrs.FIXARRAY_MAX - hdrs.FIXARRAY_MIN) {
try writer.writeByte(hdrs.FIXARRAY_MIN + @as(u8, @intCast(len)));
} else if (len <= std.math.maxInt(u16)) {
Expand All @@ -45,8 +45,8 @@ pub fn packArrayHeader(writer: anytype, len: usize) !void {
}
}

pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
const header = try reader.readByte();
pub fn unpackArrayHeader(reader: *std.Io.Reader, comptime T: type) !T {
const header = try reader.takeByte();
switch (header) {
hdrs.FIXARRAY_MIN...hdrs.FIXARRAY_MAX => {
return header - hdrs.FIXARRAY_MIN;
Expand All @@ -63,7 +63,7 @@ pub fn unpackArrayHeader(reader: anytype, comptime T: type) !T {
}
}

pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !void {
pub fn packArray(writer: *std.Io.Writer, comptime T: type, value_or_maybe_null: T) !void {
const value = try maybePackNull(writer, T, value_or_maybe_null) orelse return;
try packArrayHeader(writer, value.len);

Expand All @@ -72,7 +72,7 @@ pub fn packArray(writer: anytype, comptime T: type, value_or_maybe_null: T) !voi
}
}

pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: type) !T {
pub fn unpackArray(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime T: type) !T {
const len = if (isOptional(T))
try unpackArrayHeader(reader, ?u32) orelse return null
else
Expand All @@ -90,7 +90,7 @@ pub fn unpackArray(reader: anytype, allocator: std.mem.Allocator, comptime T: ty
return data;
}

pub fn unpackArrayInto(reader: anytype, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
pub fn unpackArrayInto(reader: *std.Io.Reader, allocator: std.mem.Allocator, comptime Item: type, buffer: []Item) ![]Item {
const len = try unpackArrayHeader(reader, u32);

if (buffer.len < len) {
Expand Down Expand Up @@ -126,16 +126,16 @@ const packed_abc = [_]u8{ 0x93, 0x61, 0x62, 0x63 };

test "packArray: abc" {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packArray(stream.writer(), []const u8, "abc");
try std.testing.expectEqualSlices(u8, &packed_abc, stream.getWritten());
var writer = std.Io.Writer.fixed(&buffer);
try packArray(&writer, []const u8, "abc");
try std.testing.expectEqualSlices(u8, &packed_abc, writer.buffered());
}

test "packArray: null" {
var buffer: [16]u8 = undefined;
var stream = std.io.fixedBufferStream(&buffer);
try packArray(stream.writer(), ?[]const u8, null);
try std.testing.expectEqualSlices(u8, &packed_null, stream.getWritten());
var writer = std.Io.Writer.fixed(&buffer);
try packArray(&writer, ?[]const u8, null);
try std.testing.expectEqualSlices(u8, &packed_null, writer.buffered());
}

test "sizeOfPackedArray" {
Expand Down
Loading