508 lines
21 KiB
Zig
508 lines
21 KiB
Zig
|
const std = @import("std");
|
||
|
|
const xml = @import("xml.zig");
|
||
|
|
|
||
|
|
fn Parsed(comptime T: type) type {
|
||
|
|
return struct {
|
||
|
|
allocator: std.mem.Allocator,
|
||
|
|
parsed_value: T,
|
||
|
|
|
||
|
|
const Self = @This();
|
||
|
|
|
||
|
|
pub fn init(allocator: std.mem.Allocator, parsedObj: T) Self {
|
||
|
|
return .{
|
||
|
|
.allocator = allocator,
|
||
|
|
.parsed_value = parsedObj,
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn deinit(self: Self) void {
|
||
|
|
deinitObject(self.allocator, self.parsed_value);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn deinitObject(allocator: std.mem.Allocator, obj: anytype) void {
|
||
|
|
switch (@typeInfo(@TypeOf(obj))) {
|
||
|
|
.Optional => if (obj) |o| deinitObject(allocator, o),
|
||
|
|
.Union => |union_info| {
|
||
|
|
inline for (union_info.fields) |field| {
|
||
|
|
std.debug.print("{s}", field); // need to find active field and deinit it
|
||
|
|
}
|
||
|
|
},
|
||
|
|
.Struct => |struct_info| {
|
||
|
|
inline for (struct_info.fields) |field| {
|
||
|
|
deinitObject(allocator, @field(obj, field.name));
|
||
|
|
}
|
||
|
|
},
|
||
|
|
.Array => {}, // Not implemented below
|
||
|
|
.Pointer => |ptr_info| {
|
||
|
|
switch (ptr_info.size) {
|
||
|
|
.One => {
|
||
|
|
deinitObject(allocator, obj.*);
|
||
|
|
allocator.free(obj);
|
||
|
|
},
|
||
|
|
.Many => {},
|
||
|
|
.C => {},
|
||
|
|
.Slice => {
|
||
|
|
allocator.free(obj);
|
||
|
|
},
|
||
|
|
}
|
||
|
|
},
|
||
|
|
//.Bool, .Float, .ComptimeFloat, .Int, .ComptimeInt, .Enum, .Opaque => {}, // no allocations here
|
||
|
|
else => {},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn Parser(comptime T: type) type {
|
||
|
|
return struct {
|
||
|
|
ParseType: type = T,
|
||
|
|
ReturnType: type = Parsed(T),
|
||
|
|
|
||
|
|
const Self = @This();
|
||
|
|
|
||
|
|
pub fn parse(source: []const u8, options: ParseOptions) !Parsed(T) {
|
||
|
|
if (options.allocator == null)
|
||
|
|
return error.AllocatorRequired; // we are only leaving it be null for compatibility with json
|
||
|
|
const allocator = options.allocator.?;
|
||
|
|
const parse_allocator = std.heap.ArenaAllocator.init(allocator);
|
||
|
|
const parsed = try xml.parse(allocator, source);
|
||
|
|
defer parsed.deinit();
|
||
|
|
defer parse_allocator.deinit();
|
||
|
|
return Parsed(T).init(allocator, try parseInternal(T, parsed.root, options));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
// should we just use json parse options?
|
||
|
|
pub const ParseOptions = struct {
|
||
|
|
allocator: ?std.mem.Allocator = null,
|
||
|
|
match_predicate: ?fn (a: []const u8, b: []const u8, options: xml.PredicateOptions) anyerror!bool = null,
|
||
|
|
};
|
||
|
|
|
||
|
|
pub fn parse(comptime T: type, source: []const u8, options: ParseOptions) !Parsed(T) {
|
||
|
|
if (options.allocator == null)
|
||
|
|
return error.AllocatorRequired; // we are only leaving it be null for compatibility with json
|
||
|
|
const allocator = options.allocator.?;
|
||
|
|
var parse_allocator = std.heap.ArenaAllocator.init(allocator);
|
||
|
|
const parsed = try xml.parse(parse_allocator.allocator(), source);
|
||
|
|
// defer parsed.deinit(); // Let the arena allocator whack it all
|
||
|
|
defer parse_allocator.deinit();
|
||
|
|
return Parsed(T).init(allocator, try parseInternal(T, parsed.root, options));
|
||
|
|
}
|
||
|
|
|
||
|
|
fn parseInternal(comptime T: type, element: *xml.Element, options: ParseOptions) !T {
|
||
|
|
switch (@typeInfo(T)) {
|
||
|
|
.Bool => {
|
||
|
|
if (std.ascii.eqlIgnoreCase("true", element.children.items[0].CharData))
|
||
|
|
return true;
|
||
|
|
if (std.ascii.eqlIgnoreCase("false", element.children.items[0].CharData))
|
||
|
|
return false;
|
||
|
|
return error.UnexpectedToken;
|
||
|
|
},
|
||
|
|
.Float, .ComptimeFloat => {
|
||
|
|
return try std.fmt.parseFloat(T, element.children.items[0].CharData);
|
||
|
|
},
|
||
|
|
.Int, .ComptimeInt => {
|
||
|
|
return try std.fmt.parseInt(T, element.children.items[0].CharData, 10);
|
||
|
|
},
|
||
|
|
.Optional => |optional_info| {
|
||
|
|
if (element.children.items.len == 0) {
|
||
|
|
// This is almost certainly incomplete. Empty strings? xsi:nil?
|
||
|
|
return null;
|
||
|
|
} else {
|
||
|
|
// return try parseInternal(optional_info.child, element.elements().next().?, options);
|
||
|
|
return try parseInternal(optional_info.child, element, options);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
.Enum => |enum_info| {
|
||
|
|
_ = enum_info;
|
||
|
|
// const numeric: ?enum_info.tag_type = std.fmt.parseInt(enum_info.tag_type, element.children.items[0].CharData, 10) catch null;
|
||
|
|
// if (numeric) |num| {
|
||
|
|
// return std.meta.intToEnum(T, num);
|
||
|
|
// } else {
|
||
|
|
// // json parser handles escaping - could this happen here or does chardata handle?
|
||
|
|
// return std.meta.stringToEnum(T, element.CharData);
|
||
|
|
// }
|
||
|
|
},
|
||
|
|
.Union => |union_info| {
|
||
|
|
if (union_info.tag_type) |_| {
|
||
|
|
// try each of the union fields until we find one that matches
|
||
|
|
// inline for (union_info.fields) |u_field| {
|
||
|
|
// // take a copy of tokens so we can withhold mutations until success
|
||
|
|
// var tokens_copy = tokens.*;
|
||
|
|
// if (parseInternal(u_field.field_type, token, &tokens_copy, options)) |value| {
|
||
|
|
// tokens.* = tokens_copy;
|
||
|
|
// return @unionInit(T, u_field.name, value);
|
||
|
|
// } else |err| {
|
||
|
|
// // Bubble up error.OutOfMemory
|
||
|
|
// // Parsing some types won't have OutOfMemory in their
|
||
|
|
// // error-sets, for the condition to be valid, merge it in.
|
||
|
|
// if (@as(@TypeOf(err) || error{OutOfMemory}, err) == error.OutOfMemory) return err;
|
||
|
|
// // Bubble up AllocatorRequired, as it indicates missing option
|
||
|
|
// if (@as(@TypeOf(err) || error{AllocatorRequired}, err) == error.AllocatorRequired) return err;
|
||
|
|
// // otherwise continue through the `inline for`
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
return error.NoUnionMembersMatched;
|
||
|
|
} else {
|
||
|
|
@compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'");
|
||
|
|
}
|
||
|
|
},
|
||
|
|
.Struct => |struct_info| {
|
||
|
|
var r: T = undefined;
|
||
|
|
var fields_seen = [_]bool{false} ** struct_info.fields.len;
|
||
|
|
var fields_set: u64 = 0;
|
||
|
|
// errdefer {
|
||
|
|
// // TODO: why so high here? This was needed for ec2 describe instances
|
||
|
|
// @setEvalBranchQuota(100000);
|
||
|
|
// inline for (struct_info.fields) |field, i| {
|
||
|
|
// if (fields_seen[i] and !field.is_comptime) {
|
||
|
|
// parseFree(field.field_type, @field(r, field.name), options);
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
|
||
|
|
// XML parser provides CharData for whitespace around elements.
|
||
|
|
// We shall ignore extra data for the moment as a performance thing
|
||
|
|
// if (element.children.items.len > struct_info.fields.len) {
|
||
|
|
// std.debug.print("element children: {d}, struct fields: {d}\n", .{ element.children.items.len, struct_info.fields.len });
|
||
|
|
// for (element.children.items) |child, i| {
|
||
|
|
// switch (child) {
|
||
|
|
// .CharData => std.debug.print("{d}: {s}\n", .{ i, child }),
|
||
|
|
// .Comment => {},
|
||
|
|
// .Element => {},
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// return error.MoreElementsThanFields;
|
||
|
|
// }
|
||
|
|
|
||
|
|
inline for (struct_info.fields) |field, i| {
|
||
|
|
var name = field.name;
|
||
|
|
if (comptime std.meta.trait.hasFn("fieldNameFor")(T))
|
||
|
|
name = r.fieldNameFor(field.name);
|
||
|
|
std.log.debug("Field name: {s}, Element: {s}, Adjusted field name: {s}\n", .{ field.name, element.tag, name });
|
||
|
|
var iterator = element.findChildrenByTag(name);
|
||
|
|
if (options.match_predicate) |predicate| {
|
||
|
|
iterator.predicate = predicate;
|
||
|
|
iterator.predicate_options = .{ .allocator = options.allocator.? };
|
||
|
|
}
|
||
|
|
if (try iterator.next()) |child| {
|
||
|
|
// I don't know that we would use comptime here. I'm also
|
||
|
|
// not sure the nuance of setting this...
|
||
|
|
// if (field.is_comptime) {
|
||
|
|
// if (!try parsesTo(field.field_type, field.default_value.?, tokens, options)) {
|
||
|
|
// return error.UnexpectedValue;
|
||
|
|
// }
|
||
|
|
// } else {
|
||
|
|
@field(r, field.name) = try parseInternal(field.field_type, child, options);
|
||
|
|
fields_seen[i] = true;
|
||
|
|
fields_set = fields_set + 1;
|
||
|
|
// }
|
||
|
|
|
||
|
|
} else {
|
||
|
|
return error.NoValueForField;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (fields_set != struct_info.fields.len)
|
||
|
|
return error.FieldElementMismatch; // see fields_seen for details
|
||
|
|
return r;
|
||
|
|
},
|
||
|
|
.Array => //|array_info| {
|
||
|
|
return error.ArrayNotImplemented,
|
||
|
|
// switch (token) {
|
||
|
|
// .ArrayBegin => {
|
||
|
|
// var r: T = undefined;
|
||
|
|
// var i: usize = 0;
|
||
|
|
// errdefer {
|
||
|
|
// while (true) : (i -= 1) {
|
||
|
|
// parseFree(arrayInfo.child, r[i], options);
|
||
|
|
// if (i == 0) break;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
// while (i < r.len) : (i += 1) {
|
||
|
|
// r[i] = try parse(arrayInfo.child, tokens, options);
|
||
|
|
// }
|
||
|
|
// const tok = (try tokens.next()) orelse return error.UnexpectedEndOfJson;
|
||
|
|
// switch (tok) {
|
||
|
|
// .ArrayEnd => {},
|
||
|
|
// else => return error.UnexpectedToken,
|
||
|
|
// }
|
||
|
|
// return r;
|
||
|
|
// },
|
||
|
|
// .String => |stringToken| {
|
||
|
|
// if (arrayInfo.child != u8) return error.UnexpectedToken;
|
||
|
|
// var r: T = undefined;
|
||
|
|
// const source_slice = stringToken.slice(tokens.slice, tokens.i - 1);
|
||
|
|
// switch (stringToken.escapes) {
|
||
|
|
// .None => mem.copy(u8, &r, source_slice),
|
||
|
|
// .Some => try unescapeValidString(&r, source_slice),
|
||
|
|
// }
|
||
|
|
// return r;
|
||
|
|
// },
|
||
|
|
// else => return error.UnexpectedToken,
|
||
|
|
// }
|
||
|
|
// },
|
||
|
|
.Pointer => |ptr_info| {
|
||
|
|
const allocator = options.allocator orelse return error.AllocatorRequired;
|
||
|
|
switch (ptr_info.size) {
|
||
|
|
.One => {
|
||
|
|
const r: T = try allocator.create(ptr_info.child);
|
||
|
|
errdefer allocator.free(r);
|
||
|
|
r.* = try parseInternal(ptr_info.child, element, options);
|
||
|
|
return r;
|
||
|
|
},
|
||
|
|
.Slice => {
|
||
|
|
// TODO: Detect and deal with arrays. This will require two
|
||
|
|
// passes through the element children - one to
|
||
|
|
// determine if it is an array, one to parse the elements
|
||
|
|
// <Items>
|
||
|
|
// <Item>foo</Item>
|
||
|
|
// <Item>bar</Item>
|
||
|
|
// <Items>
|
||
|
|
if (ptr_info.child != u8) {
|
||
|
|
std.log.debug("ptr_info.child == {s}", .{@typeName(ptr_info.child)});
|
||
|
|
const children = try allocator.alloc(ptr_info.child, element.children.items.len);
|
||
|
|
var inx: usize = 0;
|
||
|
|
while (inx < children.len) {
|
||
|
|
children[inx] = try parseInternal(ptr_info.child, element.children.items[inx].Element, options);
|
||
|
|
inx += 1;
|
||
|
|
}
|
||
|
|
return children;
|
||
|
|
}
|
||
|
|
return try allocator.dupe(u8, element.children.items[0].CharData);
|
||
|
|
},
|
||
|
|
.Many => {
|
||
|
|
return error.ManyPointerSizeNotImplemented;
|
||
|
|
},
|
||
|
|
.C => {
|
||
|
|
return error.CPointerSizeNotImplemented;
|
||
|
|
},
|
||
|
|
}
|
||
|
|
},
|
||
|
|
else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
|
||
|
|
// }
|
||
|
|
// },
|
||
|
|
// else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
|
||
|
|
}
|
||
|
|
unreachable;
|
||
|
|
}
|
||
|
|
pub fn fuzzyEqual(a: []const u8, b: []const u8, options: xml.PredicateOptions) !bool {
|
||
|
|
const allocator = options.allocator orelse return error.AllocatorRequired;
|
||
|
|
// std.debug.print("raw: a = '{s}', b = '{s}'\n", .{ a, b });
|
||
|
|
const lower_a = try std.ascii.allocLowerString(allocator, a);
|
||
|
|
defer allocator.free(lower_a);
|
||
|
|
const lower_b = try std.ascii.allocLowerString(allocator, b);
|
||
|
|
defer allocator.free(lower_b);
|
||
|
|
// std.debug.print("lower: a = '{s}', b = '{s}'\n", .{ lower_a, lower_b });
|
||
|
|
const normal_a = normalize(lower_a);
|
||
|
|
const normal_b = normalize(lower_b);
|
||
|
|
|
||
|
|
// std.debug.print("normal: a = '{s}', b = '{s}'\n", .{ normal_a, normal_b });
|
||
|
|
return std.mem.eql(u8, normal_a, normal_b);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn normalize(val: []u8) []u8 {
|
||
|
|
var underscores: u64 = 0;
|
||
|
|
for (val) |ch, i| {
|
||
|
|
if (ch == '_') {
|
||
|
|
underscores = underscores + 1;
|
||
|
|
} else {
|
||
|
|
val[i - underscores] = ch;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return val[0 .. val.len - underscores];
|
||
|
|
}
|
||
|
|
|
||
|
|
const testing = std.testing;
|
||
|
|
test "can parse a simple type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
// defer allocator.free(snake_case);
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <fooBar>bar</fooBar>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo_bar: []const u8,
|
||
|
|
};
|
||
|
|
// std.debug.print("{s}", .{data});
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqualStrings("bar", parsed_data.parsed_value.foo_bar);
|
||
|
|
}
|
||
|
|
|
||
|
|
test "can parse a boolean type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
// defer allocator.free(snake_case);
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <fooBar>true</fooBar>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo_bar: bool,
|
||
|
|
};
|
||
|
|
// std.debug.print("{s}", .{data});
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqual(true, parsed_data.parsed_value.foo_bar);
|
||
|
|
}
|
||
|
|
test "can parse an integer type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
// defer allocator.free(snake_case);
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <fooBar>42</fooBar>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo_bar: u8,
|
||
|
|
};
|
||
|
|
// std.debug.print("{s}", .{data});
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqual(@as(u8, 42), parsed_data.parsed_value.foo_bar);
|
||
|
|
}
|
||
|
|
test "can parse a boolean type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
// defer allocator.free(snake_case);
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <fooBar>true</fooBar>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo_bar: bool,
|
||
|
|
};
|
||
|
|
// std.debug.print("{s}", .{data});
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqual(true, parsed_data.parsed_value.foo_bar);
|
||
|
|
}
|
||
|
|
test "can parse an optional boolean type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <fooBar>true</fooBar>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo_bar: ?bool = null,
|
||
|
|
};
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqual(@as(?bool, true), parsed_data.parsed_value.foo_bar);
|
||
|
|
}
|
||
|
|
test "can parse a nested type" {
|
||
|
|
const allocator = std.testing.allocator;
|
||
|
|
const data =
|
||
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
\\<Example xmlns="http://example.example.com/doc/2016-11-15/">
|
||
|
|
\\ <foo>
|
||
|
|
\\ <bar>baz</bar>
|
||
|
|
\\ </foo>
|
||
|
|
\\</Example>
|
||
|
|
;
|
||
|
|
const Example = struct {
|
||
|
|
foo: struct {
|
||
|
|
bar: []const u8,
|
||
|
|
},
|
||
|
|
};
|
||
|
|
const parsed_data = try parse(Example, data, .{ .allocator = allocator, .match_predicate = fuzzyEqual });
|
||
|
|
defer parsed_data.deinit();
|
||
|
|
try testing.expectEqualStrings("baz", parsed_data.parsed_value.foo.bar);
|
||
|
|
}
|
||
|
|
|
||
|
|
const service_metadata: struct {
|
||
|
|
version: []const u8 = "2016-11-15",
|
||
|
|
sdk_id: []const u8 = "EC2",
|
||
|
|
arn_namespace: []const u8 = "ec2",
|
||
|
|
endpoint_prefix: []const u8 = "ec2",
|
||
|
|
sigv4_name: []const u8 = "ec2",
|
||
|
|
name: []const u8 = "AmazonEC2",
|
||
|
|
} = .{};
|
||
|
|
|
||
|
|
const describe_regions: struct {
|
||
|
|
action_name: []const u8 = "DescribeRegions",
|
||
|
|
Request: type = struct {
|
||
|
|
// filters: ?[]Filter = null,
|
||
|
|
region_names: ?[][]const u8 = null,
|
||
|
|
dry_run: ?bool = null,
|
||
|
|
all_regions: ?bool = null,
|
||
|
|
|
||
|
|
pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
|
||
|
|
const mappings = .{
|
||
|
|
.filters = "Filter",
|
||
|
|
.region_names = "RegionName",
|
||
|
|
.dry_run = "dryRun",
|
||
|
|
.all_regions = "AllRegions",
|
||
|
|
};
|
||
|
|
return @field(mappings, field_name);
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn metaInfo() struct { service_metadata: @TypeOf(service_metadata), action: @TypeOf(describe_regions) } {
|
||
|
|
return .{ .service_metadata = service_metadata, .action = describe_regions };
|
||
|
|
}
|
||
|
|
},
|
||
|
|
Response: type = struct {
|
||
|
|
regions: ?[]struct {
|
||
|
|
endpoint: ?[]const u8 = null,
|
||
|
|
region_name: ?[]const u8 = null,
|
||
|
|
opt_in_status: ?[]const u8 = null,
|
||
|
|
|
||
|
|
pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
|
||
|
|
const mappings = .{
|
||
|
|
.endpoint = "regionEndpoint",
|
||
|
|
.region_name = "regionName",
|
||
|
|
.opt_in_status = "optInStatus",
|
||
|
|
};
|
||
|
|
return @field(mappings, field_name);
|
||
|
|
}
|
||
|
|
} = null,
|
||
|
|
|
||
|
|
pub fn fieldNameFor(_: @This(), comptime field_name: []const u8) []const u8 {
|
||
|
|
const mappings = .{
|
||
|
|
.regions = "regionInfo",
|
||
|
|
};
|
||
|
|
return @field(mappings, field_name);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
} = .{};
|
||
|
|
|
||
|
|
// This test results in "broken LLVM module found: Operand is null"
|
||
|
|
// br i1 %120, label %ErrRetReturn12, <null operand!>, !dbg !10637
|
||
|
|
//
|
||
|
|
// This is a bug in the Zig compiler.
|
||
|
|
// test "can parse something serious" {
|
||
|
|
// std.testing.log_level = .debug;
|
||
|
|
// std.log.debug("", .{});
|
||
|
|
//
|
||
|
|
// const allocator = std.testing.allocator;
|
||
|
|
// const data =
|
||
|
|
// \\<?xml version="1.0" encoding="UTF-8"?>
|
||
|
|
// \\<DescribeRegionsResponse xmlns="http://ec2.amazonaws.com/doc/2016-11-15/">
|
||
|
|
// \\ <requestId>8d6bfc99-978b-4146-ba23-2e5fe5b65406</requestId>
|
||
|
|
// \\ <regionInfo>
|
||
|
|
// \\ <item>
|
||
|
|
// \\ <regionName>eu-north-1</regionName>
|
||
|
|
// \\ <regionEndpoint>ec2.eu-north-1.amazonaws.com</regionEndpoint>
|
||
|
|
// \\ <optInStatus>opt-in-not-required</optInStatus>
|
||
|
|
// \\ </item>
|
||
|
|
// \\ <item>
|
||
|
|
// \\ <regionName>ap-south-1</regionName>
|
||
|
|
// \\ <regionEndpoint>ec2.ap-south-1.amazonaws.com</regionEndpoint>
|
||
|
|
// \\ <optInStatus>opt-in-not-required</optInStatus>
|
||
|
|
// \\ </item>
|
||
|
|
// \\ </regionInfo>
|
||
|
|
// \\</DescribeRegionsResponse>
|
||
|
|
// ;
|
||
|
|
// const parsed_data = try parse(describe_regions.Response, data, .{ .allocator = allocator });
|
||
|
|
// defer parsed_data.deinit();
|
||
|
|
// try testing.expect(parsed_data.parsed_value.regions != null);
|
||
|
|
// // try testing.expectEqualStrings("eu-north-1", parsed_data.parsed_value.regions.?[0].region_name.?);
|
||
|
|
// }
|