adrien/ZipponDB
1
0
Fork 0
Code Actions Releases Activity

Return slice when parsing individual value

Browse Source 
When I use s2t, or string to type. Like to transform a string array into
an array. "[1 4 21]" to []i32{ 1, 4, 21}.

Before I return an ArrayList, now it use toOwnedSlice
This commit is contained in:
Adrien Bouvais 2024-11-01 20:37:19 +01:00
parent f5a692558b
commit 557e4ab064
2 changed files with 72 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
lib/types/stringToType.zig
View File

@ -9,30 +9,30 @@ pub fn parseInt(value_str: []const u8) i32 {
return std.fmt.parseInt(i32, value_str, 10) catch return 0;
}
pub fn parseArrayInt(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(i32) {
pub fn parseArrayInt(allocator: std.mem.Allocator, array_str: []const u8) ![]const i32 {
var array = std.ArrayList(i32).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseInt(x)) catch {};
try array.append(parseInt(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseFloat(value_str: []const u8) f64 {
return std.fmt.parseFloat(f64, value_str) catch return 0;
}
pub fn parseArrayFloat(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(f64) {
pub fn parseArrayFloat(allocator: std.mem.Allocator, array_str: []const u8) ![]const f64 {
var array = std.ArrayList(f64).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseFloat(x)) catch {};
try array.append(parseFloat(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseBool(value_str: []const u8) bool {
@ -47,26 +47,26 @@ pub fn parseDate(value_str: []const u8) DateTime {
return DateTime.init(year, month, day, 0, 0, 0, 0);
}
pub fn parseArrayDate(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(DateTime) {
pub fn parseArrayDate(allocator: std.mem.Allocator, array_str: []const u8) ![]const DateTime {
var array = std.ArrayList(DateTime).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseDate(x)) catch {};
try array.append(parseDate(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayDateUnix(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(u64) {
pub fn parseArrayDateUnix(allocator: std.mem.Allocator, array_str: []const u8) ![]const u64 {
var array = std.ArrayList(u64).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseDate(x).toUnix()) catch {};
try array.append(parseDate(x).toUnix());
}
return array;
return array.toOwnedSlice();
}
pub fn parseTime(value_str: []const u8) DateTime {
@ -78,26 +78,26 @@ pub fn parseTime(value_str: []const u8) DateTime {
return DateTime.init(0, 0, 0, hours, minutes, seconds, milliseconds);
}
pub fn parseArrayTime(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(DateTime) {
pub fn parseArrayTime(allocator: std.mem.Allocator, array_str: []const u8) ![]const DateTime {
var array = std.ArrayList(DateTime).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseTime(x)) catch {};
try array.append(parseTime(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayTimeUnix(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(u64) {
pub fn parseArrayTimeUnix(allocator: std.mem.Allocator, array_str: []const u8) ![]const u64 {
var array = std.ArrayList(u64).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseTime(x).toUnix()) catch {};
try array.append(parseTime(x).toUnix());
}
return array;
return try array.toOwnedSlice();
}
pub fn parseDatetime(value_str: []const u8) DateTime {
@ -112,49 +112,49 @@ pub fn parseDatetime(value_str: []const u8) DateTime {
return DateTime.init(year, month, day, hours, minutes, seconds, milliseconds);
}
pub fn parseArrayDatetime(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(DateTime) {
pub fn parseArrayDatetime(allocator: std.mem.Allocator, array_str: []const u8) ![]const DateTime {
var array = std.ArrayList(DateTime).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseDatetime(x)) catch {};
try array.append(parseDatetime(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayDatetimeUnix(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(u64) {
pub fn parseArrayDatetimeUnix(allocator: std.mem.Allocator, array_str: []const u8) ![]const u64 {
var array = std.ArrayList(u64).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseDatetime(x).toUnix()) catch {};
try array.append(parseDatetime(x).toUnix());
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayBool(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(bool) {
pub fn parseArrayBool(allocator: std.mem.Allocator, array_str: []const u8) ![]const bool {
var array = std.ArrayList(bool).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
array.append(parseBool(x)) catch {};
try array.append(parseBool(x));
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayUUID(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList(UUID) {
pub fn parseArrayUUID(allocator: std.mem.Allocator, array_str: []const u8) ![]const UUID {
var array = std.ArrayList(UUID).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
const uuid = UUID.parse(x) catch continue;
array.append(uuid) catch continue;
const uuid = try UUID.parse(x);
try array.append(uuid);
}
return array;
return try array.toOwnedSlice();
}
pub fn parseArrayUUIDBytes(allocator: std.mem.Allocator, array_str: []const u8) ![]const [16]u8 {
@ -162,27 +162,27 @@ pub fn parseArrayUUIDBytes(allocator: std.mem.Allocator, array_str: []const u8)
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], " ");
while (it.next()) |x| {
const uuid = UUID.parse(x) catch continue;
array.append(uuid.bytes) catch continue;
const uuid = try UUID.parse(x);
try array.append(uuid.bytes);
}
return try array.toOwnedSlice();
}
// FIXME: I think it will not work if there is a ' inside the string, even \', need to fix that
pub fn parseArrayStr(allocator: std.mem.Allocator, array_str: []const u8) std.ArrayList([]const u8) {
pub fn parseArrayStr(allocator: std.mem.Allocator, array_str: []const u8) ![]const []const u8 {
var array = std.ArrayList([]const u8).init(allocator);
var it = std.mem.splitAny(u8, array_str[1 .. array_str.len - 1], "'");
_ = it.next(); // SSkip first token that is empty
while (it.next()) |x| {
if (std.mem.eql(u8, " ", x)) continue;
array.append(x) catch {};
try array.append(x);
}
if (array.items.len > 0) allocator.free(array.pop()); // Remove the last because empty like the first one
return array;
return try array.toOwnedSlice();
}
test "Value parsing: Int" {
@ -198,9 +198,9 @@ test "Value parsing: Int" {
// Int array
const array_str = "[1 14 44 42 hello]";
const array = parseArrayInt(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [5]i32 = .{ 1, 14, 44, 42, 0 };
try std.testing.expect(std.mem.eql(i32, array.items, &expected_array));
try std.testing.expect(std.mem.eql(i32, array, &expected_array));
}
test "Value parsing: Float" {
@ -215,9 +215,9 @@ test "Value parsing: Float" {
// Float array
const array_str = "[1.5 14.3 44.9999 42 hello]";
const array = parseArrayFloat(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [5]f64 = .{ 1.5, 14.3, 44.9999, 42, 0 };
try std.testing.expect(std.mem.eql(f64, array.items, &expected_array));
try std.testing.expect(std.mem.eql(f64, array, &expected_array));
}
test "Value parsing: String" {
@ -228,14 +228,9 @@ test "Value parsing: String" {
// string array
const array_str = "['Hello' 'How are you doing ?' '']";
const array = parseArrayStr(allocator, array_str);
defer {
for (array.items) |parsed| {
allocator.free(parsed);
}
array.deinit();
}
defer allocator.free(array);
const expected_array: [3][]const u8 = .{ "'Hello'", "'How are you doing ?'", "''" };
for (array.items, expected_array) |parsed, expected| {
for (array, expected_array) |parsed, expected| {
try std.testing.expect(std.mem.eql(u8, parsed, expected));
}
}
@ -252,9 +247,9 @@ test "Value parsing: Bool array" {
// Bool array
const array_str = "[1 0 0 1 1]";
const array = parseArrayBool(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [5]bool = .{ true, false, false, true, true };
try std.testing.expect(std.mem.eql(bool, array.items, &expected_array));
try std.testing.expect(std.mem.eql(bool, array, &expected_array));
}
test "Value parsing: Date" {
@ -273,13 +268,13 @@ test "Value parsing: Date" {
// Date array
const array_str = "[1920/01/01 1998/01/21 2024/12/31]";
const array = parseArrayDate(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [3]DateTime = .{
DateTime.init(1920, 1, 1, 0, 0, 0, 0),
DateTime.init(1998, 1, 21, 0, 0, 0, 0),
DateTime.init(2024, 12, 31, 0, 0, 0, 0),
};
for (array.items, expected_array) |parsed, expected| {
for (array, expected_array) |parsed, expected| {
try std.testing.expect(expected.compareDate(parsed));
}
}
@ -301,14 +296,14 @@ test "Value parsing: Time" {
// Time array
const array_str = "[12:45:00.0000 18:12:53.7491 02:30:10 12:30]";
const array = parseArrayTime(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [4]DateTime = .{
DateTime.init(0, 0, 0, 12, 45, 0, 0),
DateTime.init(0, 0, 0, 18, 12, 53, 7491),
DateTime.init(0, 0, 0, 2, 30, 10, 0),
DateTime.init(0, 0, 0, 12, 30, 0, 0),
};
for (array.items, expected_array) |parsed, expected| {
for (array, expected_array) |parsed, expected| {
try std.testing.expect(expected.compareTime(parsed));
}
}
@ -330,14 +325,14 @@ test "Value parsing: Datetime" {
// Time array
const array_str = "[1920/01/01-12:45:00.0000 1920/01/01-18:12:53.7491 1920/01/01-02:30:10 1920/01/01-12:30]";
const array = parseArrayDatetime(allocator, array_str);
defer array.deinit();
defer allocator.free(array);
const expected_array: [4]DateTime = .{
DateTime.init(1920, 1, 1, 12, 45, 0, 0),
DateTime.init(1920, 1, 1, 18, 12, 53, 7491),
DateTime.init(1920, 1, 1, 2, 30, 10, 0),
DateTime.init(1920, 1, 1, 12, 30, 0, 0),
};
for (array.items, expected_array) |parsed, expected| {
for (array, expected_array) |parsed, expected| {
try std.testing.expect(expected.compareDatetime(parsed));
}
}

44
src/fileEngine.zig
View File

@ -763,52 +763,52 @@ pub const FileEngine = struct {
datas[i] = zid.Data{ .UUID = uuid.bytes };
},
.int_array => {
var array = s2t.parseArrayInt(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayInt(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initIntArray(zid.allocEncodArray.Int(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initIntArray(zid.allocEncodArray.Int(allocator, array) catch return FileEngineError.AllocEncodError);
},
.float_array => {
var array = s2t.parseArrayFloat(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayFloat(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initFloatArray(zid.allocEncodArray.Float(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initFloatArray(zid.allocEncodArray.Float(allocator, array) catch return FileEngineError.AllocEncodError);
},
.str_array => {
var array = s2t.parseArrayStr(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayStr(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initStrArray(zid.allocEncodArray.Str(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initStrArray(zid.allocEncodArray.Str(allocator, array) catch return FileEngineError.AllocEncodError);
},
.bool_array => {
var array = s2t.parseArrayBool(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayBool(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initFloatArray(zid.allocEncodArray.Bool(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initFloatArray(zid.allocEncodArray.Bool(allocator, array) catch return FileEngineError.AllocEncodError);
},
.link_array => {
const array = s2t.parseArrayUUIDBytes(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer self.allocator.free(array);
defer allocator.free(array);
datas[i] = zid.Data.initUUIDArray(zid.allocEncodArray.UUID(allocator, array) catch return FileEngineError.AllocEncodError);
},
.date_array => {
var array = s2t.parseArrayDateUnix(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayDateUnix(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array) catch return FileEngineError.AllocEncodError);
},
.time_array => {
var array = s2t.parseArrayTimeUnix(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayTimeUnix(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array) catch return FileEngineError.AllocEncodError);
},
.datetime_array => {
var array = s2t.parseArrayDatetimeUnix(allocator, map.get(member).?);
defer array.deinit();
const array = s2t.parseArrayDatetimeUnix(allocator, map.get(member).?) catch return FileEngineError.MemoryError;
defer allocator.free(array);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array.items) catch return FileEngineError.AllocEncodError);
datas[i] = zid.Data.initUnixArray(zid.allocEncodArray.Unix(allocator, array) catch return FileEngineError.AllocEncodError);
},
}
}