allocNextIntoArrayListMax

The next token type must be either .number or .string. See peekNextTokenType(). When allocation is not necessary with .alloc_if_needed, this method returns the content slice from the input buffer, and value_list is not touched. When allocation is necessary or with .alloc_always, this method concatenates partial tokens into the given value_list, and returns null once the final .number or .string token has been written into it. In case of an error.BufferUnderrun, partial values will be left in the given value_list. The given value_list is never reset by this method, so an error.BufferUnderrun situation can be resumed by passing the same array list in again. This method does not indicate whether the token content being returned is for a .number or .string token type; the caller of this method is expected to know which type of token is being processed.

Function parameters

Parameters

self:*@This()
value_list:*std.array_list.Managed(u8)
when:AllocWhen
max_value_len:usize

The tokens emitted by `std.json.Scanner` and `std.json.Reader` `.next*()` functions follow this grammar:

Types

Token: The tokens emitted by `std.json.Scanner` and `std.json.Reader` `.next*()` functions follow this grammar:
TokenType: This is only used in `peekNextTokenType()` and gives a categorization based on the first byte of the next token that will be emitted from a `next*()` call.
Diagnostics: To enable diagnostics, declare `var diagnostics = Diagnostics{};` then call `source.enableDiagnostics(&diagnostics);`
AllocWhen: See the documentation for `std.json.Token`.
Reader: All `next*()` methods here handle `error.BufferUnderrun` from `std.json.Scanner`, and then read from the reader.

The allocator is only used to track `[]` and `{}` nesting levels.

Functions

initStreaming: The allocator is only used to track `[]` and `{}` nesting levels.
initCompleteInput: Use this if your input is a single slice.
deinit
enableDiagnostics
feedInput: Call this whenever you get `error.BufferUnderrun` from `next()`.
endInput: Call this when you will no longer call `feedInput()` anymore.
nextAlloc: Equivalent to `nextAllocMax(allocator, when, default_max_value_len);`
nextAllocMax: This function is only available after `endInput()` (or `initCompleteInput()`) has been called.
allocNextIntoArrayList: Equivalent to `allocNextIntoArrayListMax(value_list, when, default_max_value_len);`
allocNextIntoArrayListMax: The next token type must be either `.number` or `.string`.
skipValue: This function is only available after `endInput()` (or `initCompleteInput()`) has been called.
skipUntilStackHeight: Skip tokens until an `.object_end` or `.array_end` token results in a `stackHeight()` equal the given stack height.
stackHeight: The depth of `{}` or `[]` nesting levels at the current position.
ensureTotalStackCapacity: Pre allocate memory to hold the given number of nesting levels.
next: See `std.json.Token` for documentation of this function.
peekNextTokenType: Seeks ahead in the input until the first byte of the next token (or the end of the input)
validate: Scan the input and check for malformed JSON.
isNumberFormattedLikeAnInteger: For the slice you get from a `Token.number` or `Token.allocated_number`,

Error sets in this namespace

Error Sets

NextError
AllocError
PeekError
SkipError
AllocIntoArrayListError
Error: The parsing errors are divided into two categories:

Used by `json.reader`.

Values

default_buffer_size: Used by `json.reader`.
default_max_value_len: For security, the maximum size allocated to store a single string or number value is limited to 4MiB by default.

Source

Implementation

pub fn allocNextIntoArrayListMax(self: *@This(), value_list: *std.array_list.Managed(u8), when: AllocWhen, max_value_len: usize) AllocIntoArrayListError!?[]const u8 {
    while (true) {
        const token = try self.next();
        switch (token) {
            // Accumulate partial values.
            .partial_number, .partial_string => |slice| {
                try appendSlice(value_list, slice, max_value_len);
            },
            .partial_string_escaped_1 => |buf| {
                try appendSlice(value_list, buf[0..], max_value_len);
            },
            .partial_string_escaped_2 => |buf| {
                try appendSlice(value_list, buf[0..], max_value_len);
            },
            .partial_string_escaped_3 => |buf| {
                try appendSlice(value_list, buf[0..], max_value_len);
            },
            .partial_string_escaped_4 => |buf| {
                try appendSlice(value_list, buf[0..], max_value_len);
            },

            // Return complete values.
            .number => |slice| {
                if (when == .alloc_if_needed and value_list.items.len == 0) {
                    // No alloc necessary.
                    return slice;
                }
                try appendSlice(value_list, slice, max_value_len);
                // The token is complete.
                return null;
            },
            .string => |slice| {
                if (when == .alloc_if_needed and value_list.items.len == 0) {
                    // No alloc necessary.
                    return slice;
                }
                try appendSlice(value_list, slice, max_value_len);
                // The token is complete.
                return null;
            },

            .object_begin,
            .object_end,
            .array_begin,
            .array_end,
            .true,
            .false,
            .null,
            .end_of_document,
            => unreachable, // Only .number and .string token types are allowed here. Check peekNextTokenType() before calling this.

            .allocated_number, .allocated_string => unreachable,
        }
    }
}