class TypedProtoDecoderBase

If the field |id| is known at compile time, prefer the templated

specialization at

<kFieldNumber

>().

Like Get(), but also resolves "extension" fields whose id exceeds the

highest field id known in-tree at compile time (i.e. id >= num_fields_,

which is MAX_FIELD_ID + 1). Such fields are NOT stored by ParseAllFields()

-- e.g. fields carved out of TracePacket's `extensions 1000 to 1999`

range. For in-tree ids this delegates to Get(); for extension ids it falls

back to a linear re-scan of the buffer.

NOTE: for *repeated* fields the slow path returns the FIRST occurrence

(FindField semantics), whereas Get() returns the last. All current

extension fields are singular submessages, so this is not observable today.

TODO: make extension lookups fast without re-scanning the buffer. The

blocker is that fields_ is indexed directly by field id (on_stack_storage_,

or heap_storage_ after ExpandHeapStorage()), so it must be sized to the

largest field id. That is fine for the densely-numbered in-tree fields, but

extension ids are sparse and can be arbitrarily high (the OOT range starts

at 1000), so indexing by id would waste / unbound memory. Proposed design:

- Replace the flat array with a two-level sparse map. Level 1 is a set of

id ranges built dynamically while decoding (these need not match the

static extensions.json allocations), e.g. tracked with a bitset. Level

2 maps an id within a matched range to a compact slot index.

- Back the slots with an object pool so repeated decodes reuse storage

and allocate ~zero: only a few decoders are live at any time, so the

pool stays small.

This costs memory proportional to the extension fields actually present

rather than to the max field id, and keeps the decode hot path

allocation-free.

Returns an object that allows to iterate over all instances of a repeated

field given its id. Example usage:

for (auto it = decoder.GetRepeated

<int32

_t>(N); it; ++it) { ... }

Returns an objects that allows to iterate over all entries of a packed

repeated field given its id and type. The |wire_type| is necessary for

decoding the packed field, the |cpp_type| is for convenience

&

stronger

typing.

The caller must also supply a pointer to a bool that is set to true if the

packed buffer is found to be malformed while iterating (so you need to

exhaust the iterator if you want to check the full extent of the buffer).

Note that unlike standard protobuf parsers, protozero does not allow

treating of packed repeated fields as non-packed and vice-versa (therefore

not making the packed option forwards and backwards compatible). So

the caller needs to use the right accessor for correct results.

Returns a unified iterator that automatically dispatches between packed and

non-packed repeated field iteration based on the wire format. This allows

parsers to handle both formats without knowing ahead of time which one is

used.

Example usage:

bool parse_error = false;

for (auto it = decoder.GetUnifiedRepeated

<wire

_type, int32_t>(N,

&parse

_error);

it; ++it) { ... }