adrien/ZipponDB
1
0
Fork 0
Code Actions Releases Activity

Updated APPEND function to remove duplicate code

Browse Source
This commit is contained in:
Adrien Bouvais 2025-01-29 22:22:25 +01:00
parent cb250bbcd0
commit 44ea7efbb0
1 changed files with 90 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
src/file/array.zig
View File

@ -17,25 +17,37 @@ pub fn updateData(allocator: std.mem.Allocator, condition: ArrayCondition, input
} }
} }
// This does not work, I think because I cant access the value at the pointer and so not update it.
// Maybe if I return instead ?
fn popInline(input: *zid.Data) void {
inline for (comptime std.meta.fields(zid.Data)) |field| {
if (comptime std.mem.endsWith(u8, field.name, "Array")) {
if (@field(input, field.name).len > 8) { // If array is not empty, only 8 bytes mean that there is just the size of the array that's encode, meaning a u64 of 8 bytes
@field(input, field.name) = @field(input, field.name)[0 .. @field(input, field.name).len - input.size()];
}
}
}
}
fn pop(input: *zid.Data) void { fn pop(input: *zid.Data) void {
switch (input.*) { switch (input.*) {
.IntArray => |v| if (v.len > 4) { .IntArray => |v| if (v.len > 8) {
input.*.IntArray = v[0 .. v.len - input.size()]; input.*.IntArray = v[0 .. v.len - @sizeOf(i32)];
}, },
.FloatArray => |v| if (v.len > 4) { .FloatArray => |v| if (v.len > 8) {
input.*.FloatArray = v[0 .. v.len - input.size()]; input.*.FloatArray = v[0 .. v.len - @sizeOf(f64)];
}, },
.UnixArray => |v| if (v.len > 4) { .UnixArray => |v| if (v.len > 8) {
input.*.UnixArray = v[0 .. v.len - input.size()]; input.*.UnixArray = v[0 .. v.len - @sizeOf(u64)];
}, },
.UUIDArray => |v| if (v.len > 4) { .UUIDArray => |v| if (v.len > 8) {
input.*.UUIDArray = v[0 .. v.len - input.size()]; input.*.UUIDArray = v[0 .. v.len - @sizeOf([16]u8)];
}, },
.BoolArray => |v| if (v.len > 4) { .BoolArray => |v| if (v.len > 8) {
input.*.BoolArray = v[0 .. v.len - input.size()]; input.*.BoolArray = v[0 .. v.len - @sizeOf(bool)];
}, },
.StrArray => |v| if (v.len > 4) { .StrArray => |v| if (v.len > 8) {
input.*.StrArray = v[0 .. v.len - input.size()]; input.*.StrArray = v[0 .. v.len - @sizeOf(f64)]; // FIXME: Obviously the size of is wrong
}, },
else => unreachable, else => unreachable,
} }
@ -54,95 +66,86 @@ fn clear(input: *zid.Data) void {
} }
// I think I could use meta programming here by adding the type as argument // I think I could use meta programming here by adding the type as argument
// TODO: Update the remaining type like int
fn append(allocator: std.mem.Allocator, input: *zid.Data, data: ConditionValue) !void { fn append(allocator: std.mem.Allocator, input: *zid.Data, data: ConditionValue) !void {
var updated_array = std.ArrayList(u8).init(allocator);
errdefer updated_array.deinit();
switch (input.*) { switch (input.*) {
.IntArray => { .IntArray,
var updated_array = std.ArrayList(u8).init(allocator); .FloatArray,
try updated_array.appendSlice(input.IntArray); .UnixArray,
.BoolArray,
.StrArray,
.UUIDArray,
=> |v| try updated_array.appendSlice(v),
else => unreachable,
}
switch (data) { var new_len: usize = 0;
.int => |v| { switch (data) {
try updated_array.appendSlice(std.mem.asBytes(&v)); .int => |v| {
const new_len = input.size() - 8 + @sizeOf(i32); try updated_array.appendSlice(std.mem.asBytes(&v));
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len)); new_len = input.size() - 8 + @sizeOf(i32);
},
.int_array => |v| {
const new_array = try zid.allocEncodArray.Int(allocator, v);
try updated_array.appendSlice(new_array[8..]);
const new_len = input.size() + new_array.len - 16;
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
},
else => unreachable,
}
input.*.IntArray = try updated_array.toOwnedSlice();
}, },
.FloatArray => { .float => |v| {
var array = std.ArrayList(f64).init(allocator); try updated_array.appendSlice(std.mem.asBytes(&v));
defer array.deinit(); new_len = input.size() - 8 + @sizeOf(f64);
try array.appendSlice(data.float_array); },
const new_array = try zid.allocEncodArray.Float(allocator, array.items); .unix => |v| {
var updated_array = std.ArrayList(u8).init(allocator); try updated_array.appendSlice(std.mem.asBytes(&v));
try updated_array.appendSlice(input.FloatArray); new_len = input.size() - 8 + @sizeOf(u64);
},
.bool_ => |v| {
try updated_array.appendSlice(std.mem.asBytes(&v));
new_len = input.size() - 8 + @sizeOf(bool);
},
.str => |v| {
try updated_array.appendSlice(std.mem.asBytes(&v.len));
try updated_array.appendSlice(v);
new_len = input.size() + v.len - 8;
},
.int_array => |v| {
const new_array = try zid.allocEncodArray.Int(allocator, v);
defer allocator.free(new_array);
try updated_array.appendSlice(new_array[8..]); try updated_array.appendSlice(new_array[8..]);
const new_len = input.size() + new_array.len - 16; new_len = input.size() + new_array.len - 16;
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
input.*.FloatArray = try updated_array.toOwnedSlice();
}, },
.UnixArray => { .float_array => |v| {
var array = std.ArrayList(u64).init(allocator); const new_array = try zid.allocEncodArray.Float(allocator, v);
defer array.deinit(); defer allocator.free(new_array);
try array.appendSlice(data.unix_array);
const new_array = try zid.allocEncodArray.Unix(allocator, array.items);
var updated_array = std.ArrayList(u8).init(allocator);
try updated_array.appendSlice(input.UnixArray);
try updated_array.appendSlice(new_array[8..]); try updated_array.appendSlice(new_array[8..]);
const new_len = input.size() + new_array.len - 16; new_len = input.size() + new_array.len - 16;
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
input.*.UnixArray = try updated_array.toOwnedSlice();
}, },
.BoolArray => { .bool_array => |v| {
var array = std.ArrayList(bool).init(allocator); const new_array = try zid.allocEncodArray.Bool(allocator, v);
defer array.deinit(); defer allocator.free(new_array);
try array.appendSlice(data.bool_array);
const new_array = try zid.allocEncodArray.Bool(allocator, array.items);
var updated_array = std.ArrayList(u8).init(allocator);
try updated_array.appendSlice(input.BoolArray);
try updated_array.appendSlice(new_array[8..]); try updated_array.appendSlice(new_array[8..]);
const new_len = input.size() + new_array.len - 16; new_len = input.size() + new_array.len - 16;
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
input.*.BoolArray = try updated_array.toOwnedSlice();
}, },
.StrArray => { .str_array => |v| {
var array = std.ArrayList([]const u8).init(allocator); const new_array = try zid.allocEncodArray.Str(allocator, v);
defer array.deinit(); defer allocator.free(new_array);
try array.appendSlice(data.str_array);
const new_array = try zid.allocEncodArray.Str(allocator, array.items);
var updated_array = std.ArrayList(u8).init(allocator);
try updated_array.appendSlice(input.StrArray);
try updated_array.appendSlice(new_array[8..]); try updated_array.appendSlice(new_array[8..]);
const new_len = input.size() + new_array.len - 16; new_len = input.size() + new_array.len - 16;
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
input.*.StrArray = try updated_array.toOwnedSlice();
}, },
.UUIDArray => { // If input is a UUID array, that mean all data are also UUIDArray .unix_array => |v| {
var array = std.ArrayList([16]u8).init(allocator); const new_array = try zid.allocEncodArray.Unix(allocator, v);
defer array.deinit(); defer allocator.free(new_array);
try updated_array.appendSlice(new_array[8..]);
new_len = input.size() + new_array.len - 16;
},
else => unreachable,
}
var iter = data.link_array.keyIterator(); @memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len));
while (iter.next()) |uuid| try array.append(uuid.bytes);
const new_array = try zid.allocEncodArray.UUID(allocator, array.items);
var updated_array = std.ArrayList(u8).init(allocator); switch (input.*) {
try updated_array.appendSlice(input.UUIDArray); .IntArray => input.*.IntArray = try updated_array.toOwnedSlice(),
try updated_array.appendSlice(new_array[8..]); .FloatArray => input.*.FloatArray = try updated_array.toOwnedSlice(),
.UnixArray => input.*.UnixArray = try updated_array.toOwnedSlice(),
const new_len = input.size() + new_array.len - 16; .UUIDArray => input.*.UUIDArray = try updated_array.toOwnedSlice(),
@memcpy(updated_array.items[0..@sizeOf(u64)], std.mem.asBytes(&new_len)); .BoolArray => input.*.BoolArray = try updated_array.toOwnedSlice(),
input.*.UUIDArray = try updated_array.toOwnedSlice(); .StrArray => input.*.StrArray = try updated_array.toOwnedSlice(),
},
else => unreachable, else => unreachable,
} }
} }