const std = @import("std"); const json_write = @import("../json/write.zig"); const msgpack = @import("../msgpack_utils.zig"); const schema_types = @import("../schema/types.zig"); const doc_id = @import("doc_id.zig"); const types = @import("types.zig"); const Allocator = std.mem.Allocator; const ScalarValue = types.ScalarValue; const Value = types.Value; pub fn writeMsgPack(value: Value, writer: anytype) !void { switch (value) { .nil => try msgpack.encode(.nil, writer), .scalar => |s| try writeScalarMsgPack(s, writer), .array => |arr| { try msgpack.encodeArrayHeader(writer, arr.len); for (arr) |item| { try writeScalarMsgPack(item, writer); } }, } } fn writeScalarMsgPack(value: ScalarValue, writer: anytype) !void { switch (value) { .doc_id => |id| { const bytes = doc_id.toBytes(id); try msgpack.writeMsgPackBin(writer, &bytes); }, .integer => |iv| { if (iv >= 0) { try msgpack.encode(msgpack.Payload{ .uint = @intCast(iv) }, writer); } else { try msgpack.encode(msgpack.Payload{ .int = iv }, writer); } }, .real => |rv| try msgpack.encode(msgpack.Payload{ .float = rv }, writer), .text => |tv| try msgpack.writeMsgPackStr(writer, tv), .boolean => |bv| try msgpack.encode(msgpack.Payload{ .bool = bv }, writer), .binary => |bv| try msgpack.writeMsgPackBin(writer, bv), } } pub fn writeJsonToBuf(buf: *std.ArrayListUnmanaged(u8), allocator: Allocator, value: Value) !void { var w = json_write.Writer{ .buf = buf, .allocator = allocator }; switch (value) { .nil => try buf.appendSlice(allocator, "null"), .scalar => |s| try writeScalarJsonToBuf(&w, s), .array => |items| { try w.beginArray(); for (items) |item| { try writeScalarJsonToBuf(&w, item); } try w.endArray(); }, } } fn writeScalarJsonToBuf(w: *json_write.Writer, value: ScalarValue) !void { switch (value) { .doc_id => |id| { var hex_buf: [32]u8 = undefined; const hex = doc_id.hexSlice(id, &hex_buf); try w.stringValue(hex); }, .integer => |v| try w.intValue(v), .real => |v| try w.floatValue(v), .text => |s| try w.stringValue(s), .boolean => |b| try w.boolValue(b), .binary => |b| { const hex = try w.allocator.alloc(u8, b.len * 2); defer w.allocator.free(hex); const digits = "0123456789abcdef"; for (b, 0..) |byte, i| { hex[i * 2] = digits[byte >> 4]; hex[i * 2 + 1] = digits[byte & 0x0f]; } try w.stringValue(hex); }, } } pub fn validateValue(ft: schema_types.FieldType, value: msgpack.Payload) !void { const match = switch (ft) { .doc_id => value == .bin, .text => value == .str, .integer => value == .int or value == .uint, .real => value == .float or value == .uint or value == .int, .boolean => value == .bool, .array => value == .arr, .bytes => value == .bin, }; if (!match) return error.TypeMismatch; } fn buildArrayValue( allocator: Allocator, comptime Item: type, items: []const Item, items_type: schema_types.FieldType, comptime decode_fn: fn (Allocator, schema_types.FieldType, Item) anyerror!ScalarValue, comptime is_nil_fn: fn (Item) bool, ) !Value { const result_items = try allocator.alloc(ScalarValue, items.len); var i: usize = 0; errdefer { for (result_items[0..i]) |*item| item.deinit(allocator); allocator.free(result_items); } while (i < items.len) : (i += 1) { if (is_nil_fn(items[i])) return error.NullNotAllowed; result_items[i] = try decode_fn(allocator, items_type, items[i]); } var result = Value{ .array = result_items }; try result.sortedSet(allocator); return result; } pub fn fromPayload(allocator: Allocator, ft: schema_types.FieldType, items_type: ?schema_types.FieldType, value: msgpack.Payload) !Value { if (value == .nil) return .nil; return switch (ft) { .array => { const it = items_type orelse return error.TypeMismatch; return buildArrayValue(allocator, msgpack.Payload, value.arr, it, scalarFromPayload, struct { fn f(v: msgpack.Payload) bool { return v == .nil; } }.f); }, else => .{ .scalar = try scalarFromPayload(allocator, ft, value) }, }; } pub fn fromJson(allocator: Allocator, ft: schema_types.FieldType, items_type: ?schema_types.FieldType, value: std.json.Value) !Value { if (value == .null) return .nil; return switch (ft) { .array => { if (value != .array) return error.TypeMismatch; const it = items_type orelse return error.TypeMismatch; return buildArrayValue(allocator, std.json.Value, value.array.items, it, scalarFromJson, struct { fn f(v: std.json.Value) bool { return v == .null; } }.f); }, else => .{ .scalar = try scalarFromJson(allocator, ft, value) }, }; } fn scalarFromDynamicJsonItem(allocator: Allocator, item: std.json.Value) !ScalarValue { return switch (item) { .string => |s| .{ .text = try allocator.dupe(u8, s) }, .integer => |n| .{ .integer = n }, .float => |f| .{ .real = f }, .bool => |b| .{ .boolean = b }, else => error.InvalidClaimArrayElement, }; } pub fn fromDynamicJson(allocator: Allocator, value: std.json.Value) !Value { return switch (value) { .string => |s| .{ .scalar = .{ .text = try allocator.dupe(u8, s) } }, .integer => |i| .{ .scalar = .{ .integer = i } }, .float => |f| .{ .scalar = .{ .real = f } }, .bool => |b| .{ .scalar = .{ .boolean = b } }, .array => |arr| blk: { if (arr.items.len > 1000) return error.ClaimArrayTooLarge; const items = try allocator.alloc(ScalarValue, arr.items.len); var initialized: usize = 0; errdefer { for (items[0..initialized]) |*item| item.deinit(allocator); allocator.free(items); } for (arr.items, 0..) |item, i| { items[i] = try scalarFromDynamicJsonItem(allocator, item); initialized += 1; } break :blk .{ .array = items }; }, else => return error.UnsupportedClaimType, }; } fn scalarFromPayload(allocator: Allocator, ft: schema_types.FieldType, value: msgpack.Payload) !ScalarValue { return switch (ft) { .doc_id => switch (value) { .bin => |b| ScalarValue{ .doc_id = try doc_id.fromBytes(b.value()) }, else => error.TypeMismatch, }, .text => switch (value) { .str => |s| ScalarValue{ .text = try allocator.dupe(u8, s.value()) }, else => error.TypeMismatch, }, .integer => ScalarValue{ .integer = try msgpack.payloadToInt(value) }, .real => ScalarValue{ .real = try msgpack.payloadToFloat(value) }, .boolean => ScalarValue{ .boolean = try msgpack.payloadToBool(value) }, .bytes => switch (value) { .bin => |b| ScalarValue{ .binary = try allocator.dupe(u8, b.value()) }, else => error.TypeMismatch, }, else => error.InvalidArrayElement, }; } fn scalarFromJson(allocator: Allocator, ft: schema_types.FieldType, value: std.json.Value) !ScalarValue { return switch (ft) { .doc_id => switch (value) { .string => |s| ScalarValue{ .doc_id = doc_id.fromHex(s) catch return error.TypeMismatch }, else => error.TypeMismatch, }, .text => switch (value) { .string => |s| ScalarValue{ .text = try allocator.dupe(u8, s) }, else => error.TypeMismatch, }, .bytes => switch (value) { .string => |s| { if (s.len % 2 != 0) return error.TypeMismatch; const byte_len = s.len / 2; const buf = try allocator.alloc(u8, byte_len); errdefer allocator.free(buf); _ = std.fmt.hexToBytes(buf, s) catch return error.TypeMismatch; return ScalarValue{ .binary = buf }; }, else => error.TypeMismatch, }, .integer => ScalarValue{ .integer = try jsonAsInt(value) }, .real => ScalarValue{ .real = try jsonAsFloat(value) }, .boolean => ScalarValue{ .boolean = try jsonAsBool(value) }, else => error.InvalidArrayElement, }; } fn jsonAsInt(value: std.json.Value) !i64 { return switch (value) { .integer => |v| v, .number_string => |s| std.fmt.parseInt(i64, s, 10) catch return error.TypeMismatch, else => error.TypeMismatch, }; } fn jsonAsFloat(value: std.json.Value) !f64 { return switch (value) { .float => |v| v, .integer => |v| @floatFromInt(v), .number_string => |s| std.fmt.parseFloat(f64, s) catch return error.TypeMismatch, else => error.TypeMismatch, }; } fn jsonAsBool(value: std.json.Value) !bool { return switch (value) { .bool => |v| v, else => error.TypeMismatch, }; }