bincode: remove redundant code

Author: alichraghi

src/bincode/bincode.zig

@@ -4,7 +4,6 @@ pub const bounded_array = @import("bounded_array.zig");
 pub const int = @import("int.zig");
 pub const list = @import("list.zig");
 pub const optional = @import("optional.zig");
-pub const varint = @import("varint.zig");
 pub const shortvec = @import("shortvec.zig");
 
 const std = @import("std");
@@ -612,6 +611,30 @@ pub fn freeWithConfig(
     }
 }
 
+pub fn VarIntConfig(comptime T: type) bincode.FieldConfig(T) {
+    const S = struct {
+        pub fn serialize(writer: anytype, data: anytype, params: bincode.Params) !void {
+            _ = params;
+            return std.leb.writeUleb128(writer, data);
+        }
+
+        pub fn deserialize(
+            allocator: std.mem.Allocator,
+            reader: anytype,
+            params: bincode.Params,
+        ) !T {
+            _ = params;
+            _ = allocator;
+            return std.leb.readUleb128(T, reader);
+        }
+    };
+
+    return bincode.FieldConfig(T){
+        .serializer = S.serialize,
+        .deserializer = S.deserialize,
+    };
+}
+
 pub fn FieldConfig(comptime T: type) type {
     return struct {
         deserializer: ?fn (alloc: std.mem.Allocator, reader: anytype, params: Params) anyerror!T = null,

src/bincode/shortvec.zig

@@ -3,22 +3,19 @@ const sig = @import("../sig.zig");
 
 const bincode = sig.bincode;
 
-const serializeShortU16 = sig.bincode.varint.serializeShortU16;
-const deserializeShortU16 = sig.bincode.varint.deserializeShortU16;
-
 pub fn sliceConfig(comptime Slice: type) bincode.FieldConfig(Slice) {
     const Child = std.meta.Elem(Slice);
     const S = struct {
         pub fn serialize(writer: anytype, data: anytype, params: bincode.Params) !void {
             const len: u16 = std.math.cast(u16, data.len) orelse return error.DataTooLarge;
-            try serializeShortU16(writer, len);
+            try std.leb.writeUleb128(writer, len);
             for (data) |item| {
                 try bincode.write(writer, item, params);
             }
         }
 
         pub fn deserialize(allocator: std.mem.Allocator, reader: anytype, params: bincode.Params) !Slice {
-            const len, _ = try deserializeShortU16(reader);
+            const len = try std.leb.readUleb128(u16, reader);
             const elems = try allocator.alloc(Child, len);
             errdefer allocator.free(elems);
             for (elems, 0..) |*elem, i| {
@@ -46,14 +43,14 @@ pub fn arrayListConfig(comptime Child: type) bincode.FieldConfig(std.ArrayList(C
         pub fn serialize(writer: anytype, data: anytype, params: bincode.Params) !void {
             const list: std.ArrayList(Child) = data;
             const len = std.math.cast(u16, list.items.len) orelse return error.DataTooLarge;
-            try serializeShortU16(writer, len);
+            try std.leb.writeUleb128(writer, len);
             for (list.items) |item| {
                 try bincode.write(writer, item, params);
             }
         }
 
         pub fn deserialize(allocator: std.mem.Allocator, reader: anytype, params: bincode.Params) !std.ArrayList(Child) {
-            const len, _ = try deserializeShortU16(reader);
+            const len = try std.leb.readUleb128(u16, reader);
             var list = try std.ArrayList(Child).initCapacity(allocator, @as(usize, len));
             for (0..len) |_| {
                 const item = try bincode.read(allocator, Child, reader, params);

src/bincode/varint.zig

@@ -25,8 +25,6 @@ const BitVecConfig = sig.bloom.bit_vec.BitVecConfig;
 const sanitizeWallclock = sig.gossip.message.sanitizeWallclock;
 
 const PACKET_DATA_SIZE = sig.net.Packet.DATA_SIZE;
-const var_int_config_u16 = sig.bincode.varint.var_int_config_u16;
-const var_int_config_u64 = sig.bincode.varint.var_int_config_u64;
 
 pub const MAX_EPOCH_SLOTS: u8 = 255;
 pub const MAX_VOTES: u8 = 32;
@@ -1271,7 +1269,7 @@ pub const ContactInfo = struct {
     pub const @"!bincode-config:addrs" = bincode.shortvec.arrayListConfig(IpAddr);
     pub const @"!bincode-config:sockets" = bincode.shortvec.arrayListConfig(SocketEntry);
     pub const @"!bincode-config:extensions" = bincode.shortvec.arrayListConfig(Extension);
-    pub const @"!bincode-config:wallclock" = var_int_config_u64;
+    pub const @"!bincode-config:wallclock" = bincode.VarIntConfig(u64);
 
     const Self = @This();
 
@@ -1566,7 +1564,7 @@ pub const SocketEntry = struct {
 
     const Self = @This();
 
-    pub const @"!bincode-config:offset" = var_int_config_u16;
+    pub const @"!bincode-config:offset" = bincode.VarIntConfig(u16);
 
     pub fn eql(self: *const Self, other: *const Self) bool {
         return self.key == other.key and

src/gossip/data.zig

@@ -164,9 +164,9 @@ pub fn serializeCompactVoteStateUpdate(
 
     // Serialize in compact format
     try writer.writeInt(Slot, data.root orelse 0, .little);
-    try sig.bincode.varint.serializeShortU16(writer, @intCast(lockouts.len));
+    try std.leb.writeUleb128(writer, @as(u16, @intCast(lockouts.len)));
     for (lockouts.constSlice()) |lockout| {
-        try sig.bincode.varint.serializeShortU16(writer, @intCast(lockout[0]));
+        try std.leb.writeUleb128(writer, @as(u16, @intCast(lockout[0])));
         try writer.writeInt(u8, @intCast(lockout[1]), .little);
     }
     try writer.writeAll(&data.hash.data);
@@ -187,15 +187,11 @@ pub fn deserializeCompactVoteStateUpdate(
     root = if (root == std.math.maxInt(Slot)) 0 else root;
 
     var slot = if (root == std.math.maxInt(Slot)) 0 else root;
-    const lockouts_len, _ = try sig.bincode.varint.deserializeShortU16(reader);
+    const lockouts_len = try std.leb.readUleb128(u16, reader);
     const lockouts = try allocator.alloc(Lockout, lockouts_len);
     errdefer allocator.free(lockouts);
     for (lockouts) |*lockout| {
-        const offset = try sig.bincode.varint.var_int_config_u64.deserializer.?(
-            allocator,
-            reader,
-            .{},
-        );
+        const offset = try std.leb.readUleb128(u64, reader);
         const confirmation_count = try reader.readInt(u8, .little);
         slot = try std.math.add(Slot, slot, offset);
         lockout.* = .{ .slot = slot, .confirmation_count = confirmation_count };
@@ -263,13 +259,9 @@ pub fn serializeTowerSync(writer: anytype, data: anytype, _: sig.bincode.Params)
 
     // Serialize in compact format
     try writer.writeInt(Slot, data.root orelse 0, .little);
-    try sig.bincode.varint.serializeShortU16(writer, @intCast(lockouts.len));
+    try std.leb.writeUleb128(writer, @as(u16, @intCast(lockouts.len)));
     for (lockouts.constSlice()) |lockout| {
-        try sig.bincode.varint.var_int_config_u64.serializer.?(
-            writer,
-            lockout[0],
-            .{},
-        );
+        try std.leb.writeUleb128(writer, lockout[0]);
         try writer.writeInt(u8, lockout[1], .little);
     }
     try writer.writeAll(&data.hash.data);
@@ -290,15 +282,11 @@ pub fn deserializeTowerSync(
     const root = try reader.readInt(Slot, .little);
 
     var slot = if (root == std.math.maxInt(Slot)) 0 else root;
-    const lockouts_len, _ = try sig.bincode.varint.deserializeShortU16(reader);
+    const lockouts_len = try std.leb.readUleb128(u16, reader);
     const lockouts = try allocator.alloc(Lockout, lockouts_len);
     errdefer allocator.free(lockouts);
     for (lockouts) |*lockout| {
-        const offset = try sig.bincode.varint.var_int_config_u64.deserializer.?(
-            allocator,
-            reader,
-            .{},
-        );
+        const offset = try std.leb.readUleb128(u64, reader);
         const confirmation_count = try reader.readInt(u8, .little);
         slot = try std.math.add(Slot, slot, offset);
         lockout.* = .{ .slot = slot, .confirmation_count = confirmation_count };

src/runtime/program/vote/state.zig

@@ -1,7 +1,5 @@
 const sig = @import("../sig.zig");
 
-const var_int_config_u16 = sig.bincode.varint.var_int_config_u16;
-
 pub const CURRENT_CLIENT_VERSION: ClientVersion = ClientVersion.new(0, 1, 0, 0, 0, 4);
 
 pub const ClientVersion = struct {
@@ -34,8 +32,8 @@ pub const ClientVersion = struct {
         };
     }
 
-    pub const @"!bincode-config:major" = var_int_config_u16;
-    pub const @"!bincode-config:minor" = var_int_config_u16;
-    pub const @"!bincode-config:patch" = var_int_config_u16;
-    pub const @"!bincode-config:client" = var_int_config_u16;
+    pub const @"!bincode-config:major" = sig.bincode.VarIntConfig(u16);
+    pub const @"!bincode-config:minor" = sig.bincode.VarIntConfig(u16);
+    pub const @"!bincode-config:patch" = sig.bincode.VarIntConfig(u16);
+    pub const @"!bincode-config:client" = sig.bincode.VarIntConfig(u16);
 };