A poolable string builder (aka string buffer) for Zig
more int write functions
Karl Seguin
(Jan 3, 2024, 5:51 PM +0800)
b1eb9a2a
7588df4d
+22
-47
+22
-47
src/buffer.zig
+22
-47
src/buffer.zig
···
130
130
131
131
132
132
pub fn writeU16Little(self: *Buffer, value: u16) !void {
133
-
return self.writeIntLittle(u16, value);
133
+
return self.writeIntT(u16, value, .little);
134
134
}
135
135
136
136
pub fn writeU32Little(self: *Buffer, value: u32) !void {
137
-
return self.writeIntLittle(u32, value);
137
+
return self.writeIntT(u32, value, .little);
138
138
}
139
139
140
140
pub fn writeU64Little(self: *Buffer, value: u64) !void {
141
-
return self.writeIntLittle(u64, value);
141
+
return self.writeIntT(u64, value, .little);
142
142
}
143
143
144
144
pub fn writeIntLittle(self: *Buffer, comptime T: type, value: T) !void {
145
-
const l = @divExact(@typeInfo(T).Int.bits, 8);
146
-
try self.ensureUnusedCapacity(l);
147
-
const pos = self.pos;
148
-
writeIntInto(T, self.buf, pos, value, l, .little);
149
-
self.pos = pos + l;
145
+
return self.writeIntT(T, value, .little);
150
146
}
151
147
152
148
pub fn writeU16Big(self: *Buffer, value: u16) !void {
153
-
return self.writeIntBig(u16, value);
149
+
return self.writeIntT(u16, value, .big);
154
150
}
155
151
156
152
pub fn writeU32Big(self: *Buffer, value: u32) !void {
157
-
return self.writeIntBig(u32, value);
153
+
return self.writeIntT(u32, value, .big);
158
154
}
159
155
160
156
pub fn writeU64Big(self: *Buffer, value: u64) !void {
161
-
return self.writeIntBig(u64, value);
157
+
return self.writeIntT(u64, value, .big);
162
158
}
163
159
164
160
pub fn writeIntBig(self: *Buffer, comptime T: type, value: T) !void {
161
+
return self.writeIntT(T, value, .big);
162
+
}
163
+
164
+
pub fn writeIntT(self: *Buffer, comptime T: type, value: T, endian: Endian) void {
165
165
const l = @divExact(@typeInfo(T).Int.bits, 8);
166
-
try self.ensureUnusedCapacity(l);
167
166
const pos = self.pos;
168
-
writeIntInto(T, self.buf, pos, value, l, .big);
167
+
writeIntInto(T, self.buf, pos, value, l, endian);
169
168
self.pos = pos + l;
170
169
}
171
170
···
238
237
239
238
pub fn writeByte(self: *View, b: u8) void {
240
239
const pos = self.pos;
241
-
writeByteInto(self.buf.buf, pos, b);
240
+
writeByteInto(self.buf.buf, pos, b);
242
241
self.pos = pos + 1;
243
242
}
244
243
···
302
301
return self.writeIntT(i64, value, .little);
303
302
}
304
303
304
+
pub fn writeIntLittle(self: *View, comptime T: type, value: T) void {
305
+
self.writeIntT(T, value, .little);
306
+
}
307
+
305
308
pub fn writeU16Big(self: *View, value: u16) void {
306
309
return self.writeIntT(u16, value, .big);
307
310
}
···
326
329
return self.writeIntT(i64, value, .big);
327
330
}
328
331
329
-
fn writeIntT(self: *View, comptime T: type, value: T, endian: Endian) void {
332
+
pub fn writeIntBig(self: *View, comptime T: type, value: T) void {
333
+
self.writeIntT(T, value, .big);
334
+
}
335
+
336
+
pub fn writeIntT(self: *View, comptime T: type, value: T, endian: Endian) void {
330
337
const l = @divExact(@typeInfo(T).Int.bits, 8);
331
338
const pos = self.pos;
332
339
writeIntInto(T, self.buf.buf, pos, value, l, endian);
333
340
self.pos = pos + l;
334
-
}
335
-
336
-
pub fn writeInt(self: *View, value: anytype) void {
337
-
return self.writeIntAs(value, self.endian);
338
-
}
339
-
340
-
pub fn writeIntAs(self: *View, value: anytype, endian: Endian) void {
341
-
const T = @TypeOf(value);
342
-
switch (@typeInfo(T)) {
343
-
.ComptimeInt => @compileError("Writing a comptime_int is slightly ambiguous, please cast to a specific type: sb.writeInt(@as(i32, 9001))"),
344
-
.Int => |int| {
345
-
if (int.signedness == .signed) {
346
-
switch (int.bits) {
347
-
8 => return self.writeByte(value),
348
-
16 => return self.writeIntT(i16, value, endian),
349
-
32 => return self.writeIntT(i32, value, endian),
350
-
64 => return self.writeIntT(i64, value, endian),
351
-
else => {},
352
-
}
353
-
} else {
354
-
switch (int.bits) {
355
-
8 => return self.writeByte(value),
356
-
16 => return self.writeIntT(u16, value, endian),
357
-
32 => return self.writeIntT(u32, value, endian),
358
-
64 => return self.writeIntT(u64, value, endian),
359
-
else => {},
360
-
}
361
-
}
362
-
},
363
-
else => {},
364
-
}
365
-
@compileError("Unsupported integer type: " ++ @typeName(T));
366
341
}
367
342
};
368
343