feat: serialize custom length string

src/protocol.zig

@@ -10,16 +10,16 @@ const VERSION: u8 = 1;
 
 // Data format:
 // u8 -> version
-// list of 100 u8
+// u8 -> len
+// list of u8 of len
 
 const Data = struct {
-    version: u8,
-    message: [100]u8,
+    message: []const u8,
 };
 
-const SerializationError = error{ VersionDoesNotMatchError, OtherError };
+const SerializationError = error{ VersionDoesNotMatchError, OutOfMemory, OtherError };
 
-fn deserialize(input: []u8) SerializationError!Data {
+fn deserialize(allocator: std.mem.Allocator, input: []u8) SerializationError!Data {
     if (input.len == 0) {
         return SerializationError.OtherError;
     }
@@ -28,25 +28,35 @@ fn deserialize(input: []u8) SerializationError!Data {
         return SerializationError.VersionDoesNotMatchError;
     }
 
-    var message = [_]u8{0} ** 100;
+    const messageLen = input[1];
 
-    @memcpy(&message, input[1..101]);
+    const message = try allocator.alloc(u8, messageLen);
 
-    return .{ .version = VERSION, .message = message };
+    @memcpy(message, input[2..(messageLen + 2)]);
+
+    return .{ .message = message };
 }
 fn serialize(allocator: std.mem.Allocator, input: Data) ![]u8 {
-    const data = try allocator.alloc(u8, 1 + input.message.len);
-    data[0] = input.version;
-    @memcpy(data[1..], &input.message);
+    const messageLen = input.message.len;
+    if (messageLen >= std.math.maxInt(u8)) {
+        return SerializationError.OtherError;
+    }
+    const data = try allocator.alloc(u8, 2 + input.message.len);
+    data[0] = VERSION;
+    data[1] = @intCast(input.message.len);
+    const a = input.message;
+    @memcpy(data[2..], a);
     return data;
 }
 
 test "expect DataV1 can be serialized and deserialized" {
-    const expected: Data = .{ .version = VERSION, .message = [_]u8{ 'T', 'e', 's', 't' } ++ [_]u8{0} ** 96 };
+    const message = "Test";
+    const expected: Data = .{ .message = message };
     const serialized = try serialize(std.testing.allocator, expected);
     defer std.testing.allocator.free(serialized);
 
-    const actual = try deserialize(serialized);
+    const actual = try deserialize(std.testing.allocator, serialized);
+    defer std.testing.allocator.free(actual.message);
 
-    try std.testing.expectEqual(expected, actual);
+    try std.testing.expectEqualDeep(expected.message, actual.message);
 }