stdassertAllocatorArenaAllocatorArrayListScannerTokenAllocWhendefault_max_value_lenisNumberFormattedLikeAnIntegerValueArrayParseOptionsParsedparseFromSliceparseFromSliceLeakyparseFromTokenSourceparseFromTokenSourceLeakyparseFromValueparseFromValueLeakyParseErrorParseFromValueErrorinnerParseinternalParseArrayinnerParseFromValueinnerParseArrayFromArrayValuesliceToIntsliceToEnumfillDefaultStructValuesfreeAllocated
std.json.static.Allocator
alias
Alias of std.mem.Allocator
std.json.static.AllocWhen
alias
Alias of std.json.Scanner.AllocWhen
std.json.static.ArenaAllocator
alias
Alias of std.heap.ArenaAllocator
std.json.static.Array
alias
Alias of std.json.dynamic.Array
std.json.static.ArrayList
alias
Alias of std.array_list.Managed
std.json.static.assert
alias
Alias of std.debug.assert
std.json.static.default_max_value_len
alias
std.json.static.fillDefaultStructValues
function
fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".field_names.len]bool) !void
Parameters
T: type
r: *T
fields_seen: *[@typeInfo(T).@"struct".field_names.len]bool
std.json.static.freeAllocated
function
fn freeAllocated(allocator: Allocator, token: Token) void
Parameters
std.json.static.innerParse
function
This is an internal function called recursively
during the implementation of parseFromTokenSourceLeaky and similar.
It is exposed primarily to enable custom jsonParse() methods to call back into the parseFrom* system,
such as if you're implementing a custom container of type T;
you can call innerParse(T, ...) for each of the container's items.
Note that null fields are not allowed on the options when calling this function.
(The options you get in your jsonParse method has no null fields.)
pub fn innerParse( comptime T: type, allocator: Allocator, source: anytype, options: ParseOptions, ) ParseError(@TypeOf(source.*))!T
Parameters
std.json.static.innerParseArrayFromArrayValue
function
fn innerParseArrayFromArrayValue( comptime T: type, comptime Child: type, comptime len: comptime_int, allocator: Allocator, array: Array, options: ParseOptions, ) !T
Parameters
std.json.static.innerParseFromValue
function
This is an internal function called recursively
during the implementation of parseFromValueLeaky.
It is exposed primarily to enable custom jsonParseFromValue() methods to call back into the parseFromValue* system,
such as if you're implementing a custom container of type T;
you can call innerParseFromValue(T, ...) for each of the container's items.
pub fn innerParseFromValue( comptime T: type, allocator: Allocator, source: Value, options: ParseOptions, ) ParseFromValueError!T
Parameters
Errors
- DuplicateField
- InvalidCharacter ParseIntError
The input was empty or contained an invalid character.
- InvalidEnumTag
- InvalidNumber
- LengthMismatch
- MissingField
- OutOfMemory Error
- Overflow ParseIntError
The result cannot fit in the type specified.
- UnexpectedToken
- UnknownField
std.json.static.internalParseArray
function
fn internalParseArray( comptime T: type, comptime Child: type, allocator: Allocator, source: anytype, options: ParseOptions, ) !T
Parameters
std.json.static.isNumberFormattedLikeAnInteger
alias
std.json.static.Parsed
type-function
pub fn Parsed(comptime T: type) type
Parameters
T: type
Fields
arena: *ArenaAllocator
value: T
std.json.static.Parsed.deinit
function
pub fn deinit(self: @This()) void
Parameters
self: @This()
std.json.static.ParseError
type-function
The error set that will be returned when parsing from *Source.
Note that this may contain error.BufferUnderrun, but that error will never actually be returned.
pub fn ParseError(comptime Source: type) type
Parameters
Source: type
std.json.static.parseFromSlice
function
Parses the json document from s and returns the result packaged in a std.json.Parsed.
You must call deinit() of the returned object to clean up allocated resources.
If you are using a std.heap.ArenaAllocator or similar, consider calling parseFromSliceLeaky instead.
Note that error.BufferUnderrun is not actually possible to return from this function.
pub fn parseFromSlice( comptime T: type, allocator: Allocator, s: []const u8, options: ParseOptions, ) ParseError(Scanner)!Parsed(T)
Parameters
std.json.static.parseFromSliceLeaky
function
Parses the json document from s and returns the result.
Allocations made during this operation are not carefully tracked and may not be possible to individually clean up.
It is recommended to use a std.heap.ArenaAllocator or similar.
pub fn parseFromSliceLeaky( comptime T: type, allocator: Allocator, s: []const u8, options: ParseOptions, ) ParseError(Scanner)!T
Parameters
std.json.static.parseFromTokenSource
function
scanner_or_reader must be either a *std.json.Scanner with complete input or a *std.json.Reader.
Note that error.BufferUnderrun is not actually possible to return from this function.
pub fn parseFromTokenSource( comptime T: type, allocator: Allocator, scanner_or_reader: anytype, options: ParseOptions, ) ParseError(@TypeOf(scanner_or_reader.*))!Parsed(T)
Parameters
std.json.static.parseFromTokenSourceLeaky
function
scanner_or_reader must be either a *std.json.Scanner with complete input or a *std.json.Reader.
Allocations made during this operation are not carefully tracked and may not be possible to individually clean up.
It is recommended to use a std.heap.ArenaAllocator or similar.
pub fn parseFromTokenSourceLeaky( comptime T: type, allocator: Allocator, scanner_or_reader: anytype, options: ParseOptions, ) ParseError(@TypeOf(scanner_or_reader.*))!T
Parameters
std.json.static.parseFromValue
function
Like parseFromSlice, but the input is an already-parsed std.json.Value object.
Only options.ignore_unknown_fields is used from options.
pub fn parseFromValue( comptime T: type, allocator: Allocator, source: Value, options: ParseOptions, ) ParseFromValueError!Parsed(T)
Parameters
Errors
- DuplicateField
- InvalidCharacter ParseIntError
The input was empty or contained an invalid character.
- InvalidEnumTag
- InvalidNumber
- LengthMismatch
- MissingField
- OutOfMemory Error
- Overflow ParseIntError
The result cannot fit in the type specified.
- UnexpectedToken
- UnknownField
std.json.static.ParseFromValueError
error-set
Errors
- DuplicateField
- InvalidCharacter ParseIntError
The input was empty or contained an invalid character.
- InvalidEnumTag
- InvalidNumber
- LengthMismatch
- MissingField
- OutOfMemory Error
- Overflow ParseIntError
The result cannot fit in the type specified.
- UnexpectedToken
- UnknownField
std.json.static.parseFromValueLeaky
function
pub fn parseFromValueLeaky( comptime T: type, allocator: Allocator, source: Value, options: ParseOptions, ) ParseFromValueError!T
Parameters
Errors
- DuplicateField
- InvalidCharacter ParseIntError
The input was empty or contained an invalid character.
- InvalidEnumTag
- InvalidNumber
- LengthMismatch
- MissingField
- OutOfMemory Error
- Overflow ParseIntError
The result cannot fit in the type specified.
- UnexpectedToken
- UnknownField
std.json.static.ParseOptions
container
Controls how to deal with various inconsistencies between the JSON document and the Zig struct type passed in. For duplicate fields or unknown fields, set options in this struct. For missing fields, give the Zig struct fields default values.
Fields
duplicate_field_behavior: enum {
use_first,
@"error",
use_last,
} = .@"error"Behaviour when a duplicate field is encountered.
The default is to return error.DuplicateField.
ignore_unknown_fields: bool = falseIf false, finding an unknown field returns error.UnknownField.
max_value_len: ?usize = nullPassed to std.json.Scanner.nextAllocMax or std.json.Reader.nextAllocMax.
The default for parseFromSlice or parseFromTokenSource with a *std.json.Scanner input
is the length of the input slice, which means error.ValueTooLong will never be returned.
The default for parseFromTokenSource with a *std.json.Reader is std.json.default_max_value_len.
Ignored for values that don't need allocation or are not copied (see allocate).
Ignored for parseFromValue and parseFromValueLeaky.
allocate: ?AllocWhen = nullThis determines whether strings should always be copied,
or if a reference to the given buffer should be preferred if possible.
The default for parseFromSlice or parseFromTokenSource with a *std.json.Scanner input
is .alloc_if_needed.
The default with a *std.json.Reader input is .alloc_always.
Ignored for parseFromValue and parseFromValueLeaky.
parse_numbers: bool = trueWhen parsing to a std.json.Value, set this option to false to always emit
JSON numbers as unparsed std.json.Value.number_string.
Otherwise, JSON numbers are parsed as either std.json.Value.integer,
std.json.Value.float or left as unparsed std.json.Value.number_string
depending on the format and value of the JSON number.
When this option is true, JSON numbers encoded as floats (see std.json.isNumberFormattedLikeAnInteger)
may lose precision when being parsed into std.json.Value.float.
std.json.static.Scanner
alias
Alias of std.json.Scanner
std.json.static.sliceToEnum
function
fn sliceToEnum(comptime T: type, slice: []const u8) !T
Parameters
T: type
slice: []const u8
std.json.static.sliceToInt
function
fn sliceToInt(comptime T: type, slice: []const u8) !T
Parameters
T: type
slice: []const u8
std.json.static.std
alias
Alias of std
std.json.static.Token
alias
Alias of std.json.Scanner.Token
std.json.static.Value
alias
Alias of std.json.dynamic.Value
Source code
std/json/static.zig
const std = @import("std");
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const ArenaAllocator = std.heap.ArenaAllocator;
const ArrayList = std.array_list.Managed;
const Scanner = @import("Scanner.zig");
const Token = Scanner.Token;
const AllocWhen = Scanner.AllocWhen;
const default_max_value_len = Scanner.default_max_value_len;
const isNumberFormattedLikeAnInteger = Scanner.isNumberFormattedLikeAnInteger;
const Value = @import("./dynamic.zig").Value;
const Array = @import("./dynamic.zig").Array;
/// Controls how to deal with various inconsistencies between the JSON document and the Zig struct type passed in.
/// For duplicate fields or unknown fields, set options in this struct.
/// For missing fields, give the Zig struct fields default values.
pub const ParseOptions = struct {
/// Behaviour when a duplicate field is encountered.
/// The default is to return `error.DuplicateField`.
duplicate_field_behavior: enum {
use_first,
@"error",
use_last,
} = .@"error",
/// If false, finding an unknown field returns `error.UnknownField`.
ignore_unknown_fields: bool = false,
/// Passed to `std.json.Scanner.nextAllocMax` or `std.json.Reader.nextAllocMax`.
/// The default for `parseFromSlice` or `parseFromTokenSource` with a `*std.json.Scanner` input
/// is the length of the input slice, which means `error.ValueTooLong` will never be returned.
/// The default for `parseFromTokenSource` with a `*std.json.Reader` is `std.json.default_max_value_len`.
/// Ignored for values that don't need allocation or are not copied (see `allocate`).
/// Ignored for `parseFromValue` and `parseFromValueLeaky`.
max_value_len: ?usize = null,
/// This determines whether strings should always be copied,
/// or if a reference to the given buffer should be preferred if possible.
/// The default for `parseFromSlice` or `parseFromTokenSource` with a `*std.json.Scanner` input
/// is `.alloc_if_needed`.
/// The default with a `*std.json.Reader` input is `.alloc_always`.
/// Ignored for `parseFromValue` and `parseFromValueLeaky`.
allocate: ?AllocWhen = null,
/// When parsing to a `std.json.Value`, set this option to false to always emit
/// JSON numbers as unparsed `std.json.Value.number_string`.
/// Otherwise, JSON numbers are parsed as either `std.json.Value.integer`,
/// `std.json.Value.float` or left as unparsed `std.json.Value.number_string`
/// depending on the format and value of the JSON number.
/// When this option is true, JSON numbers encoded as floats (see `std.json.isNumberFormattedLikeAnInteger`)
/// may lose precision when being parsed into `std.json.Value.float`.
parse_numbers: bool = true,
};
pub fn Parsed(comptime T: type) type {
return struct {
arena: *ArenaAllocator,
value: T,
pub fn deinit(self: @This()) void {
const allocator = self.arena.child_allocator;
self.arena.deinit();
allocator.destroy(self.arena);
}
};
}
/// Parses the json document from `s` and returns the result packaged in a `std.json.Parsed`.
/// You must call `deinit()` of the returned object to clean up allocated resources.
/// If you are using a `std.heap.ArenaAllocator` or similar, consider calling `parseFromSliceLeaky` instead.
/// Note that `error.BufferUnderrun` is not actually possible to return from this function.
pub fn parseFromSlice(
comptime T: type,
allocator: Allocator,
s: []const u8,
options: ParseOptions,
) ParseError(Scanner)!Parsed(T) {
var scanner = Scanner.initCompleteInput(allocator, s);
defer scanner.deinit();
return parseFromTokenSource(T, allocator, &scanner, options);
}
/// Parses the json document from `s` and returns the result.
/// Allocations made during this operation are not carefully tracked and may not be possible to individually clean up.
/// It is recommended to use a `std.heap.ArenaAllocator` or similar.
pub fn parseFromSliceLeaky(
comptime T: type,
allocator: Allocator,
s: []const u8,
options: ParseOptions,
) ParseError(Scanner)!T {
var scanner = Scanner.initCompleteInput(allocator, s);
defer scanner.deinit();
return parseFromTokenSourceLeaky(T, allocator, &scanner, options);
}
/// `scanner_or_reader` must be either a `*std.json.Scanner` with complete input or a `*std.json.Reader`.
/// Note that `error.BufferUnderrun` is not actually possible to return from this function.
pub fn parseFromTokenSource(
comptime T: type,
allocator: Allocator,
scanner_or_reader: anytype,
options: ParseOptions,
) ParseError(@TypeOf(scanner_or_reader.*))!Parsed(T) {
var parsed = Parsed(T){
.arena = try allocator.create(ArenaAllocator),
.value = undefined,
};
errdefer allocator.destroy(parsed.arena);
parsed.arena.* = ArenaAllocator.init(allocator);
errdefer parsed.arena.deinit();
parsed.value = try parseFromTokenSourceLeaky(T, parsed.arena.allocator(), scanner_or_reader, options);
return parsed;
}
/// `scanner_or_reader` must be either a `*std.json.Scanner` with complete input or a `*std.json.Reader`.
/// Allocations made during this operation are not carefully tracked and may not be possible to individually clean up.
/// It is recommended to use a `std.heap.ArenaAllocator` or similar.
pub fn parseFromTokenSourceLeaky(
comptime T: type,
allocator: Allocator,
scanner_or_reader: anytype,
options: ParseOptions,
) ParseError(@TypeOf(scanner_or_reader.*))!T {
if (@TypeOf(scanner_or_reader.*) == Scanner) {
assert(scanner_or_reader.is_end_of_input);
}
var resolved_options = options;
if (resolved_options.max_value_len == null) {
if (@TypeOf(scanner_or_reader.*) == Scanner) {
resolved_options.max_value_len = scanner_or_reader.input.len;
} else {
resolved_options.max_value_len = default_max_value_len;
}
}
if (resolved_options.allocate == null) {
if (@TypeOf(scanner_or_reader.*) == Scanner) {
resolved_options.allocate = .alloc_if_needed;
} else {
resolved_options.allocate = .alloc_always;
}
}
const value = try innerParse(T, allocator, scanner_or_reader, resolved_options);
assert(.end_of_document == try scanner_or_reader.next());
return value;
}
/// Like `parseFromSlice`, but the input is an already-parsed `std.json.Value` object.
/// Only `options.ignore_unknown_fields` is used from `options`.
pub fn parseFromValue(
comptime T: type,
allocator: Allocator,
source: Value,
options: ParseOptions,
) ParseFromValueError!Parsed(T) {
var parsed = Parsed(T){
.arena = try allocator.create(ArenaAllocator),
.value = undefined,
};
errdefer allocator.destroy(parsed.arena);
parsed.arena.* = ArenaAllocator.init(allocator);
errdefer parsed.arena.deinit();
parsed.value = try parseFromValueLeaky(T, parsed.arena.allocator(), source, options);
return parsed;
}
pub fn parseFromValueLeaky(
comptime T: type,
allocator: Allocator,
source: Value,
options: ParseOptions,
) ParseFromValueError!T {
// I guess this function doesn't need to exist,
// but the flow of the sourcecode is easy to follow and grouped nicely with
// this pub redirect function near the top and the implementation near the bottom.
return innerParseFromValue(T, allocator, source, options);
}
/// The error set that will be returned when parsing from `*Source`.
/// Note that this may contain `error.BufferUnderrun`, but that error will never actually be returned.
pub fn ParseError(comptime Source: type) type {
// A few of these will either always be present or present enough of the time that
// omitting them is more confusing than always including them.
return ParseFromValueError || Source.NextError || Source.PeekError || Source.AllocError;
}
pub const ParseFromValueError = std.fmt.ParseIntError || std.fmt.ParseFloatError || Allocator.Error || error{
UnexpectedToken,
InvalidNumber,
Overflow,
InvalidEnumTag,
DuplicateField,
UnknownField,
MissingField,
LengthMismatch,
};
/// This is an internal function called recursively
/// during the implementation of `parseFromTokenSourceLeaky` and similar.
/// It is exposed primarily to enable custom `jsonParse()` methods to call back into the `parseFrom*` system,
/// such as if you're implementing a custom container of type `T`;
/// you can call `innerParse(T, ...)` for each of the container's items.
/// Note that `null` fields are not allowed on the `options` when calling this function.
/// (The `options` you get in your `jsonParse` method has no `null` fields.)
pub fn innerParse(
comptime T: type,
allocator: Allocator,
source: anytype,
options: ParseOptions,
) ParseError(@TypeOf(source.*))!T {
switch (@typeInfo(T)) {
.bool => {
return switch (try source.next()) {
.true => true,
.false => false,
else => error.UnexpectedToken,
};
},
.float, .comptime_float => {
const token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
defer freeAllocated(allocator, token);
const slice = switch (token) {
inline .number, .allocated_number, .string, .allocated_string => |slice| slice,
else => return error.UnexpectedToken,
};
return try std.fmt.parseFloat(T, slice);
},
.int, .comptime_int => {
const token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
defer freeAllocated(allocator, token);
const slice = switch (token) {
inline .number, .allocated_number, .string, .allocated_string => |slice| slice,
else => return error.UnexpectedToken,
};
return sliceToInt(T, slice);
},
.optional => |optionalInfo| {
switch (try source.peekNextTokenType()) {
.null => {
_ = try source.next();
return null;
},
else => {
return try innerParse(optionalInfo.child, allocator, source, options);
},
}
},
.@"enum" => {
if (std.meta.hasFn(T, "jsonParse")) {
return T.jsonParse(allocator, source, options);
}
const token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
defer freeAllocated(allocator, token);
const slice = switch (token) {
inline .number, .allocated_number, .string, .allocated_string => |slice| slice,
else => return error.UnexpectedToken,
};
return sliceToEnum(T, slice);
},
.@"union" => |unionInfo| {
if (std.meta.hasFn(T, "jsonParse")) {
return T.jsonParse(allocator, source, options);
}
if (unionInfo.tag_type == null) @compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'");
if (.object_begin != try source.next()) return error.UnexpectedToken;
var result: ?T = null;
var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
const field_name = switch (name_token.?) {
inline .string, .allocated_string => |slice| slice,
else => {
return error.UnexpectedToken;
},
};
inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
if (std.mem.eql(u8, u_field_name, field_name)) {
// Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
// (Recursing into innerParse() might trigger more allocations.)
freeAllocated(allocator, name_token.?);
name_token = null;
if (u_field_type == void) {
// void isn't really a json type, but we can support void payload union tags with {} as a value.
if (.object_begin != try source.next()) return error.UnexpectedToken;
if (.object_end != try source.next()) return error.UnexpectedToken;
result = @unionInit(T, u_field_name, {});
} else {
// Recurse.
result = @unionInit(T, u_field_name, try innerParse(u_field_type, allocator, source, options));
}
break;
}
} else {
// Didn't match anything.
return error.UnknownField;
}
if (.object_end != try source.next()) return error.UnexpectedToken;
return result.?;
},
.@"struct" => |structInfo| {
if (structInfo.is_tuple) {
if (.array_begin != try source.next()) return error.UnexpectedToken;
var r: T = undefined;
inline for (structInfo.field_types, 0..) |field_type, i| {
r[i] = try innerParse(field_type, allocator, source, options);
}
if (.array_end != try source.next()) return error.UnexpectedToken;
return r;
}
if (std.meta.hasFn(T, "jsonParse")) {
return T.jsonParse(allocator, source, options);
}
if (.object_begin != try source.next()) return error.UnexpectedToken;
var r: T = undefined;
var fields_seen: [structInfo.field_names.len]bool = @splat(false);
while (true) {
var name_token: ?Token = try source.nextAllocMax(allocator, .alloc_if_needed, options.max_value_len.?);
const field_name = switch (name_token.?) {
inline .string, .allocated_string => |slice| slice,
.object_end => { // No more fields.
break;
},
else => {
return error.UnexpectedToken;
},
};
inline for (
structInfo.field_names,
structInfo.field_types,
structInfo.field_attrs,
0..,
) |f_name, f_type, f_attrs, i| {
if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
if (std.mem.eql(u8, f_name, field_name)) {
// Free the name token now in case we're using an allocator that optimizes freeing the last allocated object.
// (Recursing into innerParse() might trigger more allocations.)
freeAllocated(allocator, name_token.?);
name_token = null;
if (fields_seen[i]) {
switch (options.duplicate_field_behavior) {
.use_first => {
// Parse and ignore the redundant value.
// We don't want to skip the value, because we want type checking.
_ = try innerParse(f_type, allocator, source, options);
break;
},
.@"error" => return error.DuplicateField,
.use_last => {},
}
}
@field(r, f_name) = try innerParse(f_type, allocator, source, options);
fields_seen[i] = true;
break;
}
} else {
// Didn't match anything.
freeAllocated(allocator, name_token.?);
if (options.ignore_unknown_fields) {
try source.skipValue();
} else {
return error.UnknownField;
}
}
}
try fillDefaultStructValues(T, &r, &fields_seen);
return r;
},
.array => |arrayInfo| {
switch (try source.peekNextTokenType()) {
.array_begin => {
// Typical array.
return internalParseArray(T, arrayInfo.child, allocator, source, options);
},
.string => {
if (arrayInfo.child != u8) return error.UnexpectedToken;
// Fixed-length string.
var r: T = undefined;
var i: usize = 0;
while (true) {
switch (try source.next()) {
.string => |slice| {
if (i + slice.len != r.len) return error.LengthMismatch;
@memcpy(r[i..][0..slice.len], slice);
break;
},
.partial_string => |slice| {
if (i + slice.len > r.len) return error.LengthMismatch;
@memcpy(r[i..][0..slice.len], slice);
i += slice.len;
},
.partial_string_escaped_1 => |arr| {
if (i + arr.len > r.len) return error.LengthMismatch;
@memcpy(r[i..][0..arr.len], arr[0..]);
i += arr.len;
},
.partial_string_escaped_2 => |arr| {
if (i + arr.len > r.len) return error.LengthMismatch;
@memcpy(r[i..][0..arr.len], arr[0..]);
i += arr.len;
},
.partial_string_escaped_3 => |arr| {
if (i + arr.len > r.len) return error.LengthMismatch;
@memcpy(r[i..][0..arr.len], arr[0..]);
i += arr.len;
},
.partial_string_escaped_4 => |arr| {
if (i + arr.len > r.len) return error.LengthMismatch;
@memcpy(r[i..][0..arr.len], arr[0..]);
i += arr.len;
},
else => unreachable,
}
}
return r;
},
else => return error.UnexpectedToken,
}
},
.vector => |vector_info| {
switch (try source.peekNextTokenType()) {
.array_begin => {
const A = [vector_info.len]vector_info.child;
return try internalParseArray(A, vector_info.child, allocator, source, options);
},
else => return error.UnexpectedToken,
}
},
.pointer => |ptrInfo| {
switch (ptrInfo.size) {
.one => {
const r: *ptrInfo.child = try allocator.create(ptrInfo.child);
r.* = try innerParse(ptrInfo.child, allocator, source, options);
return r;
},
.slice => {
switch (try source.peekNextTokenType()) {
.array_begin => {
_ = try source.next();
// Typical array.
var arraylist = ArrayList(ptrInfo.child).init(allocator);
while (true) {
switch (try source.peekNextTokenType()) {
.array_end => {
_ = try source.next();
break;
},
else => {},
}
try arraylist.ensureUnusedCapacity(1);
arraylist.appendAssumeCapacity(try innerParse(ptrInfo.child, allocator, source, options));
}
if (ptrInfo.sentinel()) |s| {
return try arraylist.toOwnedSliceSentinel(s);
}
return try arraylist.toOwnedSlice();
},
.string => {
if (ptrInfo.child != u8) return error.UnexpectedToken;
// Dynamic length string.
if (ptrInfo.sentinel()) |s| {
// Use our own array list so we can append the sentinel.
var value_list = ArrayList(u8).init(allocator);
_ = try source.allocNextIntoArrayListMax(&value_list, .alloc_always, options.max_value_len.?);
return try value_list.toOwnedSliceSentinel(s);
}
if (ptrInfo.attrs.@"const") {
switch (try source.nextAllocMax(allocator, options.allocate.?, options.max_value_len.?)) {
inline .string, .allocated_string => |slice| return slice,
else => unreachable,
}
} else {
// Have to allocate to get a mutable copy.
switch (try source.nextAllocMax(allocator, .alloc_always, options.max_value_len.?)) {
.allocated_string => |slice| return slice,
else => unreachable,
}
}
},
else => return error.UnexpectedToken,
}
},
else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
}
},
else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
}
unreachable;
}
fn internalParseArray(
comptime T: type,
comptime Child: type,
allocator: Allocator,
source: anytype,
options: ParseOptions,
) !T {
assert(.array_begin == try source.next());
var r: T = undefined;
for (&r) |*elem| {
elem.* = try innerParse(Child, allocator, source, options);
}
if (.array_end != try source.next()) return error.UnexpectedToken;
return r;
}
/// This is an internal function called recursively
/// during the implementation of `parseFromValueLeaky`.
/// It is exposed primarily to enable custom `jsonParseFromValue()` methods to call back into the `parseFromValue*` system,
/// such as if you're implementing a custom container of type `T`;
/// you can call `innerParseFromValue(T, ...)` for each of the container's items.
pub fn innerParseFromValue(
comptime T: type,
allocator: Allocator,
source: Value,
options: ParseOptions,
) ParseFromValueError!T {
switch (@typeInfo(T)) {
.bool => {
switch (source) {
.bool => |b| return b,
else => return error.UnexpectedToken,
}
},
.float, .comptime_float => {
switch (source) {
.float => |f| return @as(T, @floatCast(f)),
.integer => |i| return @as(T, @floatFromInt(i)),
.number_string, .string => |s| return std.fmt.parseFloat(T, s),
else => return error.UnexpectedToken,
}
},
.int, .comptime_int => {
switch (source) {
.float => |f| {
if (@round(f) != f) return error.InvalidNumber;
if (f > @as(@TypeOf(f), @floatFromInt(std.math.maxInt(T)))) return error.Overflow;
if (f < @as(@TypeOf(f), @floatFromInt(std.math.minInt(T)))) return error.Overflow;
return @intFromFloat(f);
},
.integer => |i| {
if (i > std.math.maxInt(T)) return error.Overflow;
if (i < std.math.minInt(T)) return error.Overflow;
return @intCast(i);
},
.number_string, .string => |s| {
return sliceToInt(T, s);
},
else => return error.UnexpectedToken,
}
},
.optional => |optionalInfo| {
switch (source) {
.null => return null,
else => return try innerParseFromValue(optionalInfo.child, allocator, source, options),
}
},
.@"enum" => {
if (std.meta.hasFn(T, "jsonParseFromValue")) {
return T.jsonParseFromValue(allocator, source, options);
}
switch (source) {
.float => return error.InvalidEnumTag,
.integer => |i| return std.enums.fromInt(T, i) orelse return error.InvalidEnumTag,
.number_string, .string => |s| return sliceToEnum(T, s),
else => return error.UnexpectedToken,
}
},
.@"union" => |unionInfo| {
if (std.meta.hasFn(T, "jsonParseFromValue")) {
return T.jsonParseFromValue(allocator, source, options);
}
if (unionInfo.tag_type == null) @compileError("Unable to parse into untagged union '" ++ @typeName(T) ++ "'");
if (source != .object) return error.UnexpectedToken;
if (source.object.count() != 1) return error.UnexpectedToken;
var it = source.object.iterator();
const kv = it.next().?;
const field_name = kv.key_ptr.*;
inline for (unionInfo.field_names, unionInfo.field_types) |u_field_name, u_field_type| {
if (std.mem.eql(u8, u_field_name, field_name)) {
if (u_field_type == void) {
// void isn't really a json type, but we can support void payload union tags with {} as a value.
if (kv.value_ptr.* != .object) return error.UnexpectedToken;
if (kv.value_ptr.*.object.count() != 0) return error.UnexpectedToken;
return @unionInit(T, u_field_name, {});
}
// Recurse.
return @unionInit(T, u_field_name, try innerParseFromValue(u_field_type, allocator, kv.value_ptr.*, options));
}
}
// Didn't match anything.
return error.UnknownField;
},
.@"struct" => |structInfo| {
if (structInfo.is_tuple) {
if (source != .array) return error.UnexpectedToken;
if (source.array.items.len != structInfo.field_names.len) return error.UnexpectedToken;
var r: T = undefined;
inline for (0..structInfo.field_names.len, source.array.items) |i, item| {
r[i] = try innerParseFromValue(structInfo.field_types[i], allocator, item, options);
}
return r;
}
if (std.meta.hasFn(T, "jsonParseFromValue")) {
return T.jsonParseFromValue(allocator, source, options);
}
if (source != .object) return error.UnexpectedToken;
var r: T = undefined;
var fields_seen: [structInfo.field_names.len]bool = @splat(false);
var it = source.object.iterator();
while (it.next()) |kv| {
const field_name = kv.key_ptr.*;
inline for (
structInfo.field_names,
structInfo.field_types,
structInfo.field_attrs,
0..,
) |f_name, f_type, f_attrs, i| {
if (f_attrs.@"comptime") @compileError("comptime fields are not supported: " ++ @typeName(T) ++ "." ++ f_name);
if (std.mem.eql(u8, f_name, field_name)) {
assert(!fields_seen[i]); // Can't have duplicate keys in a Value.object.
@field(r, f_name) = try innerParseFromValue(f_type, allocator, kv.value_ptr.*, options);
fields_seen[i] = true;
break;
}
} else {
// Didn't match anything.
if (!options.ignore_unknown_fields) return error.UnknownField;
}
}
try fillDefaultStructValues(T, &r, &fields_seen);
return r;
},
.array => |arrayInfo| {
switch (source) {
.array => |array| {
// Typical array.
return innerParseArrayFromArrayValue(T, arrayInfo.child, arrayInfo.len, allocator, array, options);
},
.string => |s| {
if (arrayInfo.child != u8) return error.UnexpectedToken;
// Fixed-length string.
if (s.len != arrayInfo.len) return error.LengthMismatch;
var r: T = undefined;
@memcpy(r[0..], s);
return r;
},
else => return error.UnexpectedToken,
}
},
.vector => |vecInfo| {
switch (source) {
.array => |array| {
return innerParseArrayFromArrayValue(T, vecInfo.child, vecInfo.len, allocator, array, options);
},
else => return error.UnexpectedToken,
}
},
.pointer => |ptrInfo| {
switch (ptrInfo.size) {
.one => {
const r: *ptrInfo.child = try allocator.create(ptrInfo.child);
r.* = try innerParseFromValue(ptrInfo.child, allocator, source, options);
return r;
},
.slice => {
switch (source) {
.array => |array| {
const r = if (ptrInfo.sentinel()) |sentinel|
try allocator.allocSentinel(ptrInfo.child, array.items.len, sentinel)
else
try allocator.alloc(ptrInfo.child, array.items.len);
for (array.items, r) |item, *dest| {
dest.* = try innerParseFromValue(ptrInfo.child, allocator, item, options);
}
return r;
},
.string => |s| {
if (ptrInfo.child != u8) return error.UnexpectedToken;
// Dynamic length string.
const r = if (ptrInfo.sentinel()) |sentinel|
try allocator.allocSentinel(ptrInfo.child, s.len, sentinel)
else
try allocator.alloc(ptrInfo.child, s.len);
@memcpy(r[0..], s);
return r;
},
else => return error.UnexpectedToken,
}
},
else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
}
},
else => @compileError("Unable to parse into type '" ++ @typeName(T) ++ "'"),
}
}
fn innerParseArrayFromArrayValue(
comptime T: type,
comptime Child: type,
comptime len: comptime_int,
allocator: Allocator,
array: Array,
options: ParseOptions,
) !T {
if (array.items.len != len) return error.LengthMismatch;
var r: T = undefined;
for (array.items, 0..) |item, i| {
r[i] = try innerParseFromValue(Child, allocator, item, options);
}
return r;
}
fn sliceToInt(comptime T: type, slice: []const u8) !T {
if (isNumberFormattedLikeAnInteger(slice))
return std.fmt.parseInt(T, slice, 10);
// Try to coerce a float to an integer.
const float = try std.fmt.parseFloat(f128, slice);
if (@round(float) != float) return error.InvalidNumber;
if (float > @as(f128, @floatFromInt(std.math.maxInt(T))) or float < @as(f128, @floatFromInt(std.math.minInt(T)))) return error.Overflow;
return @as(T, @intCast(@as(i128, @intFromFloat(float))));
}
fn sliceToEnum(comptime T: type, slice: []const u8) !T {
// Check for a named value.
if (std.meta.stringToEnum(T, slice)) |value| return value;
// Check for a numeric value.
if (!isNumberFormattedLikeAnInteger(slice)) return error.InvalidEnumTag;
const n = std.fmt.parseInt(@typeInfo(T).@"enum".tag_type, slice, 10) catch return error.InvalidEnumTag;
return std.enums.fromInt(T, n) orelse return error.InvalidEnumTag;
}
fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".field_names.len]bool) !void {
const info = @typeInfo(T).@"struct";
inline for (
info.field_names,
info.field_types,
info.field_attrs,
0..,
) |field_name, field_type, field_attrs, i| {
if (!fields_seen[i]) {
if (field_attrs.defaultValue(field_type)) |default| {
@field(r, field_name) = default;
} else {
return error.MissingField;
}
}
}
}
fn freeAllocated(allocator: Allocator, token: Token) void {
switch (token) {
.allocated_number, .allocated_string => |slice| {
allocator.free(slice);
},
else => {},
}
}
test {
_ = @import("./static_test.zig");
}