From 5fa0fd00c4e2919fc979a18f16de259444445c07 Mon Sep 17 00:00:00 2001 From: Eugene Blikh Date: Sun, 17 May 2026 08:50:00 +0300 Subject: [PATCH] codec: proto2 groups (SGROUP/EGROUP wire format) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Plugin: detect protoreflect.GroupKind, emit kind='group' in the field descriptor and a SGROUP opening tag in inline codegen. The group body bypasses the LEN-prefix path entirely — encoder emits start-tag, body bytes, end-tag in three slots; decoder calls pb.codec.decode_group(desc, buf, pos, field_id) which reads inner tags until the matching EGROUP id. Wire layer already understood SGROUP/EGROUP for skip_field; the new decode_group reuses the per-tag dispatch from decode_message but stops on EGROUP instead of end-of-buffer. Repeated groups bracket each element with its own SGROUP/EGROUP pair. Runtime parser now desugars `optional|required|repeated group Name = id { body }` into (a) a nested message named Name and (b) a synthetic field of kind=group whose lowercased name is `name` — so source-parsed proto2 schemas behave the same as build-time codegen. Text format renders groups under the submessage's capitalized name (`SingleGroup { ... }`) rather than the lowercase field name, matching mainline protoc's convention. Adds a vendored, MessageSet-stripped test_messages_proto2.proto in test/conformance/proto/ (header comment documents the patch). 10 new luatest cases (group_*) cover singular + repeated + text + descriptor kind, across both codegen modes. 739 tests pass. --- cmd/protoc-gen-tarantool/internal/gen/gen.go | 10 +- .../internal/gen/inline.go | 126 +- .../full/proto2_basic/proto2_basic_pb.lua | 275 + .../proto2/test_messages_proto2_pb.lua | 6111 +++++++++++++++++ .../runtime/proto2_basic/proto2_basic_pb.lua | 118 + .../proto2/test_messages_proto2_pb.lua | 1633 +++++ runtime/pb/codec.lua | 135 + runtime/pb/dynamic.lua | 21 +- runtime/pb/parser.lua | 113 +- runtime/pb/text.lua | 12 + .../proto/test_messages_proto2.proto | 387 ++ test/proto/proto2_basic.proto | 12 + test/proto2_test.lua | 42 + 13 files changed, 8917 insertions(+), 78 deletions(-) create mode 100644 examples/expected/full/protobuf_test_messages/proto2/test_messages_proto2_pb.lua create mode 100644 examples/expected/runtime/protobuf_test_messages/proto2/test_messages_proto2_pb.lua create mode 100644 test/conformance/proto/test_messages_proto2.proto diff --git a/cmd/protoc-gen-tarantool/internal/gen/gen.go b/cmd/protoc-gen-tarantool/internal/gen/gen.go index 336f033c6bb66e8f37e1498ea07d8b88df9b9b3f..c7484b38accede9f604f20c0cf860fe718c8df51 100644 --- a/cmd/protoc-gen-tarantool/internal/gen/gen.go +++ b/cmd/protoc-gen-tarantool/internal/gen/gen.go @@ -440,7 +440,15 @@ func renderFieldEntry(w *writer, file *protogen.File, f *protogen.Field, selfPat switch { case f.Message != nil: - parts = append(parts, "kind='message'") + // Proto2 `group` fields surface as a synthetic submessage whose + // Kind is GroupKind. Wire format differs from a regular nested + // message (SGROUP/EGROUP tag pair vs LEN prefix), so the codec + // needs to dispatch on the kind. + if f.Desc.Kind() == protoreflect.GroupKind { + parts = append(parts, "kind='group'") + } else { + parts = append(parts, "kind='message'") + } parts = append(parts, "message="+typeRef(file, f.Message.Desc, selfPath, imports, "_descriptor", prefix)) case f.Enum != nil: parts = append(parts, "kind='enum'") diff --git a/cmd/protoc-gen-tarantool/internal/gen/inline.go b/cmd/protoc-gen-tarantool/internal/gen/inline.go index 3a4c69efcba0f58b49ccf03539e4fd9b9e5fa4c2..9b5e06aa8e75a59b855077cf39ef77df4fd49eb0 100644 --- a/cmd/protoc-gen-tarantool/internal/gen/inline.go +++ b/cmd/protoc-gen-tarantool/internal/gen/inline.go @@ -123,19 +123,27 @@ func emitInlineEncodeField(w *writer, f *protogen.Field, file *protogen.File, se case f.Desc.IsList(): emitInlineEncodeRepeated(w, f, tag, fname, file, selfPath, imports, prefix) case f.Message != nil: - // Split the length-delimited payload into separate `out` slots: - // emit the tag, then `varint(#body)`, then the body. This avoids - // the per-field `varint(#body) .. body` string concatenation that - // `wire.encode_len` would do. `table.concat` at the end of - // `_encode` joins everything in one pass — same final bytes, - // one fewer allocation per nested-message field. ref := typeRef(file, f.Message.Desc, selfPath, imports, "_encode", prefix) - w.line(" if %s then", gate) - w.line(" local _b = %s(v)", ref) - w.line(" n = n + 1; out[n] = %s", tag) - w.line(" n = n + 1; out[n] = wire.encode_varint(#_b)") - w.line(" n = n + 1; out[n] = _b") - w.line(" end") + if f.Desc.Kind() == protoreflect.GroupKind { + // Proto2 group: SGROUP tag + body + EGROUP tag. No length + // prefix — the receiver reads until the matching EGROUP id. + endTag := tagBytesLit(int32(f.Desc.Number()), 4 /* EGROUP */) + w.line(" if %s then", gate) + w.line(" n = n + 1; out[n] = %s", tag) + w.line(" n = n + 1; out[n] = %s(v)", ref) + w.line(" n = n + 1; out[n] = %s", endTag) + w.line(" end") + } else { + // Split the length-delimited payload into separate `out` + // slots: emit tag, varint(#body), body. Avoids the per-field + // concat that wire.encode_len would do. + w.line(" if %s then", gate) + w.line(" local _b = %s(v)", ref) + w.line(" n = n + 1; out[n] = %s", tag) + w.line(" n = n + 1; out[n] = wire.encode_varint(#_b)") + w.line(" n = n + 1; out[n] = _b") + w.line(" end") + } case f.Enum != nil: enumLocal := typeRef(file, f.Enum.Desc, selfPath, imports, "", prefix) fullName := string(f.Enum.Desc.FullName()) @@ -228,15 +236,28 @@ func emitInlineEncodeRepeated(w *writer, f *protogen.Field, tag, fname string, f switch { case f.Message != nil: ref := typeRef(file, f.Message.Desc, selfPath, imports, "_encode", prefix) - w.line(" if v ~= nil and #v > 0 then") - w.line(" local _tag = %s", tag) - w.line(" for _i = 1, #v do") - w.line(" local _b = %s(v[_i])", ref) - w.line(" n = n + 1; out[n] = _tag") - w.line(" n = n + 1; out[n] = wire.encode_varint(#_b)") - w.line(" n = n + 1; out[n] = _b") - w.line(" end") - w.line(" end") + if f.Desc.Kind() == protoreflect.GroupKind { + endTag := tagBytesLit(int32(f.Desc.Number()), 4 /* EGROUP */) + w.line(" if v ~= nil and #v > 0 then") + w.line(" local _stag = %s", tag) + w.line(" local _etag = %s", endTag) + w.line(" for _i = 1, #v do") + w.line(" n = n + 1; out[n] = _stag") + w.line(" n = n + 1; out[n] = %s(v[_i])", ref) + w.line(" n = n + 1; out[n] = _etag") + w.line(" end") + w.line(" end") + } else { + w.line(" if v ~= nil and #v > 0 then") + w.line(" local _tag = %s", tag) + w.line(" for _i = 1, #v do") + w.line(" local _b = %s(v[_i])", ref) + w.line(" n = n + 1; out[n] = _tag") + w.line(" n = n + 1; out[n] = wire.encode_varint(#_b)") + w.line(" n = n + 1; out[n] = _b") + w.line(" end") + w.line(" end") + } case f.Enum != nil: enumLocal := typeRef(file, f.Enum.Desc, selfPath, imports, "", prefix) fullName := string(f.Enum.Desc.FullName()) @@ -342,24 +363,39 @@ func emitInlineDecodeFieldBody(w *writer, f *protogen.Field, file *protogen.File case f.Message != nil: ref := typeRef(file, f.Message.Desc, selfPath, imports, "_decode", prefix) dst := luaFieldAccess("result", fname) - w.line(" local payload") - w.line(" payload, pos = wire.decode_len(buf, pos)") - if isWellKnownTypeFile(f.Message.Desc.ParentFile()) { - // WKT decoders return unwrapped values (datetime, number, string), - // not Lua tables — there is nothing to merge into. Replace. - w.line(" %s = %s(payload)", dst, ref) - } else { - // Per proto3 spec, repeated occurrences of a singular message - // field merge recursively. This holds for oneof branches too; - // sibling clearing below enforces oneof exclusivity. - descRef := typeRef(file, f.Message.Desc, selfPath, imports, "_descriptor", prefix) + descRef := typeRef(file, f.Message.Desc, selfPath, imports, "_descriptor", prefix) + if f.Desc.Kind() == protoreflect.GroupKind { + // Group: no length prefix. The codec reads body fields until + // it hits an EGROUP tag matching this field's id; returns the + // decoded table and the new position. + w.line(" local payload") + w.line(" payload, pos = pb.codec.decode_group(%s, buf, pos, %d)", + descRef, f.Desc.Number()) w.line(" local prev = %s", dst) w.line(" if prev == nil then") - w.line(" %s = %s(payload)", dst, ref) + w.line(" %s = payload", dst) w.line(" else") - w.line(" pb.codec.merge_message(%s, prev, %s(payload))", - descRef, ref) + w.line(" pb.codec.merge_message(%s, prev, payload)", descRef) w.line(" end") + } else { + w.line(" local payload") + w.line(" payload, pos = wire.decode_len(buf, pos)") + if isWellKnownTypeFile(f.Message.Desc.ParentFile()) { + // WKT decoders return unwrapped values (datetime, number, string), + // not Lua tables — there is nothing to merge into. Replace. + w.line(" %s = %s(payload)", dst, ref) + } else { + // Per proto3 spec, repeated occurrences of a singular message + // field merge recursively. This holds for oneof branches too; + // sibling clearing below enforces oneof exclusivity. + w.line(" local prev = %s", dst) + w.line(" if prev == nil then") + w.line(" %s = %s(payload)", dst, ref) + w.line(" else") + w.line(" pb.codec.merge_message(%s, prev, %s(payload))", + descRef, ref) + w.line(" end") + } } case f.Enum != nil: w.line(" local u") @@ -392,9 +428,17 @@ func emitInlineDecodeRepeated(w *writer, f *protogen.Field, fname string, file * switch { case f.Message != nil: ref := typeRef(file, f.Message.Desc, selfPath, imports, "_decode", prefix) - w.line(" local payload") - w.line(" payload, pos = wire.decode_len(buf, pos)") - w.line(" list[#list + 1] = %s(payload)", ref) + if f.Desc.Kind() == protoreflect.GroupKind { + descRef := typeRef(file, f.Message.Desc, selfPath, imports, "_descriptor", prefix) + w.line(" local payload") + w.line(" payload, pos = pb.codec.decode_group(%s, buf, pos, %d)", + descRef, f.Desc.Number()) + w.line(" list[#list + 1] = payload") + } else { + w.line(" local payload") + w.line(" payload, pos = wire.decode_len(buf, pos)") + w.line(" list[#list + 1] = %s(payload)", ref) + } case f.Enum != nil: // Enums are packable (proto3 default). Accept both packed and per-element. w.line(" if wt == 2 then") @@ -661,6 +705,12 @@ func emitMapDecode(w *writer, dst string, f *protogen.Field, file *protogen.File func wireTypeForField(f *protogen.Field) int { switch { case f.Message != nil: + // Proto2 groups: the *opening* tag carries SGROUP (3). The + // closing tag is emitted separately as EGROUP (4) at the end of + // the field body. + if f.Desc.Kind() == protoreflect.GroupKind { + return 3 // SGROUP + } return 2 // LEN case f.Enum != nil: // Repeated packed enums use LEN tag; non-packed elements use VARINT. diff --git a/examples/expected/full/proto2_basic/proto2_basic_pb.lua b/examples/expected/full/proto2_basic/proto2_basic_pb.lua index 2f2aa63564355128d72f2456165fb1682e520a80..b5b2d7e55b035b950a5ae5c61edf03570a68600d 100644 --- a/examples/expected/full/proto2_basic/proto2_basic_pb.lua +++ b/examples/expected/full/proto2_basic/proto2_basic_pb.lua @@ -23,6 +23,9 @@ M.Defaults_descriptor = {name = "proto2_basic.Defaults"} M.Cardinality_descriptor = {name = "proto2_basic.Cardinality"} M.Nested_descriptor = {name = "proto2_basic.Nested"} M.Nested_Inner_descriptor = {name = "proto2_basic.Nested.Inner"} +M.WithGroup_descriptor = {name = "proto2_basic.WithGroup"} +M.WithGroup_SingleGroup_descriptor = {name = "proto2_basic.WithGroup.SingleGroup"} +M.WithGroup_RepGroup_descriptor = {name = "proto2_basic.WithGroup.RepGroup"} -- Message: proto2_basic.Defaults M.Defaults_descriptor.fields = { @@ -86,6 +89,37 @@ M.Nested_Inner_fields = pb.field_names({ x = "x", }) +-- Message: proto2_basic.WithGroup +M.WithGroup_descriptor.fields = { + {name="singlegroup", id=1, kind='group', message=M.WithGroup_SingleGroup_descriptor, optional=true}, + {name="repgroup", id=4, kind='group', message=M.WithGroup_RepGroup_descriptor, repeated=true}, +} +pb.finalize_message(M.WithGroup_descriptor) +M.WithGroup_fields = pb.field_names({ + singlegroup = "singlegroup", + repgroup = "repgroup", +}) + +-- Message: proto2_basic.WithGroup.SingleGroup +M.WithGroup_SingleGroup_descriptor.fields = { + {name="a", id=2, kind='scalar', proto_type="int32", optional=true}, + {name="s", id=3, kind='scalar', proto_type="string", optional=true}, +} +pb.finalize_message(M.WithGroup_SingleGroup_descriptor) +M.WithGroup_SingleGroup_fields = pb.field_names({ + a = "a", + s = "s", +}) + +-- Message: proto2_basic.WithGroup.RepGroup +M.WithGroup_RepGroup_descriptor.fields = { + {name="n", id=5, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.WithGroup_RepGroup_descriptor) +M.WithGroup_RepGroup_fields = pb.field_names({ + n = "n", +}) + -- EmmyLua / lua-language-server type annotations. -- These are comments — no runtime effect. They give editors -- autocomplete and type-checking for the generated wrappers. @@ -116,6 +150,19 @@ M.Nested_Inner_fields = pb.field_names({ ---@class proto2_basic.Nested.Inner ---@field x integer +--- Proto2 legacy groups. Wire format uses SGROUP (3) / EGROUP (4) tag +--- pairs instead of a length-prefixed message body. +---@class proto2_basic.WithGroup +---@field singlegroup? proto2_basic.WithGroup.SingleGroup +---@field repgroup proto2_basic.WithGroup.RepGroup[] + +---@class proto2_basic.WithGroup.SingleGroup +---@field a? integer +---@field s? string + +---@class proto2_basic.WithGroup.RepGroup +---@field n? integer + ---@param t? proto2_basic.Defaults ---@return proto2_basic.Defaults function M.Defaults_new(t) return t or {} end @@ -608,4 +655,232 @@ function M.Nested_Inner_decode_lazy(b) return pb.decode_lazy(M.Nested_Inner_desc ---@return string function M.Nested_Inner_text(t, opts) return pb.text.encode(M.Nested_Inner_descriptor, t, opts) end +---@param t? proto2_basic.WithGroup +---@return proto2_basic.WithGroup +function M.WithGroup_new(t) return t or {} end + +---@param t proto2_basic.WithGroup +---@return string +function M.WithGroup_encode(t) + if type(t) ~= 'table' then + error("expected table for proto2_basic.WithGroup, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: singlegroup + v = t.singlegroup + if v ~= nil or type(v) == 'cdata' then + n = n + 1; out[n] = "\x0b" + n = n + 1; out[n] = M.WithGroup_SingleGroup_encode(v) + n = n + 1; out[n] = "\x0c" + end + -- field 4: repgroup + v = t.repgroup + if v ~= nil and #v > 0 then + local _stag = "\x23" + local _etag = "\x24" + for _i = 1, #v do + n = n + 1; out[n] = _stag + n = n + 1; out[n] = M.WithGroup_RepGroup_encode(v[_i]) + n = n + 1; out[n] = _etag + end + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return proto2_basic.WithGroup +function M.WithGroup_decode(buf) + if type(buf) ~= 'string' then + error("expected string for proto2_basic.WithGroup decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local payload + payload, pos = pb.codec.decode_group(M.WithGroup_SingleGroup_descriptor, buf, pos, 1) + local prev = result.singlegroup + if prev == nil then + result.singlegroup = payload + else + pb.codec.merge_message(M.WithGroup_SingleGroup_descriptor, prev, payload) + end + elseif id == 4 then + local list = result.repgroup + if list == nil then list = {}; result.repgroup = list end + local payload + payload, pos = pb.codec.decode_group(M.WithGroup_RepGroup_descriptor, buf, pos, 4) + list[#list + 1] = payload + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.WithGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_descriptor, b) end +---@param t proto2_basic.WithGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_text(t, opts) return pb.text.encode(M.WithGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup +---@return boolean +function M.WithGroup_has_singlegroup(t) return t.singlegroup ~= nil end +---@param t proto2_basic.WithGroup +function M.WithGroup_clear_singlegroup(t) t.singlegroup = nil end + +---@param t? proto2_basic.WithGroup.SingleGroup +---@return proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_new(t) return t or {} end + +---@param t proto2_basic.WithGroup.SingleGroup +---@return string +function M.WithGroup_SingleGroup_encode(t) + if type(t) ~= 'table' then + error("expected table for proto2_basic.WithGroup.SingleGroup, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 2: a + v = t.a + if v ~= nil then + n = n + 1; out[n] = "\x10" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 3: s + v = t.s + if v ~= nil then + n = n + 1; out[n] = "\x1a" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_decode(buf) + if type(buf) ~= 'string' then + error("expected string for proto2_basic.WithGroup.SingleGroup decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 2 then + local val + val, pos = wire.decode_int32(buf, pos) + result.a = val + elseif id == 3 then + local val + val, pos = wire.decode_string(buf, pos) + result.s = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.WithGroup_SingleGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_SingleGroup_descriptor, b) end +---@param t proto2_basic.WithGroup.SingleGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_SingleGroup_text(t, opts) return pb.text.encode(M.WithGroup_SingleGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup.SingleGroup +---@return boolean +function M.WithGroup_SingleGroup_has_a(t) return t.a ~= nil end +---@param t proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_clear_a(t) t.a = nil end +---@param t proto2_basic.WithGroup.SingleGroup +---@return boolean +function M.WithGroup_SingleGroup_has_s(t) return t.s ~= nil end +---@param t proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_clear_s(t) t.s = nil end + +---@param t? proto2_basic.WithGroup.RepGroup +---@return proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_new(t) return t or {} end + +---@param t proto2_basic.WithGroup.RepGroup +---@return string +function M.WithGroup_RepGroup_encode(t) + if type(t) ~= 'table' then + error("expected table for proto2_basic.WithGroup.RepGroup, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 5: n + v = t.n + if v ~= nil then + n = n + 1; out[n] = "\x28" + n = n + 1; out[n] = wire.encode_int32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_decode(buf) + if type(buf) ~= 'string' then + error("expected string for proto2_basic.WithGroup.RepGroup decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 5 then + local val + val, pos = wire.decode_int32(buf, pos) + result.n = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.WithGroup_RepGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_RepGroup_descriptor, b) end +---@param t proto2_basic.WithGroup.RepGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_RepGroup_text(t, opts) return pb.text.encode(M.WithGroup_RepGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup.RepGroup +---@return boolean +function M.WithGroup_RepGroup_has_n(t) return t.n ~= nil end +---@param t proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_clear_n(t) t.n = nil end + return M diff --git a/examples/expected/full/protobuf_test_messages/proto2/test_messages_proto2_pb.lua b/examples/expected/full/protobuf_test_messages/proto2/test_messages_proto2_pb.lua new file mode 100644 index 0000000000000000000000000000000000000000..d5455cff79aba4accf8437d39021675ac6f917d5 --- /dev/null +++ b/examples/expected/full/protobuf_test_messages/proto2/test_messages_proto2_pb.lua @@ -0,0 +1,6111 @@ +-- Code generated by protoc-gen-tarantool. DO NOT EDIT. +-- source: test_messages_proto2.proto +-- syntax: proto2 +-- package: protobuf_test_messages.proto2 + +local pb = require("pb") +local wire = pb.wire + +local M = {} + +M.options = {cc_enable_arenas = true, go_package = "tarantoolpb_synthetic/test_messages_proto2", java_package = "com.google.protobuf_test_messages.proto2", objc_class_prefix = "Proto2", optimize_for = "SPEED"} + +-- Enum: protobuf_test_messages.proto2.ForeignEnumProto2 +M.ForeignEnumProto2_descriptor = pb.enum("protobuf_test_messages.proto2.ForeignEnumProto2", { + FOREIGN_FOO = 0, + FOREIGN_BAR = 1, + FOREIGN_BAZ = 2, +}) +M.ForeignEnumProto2 = M.ForeignEnumProto2_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +M.TestAllTypesProto2_NestedEnum_descriptor = pb.enum("protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", { + FOO = 0, + BAR = 1, + BAZ = 2, + NEG = -1, +}) +M.TestAllTypesProto2_NestedEnum = M.TestAllTypesProto2_NestedEnum_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.EnumOnlyProto2.Bool +M.EnumOnlyProto2_Bool_descriptor = pb.enum("protobuf_test_messages.proto2.EnumOnlyProto2.Bool", { + kFalse = 0, + kTrue = 1, +}) +M.EnumOnlyProto2_Bool = M.EnumOnlyProto2_Bool_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum +M.TestAllRequiredTypesProto2_NestedEnum_descriptor = pb.enum("protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum", { + FOO = 0, + BAR = 1, + BAZ = 2, + NEG = -1, +}) +M.TestAllRequiredTypesProto2_NestedEnum = M.TestAllRequiredTypesProto2_NestedEnum_descriptor.by_name + +-- Pre-declare message descriptors so cross-references resolve. +M.TestAllTypesProto2_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2"} +M.TestAllTypesProto2_NestedMessage_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage"} +M.TestAllTypesProto2_Data_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.Data"} +M.TestAllTypesProto2_MultiWordGroupField_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField"} +M.ForeignMessageProto2_descriptor = {name = "protobuf_test_messages.proto2.ForeignMessageProto2"} +M.GroupField_descriptor = {name = "protobuf_test_messages.proto2.GroupField"} +M.UnknownToTestAllTypes_descriptor = {name = "protobuf_test_messages.proto2.UnknownToTestAllTypes"} +M.UnknownToTestAllTypes_OptionalGroup_descriptor = {name = "protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup"} +M.NullHypothesisProto2_descriptor = {name = "protobuf_test_messages.proto2.NullHypothesisProto2"} +M.EnumOnlyProto2_descriptor = {name = "protobuf_test_messages.proto2.EnumOnlyProto2"} +M.OneStringProto2_descriptor = {name = "protobuf_test_messages.proto2.OneStringProto2"} +M.ProtoWithKeywords_descriptor = {name = "protobuf_test_messages.proto2.ProtoWithKeywords"} +M.TestAllRequiredTypesProto2_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2"} +M.TestAllRequiredTypesProto2_NestedMessage_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage"} +M.TestAllRequiredTypesProto2_Data_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data"} +M.TestLargeOneof_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof"} +M.TestLargeOneof_A1_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A1"} +M.TestLargeOneof_A2_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A2"} +M.TestLargeOneof_A3_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A3"} +M.TestLargeOneof_A4_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A4"} +M.TestLargeOneof_A5_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A5"} + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2 +M.TestAllTypesProto2_descriptor.fields = { + {name="optional_int32", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="optional_int64", id=2, kind='scalar', proto_type="int64", optional=true}, + {name="optional_uint32", id=3, kind='scalar', proto_type="uint32", optional=true}, + {name="optional_uint64", id=4, kind='scalar', proto_type="uint64", optional=true}, + {name="optional_sint32", id=5, kind='scalar', proto_type="sint32", optional=true}, + {name="optional_sint64", id=6, kind='scalar', proto_type="sint64", optional=true}, + {name="optional_fixed32", id=7, kind='scalar', proto_type="fixed32", optional=true}, + {name="optional_fixed64", id=8, kind='scalar', proto_type="fixed64", optional=true}, + {name="optional_sfixed32", id=9, kind='scalar', proto_type="sfixed32", optional=true}, + {name="optional_sfixed64", id=10, kind='scalar', proto_type="sfixed64", optional=true}, + {name="optional_float", id=11, kind='scalar', proto_type="float", optional=true}, + {name="optional_double", id=12, kind='scalar', proto_type="double", optional=true}, + {name="optional_bool", id=13, kind='scalar', proto_type="bool", optional=true}, + {name="optional_string", id=14, kind='scalar', proto_type="string", optional=true}, + {name="optional_bytes", id=15, kind='scalar', proto_type="bytes", optional=true}, + {name="optional_nested_message", id=18, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, optional=true}, + {name="optional_foreign_message", id=19, kind='message', message=M.ForeignMessageProto2_descriptor, optional=true}, + {name="optional_nested_enum", id=21, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, optional=true}, + {name="optional_foreign_enum", id=22, kind='enum', enum=M.ForeignEnumProto2_descriptor, optional=true}, + {name="optional_string_piece", id=24, kind='scalar', proto_type="string", optional=true, options={ctype = "STRING_PIECE"}}, + {name="optional_cord", id=25, kind='scalar', proto_type="string", optional=true, options={ctype = "CORD"}}, + {name="recursive_message", id=27, kind='message', message=M.TestAllTypesProto2_descriptor, optional=true}, + {name="repeated_int32", id=31, kind='scalar', proto_type="int32", repeated=true, packed=false}, + {name="repeated_int64", id=32, kind='scalar', proto_type="int64", repeated=true, packed=false}, + {name="repeated_uint32", id=33, kind='scalar', proto_type="uint32", repeated=true, packed=false}, + {name="repeated_uint64", id=34, kind='scalar', proto_type="uint64", repeated=true, packed=false}, + {name="repeated_sint32", id=35, kind='scalar', proto_type="sint32", repeated=true, packed=false}, + {name="repeated_sint64", id=36, kind='scalar', proto_type="sint64", repeated=true, packed=false}, + {name="repeated_fixed32", id=37, kind='scalar', proto_type="fixed32", repeated=true, packed=false}, + {name="repeated_fixed64", id=38, kind='scalar', proto_type="fixed64", repeated=true, packed=false}, + {name="repeated_sfixed32", id=39, kind='scalar', proto_type="sfixed32", repeated=true, packed=false}, + {name="repeated_sfixed64", id=40, kind='scalar', proto_type="sfixed64", repeated=true, packed=false}, + {name="repeated_float", id=41, kind='scalar', proto_type="float", repeated=true, packed=false}, + {name="repeated_double", id=42, kind='scalar', proto_type="double", repeated=true, packed=false}, + {name="repeated_bool", id=43, kind='scalar', proto_type="bool", repeated=true, packed=false}, + {name="repeated_string", id=44, kind='scalar', proto_type="string", repeated=true}, + {name="repeated_bytes", id=45, kind='scalar', proto_type="bytes", repeated=true}, + {name="repeated_nested_message", id=48, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, repeated=true}, + {name="repeated_foreign_message", id=49, kind='message', message=M.ForeignMessageProto2_descriptor, repeated=true}, + {name="repeated_nested_enum", id=51, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=false}, + {name="repeated_foreign_enum", id=52, kind='enum', enum=M.ForeignEnumProto2_descriptor, repeated=true, packed=false}, + {name="repeated_string_piece", id=54, kind='scalar', proto_type="string", repeated=true, options={ctype = "STRING_PIECE"}}, + {name="repeated_cord", id=55, kind='scalar', proto_type="string", repeated=true, options={ctype = "CORD"}}, + {name="packed_int32", id=75, kind='scalar', proto_type="int32", repeated=true, packed=true, options={packed = true}}, + {name="packed_int64", id=76, kind='scalar', proto_type="int64", repeated=true, packed=true, options={packed = true}}, + {name="packed_uint32", id=77, kind='scalar', proto_type="uint32", repeated=true, packed=true, options={packed = true}}, + {name="packed_uint64", id=78, kind='scalar', proto_type="uint64", repeated=true, packed=true, options={packed = true}}, + {name="packed_sint32", id=79, kind='scalar', proto_type="sint32", repeated=true, packed=true, options={packed = true}}, + {name="packed_sint64", id=80, kind='scalar', proto_type="sint64", repeated=true, packed=true, options={packed = true}}, + {name="packed_fixed32", id=81, kind='scalar', proto_type="fixed32", repeated=true, packed=true, options={packed = true}}, + {name="packed_fixed64", id=82, kind='scalar', proto_type="fixed64", repeated=true, packed=true, options={packed = true}}, + {name="packed_sfixed32", id=83, kind='scalar', proto_type="sfixed32", repeated=true, packed=true, options={packed = true}}, + {name="packed_sfixed64", id=84, kind='scalar', proto_type="sfixed64", repeated=true, packed=true, options={packed = true}}, + {name="packed_float", id=85, kind='scalar', proto_type="float", repeated=true, packed=true, options={packed = true}}, + {name="packed_double", id=86, kind='scalar', proto_type="double", repeated=true, packed=true, options={packed = true}}, + {name="packed_bool", id=87, kind='scalar', proto_type="bool", repeated=true, packed=true, options={packed = true}}, + {name="packed_nested_enum", id=88, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=true, options={packed = true}}, + {name="unpacked_int32", id=89, kind='scalar', proto_type="int32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_int64", id=90, kind='scalar', proto_type="int64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_uint32", id=91, kind='scalar', proto_type="uint32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_uint64", id=92, kind='scalar', proto_type="uint64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sint32", id=93, kind='scalar', proto_type="sint32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sint64", id=94, kind='scalar', proto_type="sint64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_fixed32", id=95, kind='scalar', proto_type="fixed32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_fixed64", id=96, kind='scalar', proto_type="fixed64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sfixed32", id=97, kind='scalar', proto_type="sfixed32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sfixed64", id=98, kind='scalar', proto_type="sfixed64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_float", id=99, kind='scalar', proto_type="float", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_double", id=100, kind='scalar', proto_type="double", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_bool", id=101, kind='scalar', proto_type="bool", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_nested_enum", id=102, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=false, options={packed = false}}, + {name="map_int32_int32", id=56, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="int32"}}, + {name="map_int64_int64", id=57, kind='map', key={kind='scalar', proto_type="int64"}, value={kind='scalar', proto_type="int64"}}, + {name="map_uint32_uint32", id=58, kind='map', key={kind='scalar', proto_type="uint32"}, value={kind='scalar', proto_type="uint32"}}, + {name="map_uint64_uint64", id=59, kind='map', key={kind='scalar', proto_type="uint64"}, value={kind='scalar', proto_type="uint64"}}, + {name="map_sint32_sint32", id=60, kind='map', key={kind='scalar', proto_type="sint32"}, value={kind='scalar', proto_type="sint32"}}, + {name="map_sint64_sint64", id=61, kind='map', key={kind='scalar', proto_type="sint64"}, value={kind='scalar', proto_type="sint64"}}, + {name="map_fixed32_fixed32", id=62, kind='map', key={kind='scalar', proto_type="fixed32"}, value={kind='scalar', proto_type="fixed32"}}, + {name="map_fixed64_fixed64", id=63, kind='map', key={kind='scalar', proto_type="fixed64"}, value={kind='scalar', proto_type="fixed64"}}, + {name="map_sfixed32_sfixed32", id=64, kind='map', key={kind='scalar', proto_type="sfixed32"}, value={kind='scalar', proto_type="sfixed32"}}, + {name="map_sfixed64_sfixed64", id=65, kind='map', key={kind='scalar', proto_type="sfixed64"}, value={kind='scalar', proto_type="sfixed64"}}, + {name="map_int32_bool", id=104, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="bool"}}, + {name="map_int32_float", id=66, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="float"}}, + {name="map_int32_double", id=67, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="double"}}, + {name="map_int32_nested_message", id=103, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor}}, + {name="map_bool_bool", id=68, kind='map', key={kind='scalar', proto_type="bool"}, value={kind='scalar', proto_type="bool"}}, + {name="map_string_string", id=69, kind='map', key={kind='scalar', proto_type="string"}, value={kind='scalar', proto_type="string"}}, + {name="map_string_bytes", id=70, kind='map', key={kind='scalar', proto_type="string"}, value={kind='scalar', proto_type="bytes"}}, + {name="map_string_nested_message", id=71, kind='map', key={kind='scalar', proto_type="string"}, value={kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor}}, + {name="map_string_foreign_message", id=72, kind='map', key={kind='scalar', proto_type="string"}, value={kind='message', message=M.ForeignMessageProto2_descriptor}}, + {name="map_string_nested_enum", id=73, kind='map', key={kind='scalar', proto_type="string"}, value={kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor}}, + {name="map_string_foreign_enum", id=74, kind='map', key={kind='scalar', proto_type="string"}, value={kind='enum', enum=M.ForeignEnumProto2_descriptor}}, + {name="oneof_uint32", id=111, kind='scalar', proto_type="uint32", oneof="oneof_field"}, + {name="oneof_nested_message", id=112, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, oneof="oneof_field"}, + {name="oneof_string", id=113, kind='scalar', proto_type="string", oneof="oneof_field"}, + {name="oneof_bytes", id=114, kind='scalar', proto_type="bytes", oneof="oneof_field"}, + {name="oneof_bool", id=115, kind='scalar', proto_type="bool", oneof="oneof_field"}, + {name="oneof_uint64", id=116, kind='scalar', proto_type="uint64", oneof="oneof_field"}, + {name="oneof_float", id=117, kind='scalar', proto_type="float", oneof="oneof_field"}, + {name="oneof_double", id=118, kind='scalar', proto_type="double", oneof="oneof_field"}, + {name="oneof_enum", id=119, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, oneof="oneof_field"}, + {name="data", id=201, kind='group', message=M.TestAllTypesProto2_Data_descriptor, optional=true}, + {name="multiwordgroupfield", id=204, kind='group', message=M.TestAllTypesProto2_MultiWordGroupField_descriptor, optional=true}, + {name="default_int32", id=241, kind='scalar', proto_type="int32", optional=true, default_value=-123456789}, + {name="default_int64", id=242, kind='scalar', proto_type="int64", optional=true, default_value=-9123456789123456789LL}, + {name="default_uint32", id=243, kind='scalar', proto_type="uint32", optional=true, default_value=2123456789}, + {name="default_uint64", id=244, kind='scalar', proto_type="uint64", optional=true, default_value=10123456789123456789ULL}, + {name="default_sint32", id=245, kind='scalar', proto_type="sint32", optional=true, default_value=-123456789}, + {name="default_sint64", id=246, kind='scalar', proto_type="sint64", optional=true, default_value=-9123456789123456789LL}, + {name="default_fixed32", id=247, kind='scalar', proto_type="fixed32", optional=true, default_value=2123456789}, + {name="default_fixed64", id=248, kind='scalar', proto_type="fixed64", optional=true, default_value=10123456789123456789ULL}, + {name="default_sfixed32", id=249, kind='scalar', proto_type="sfixed32", optional=true, default_value=-123456789}, + {name="default_sfixed64", id=250, kind='scalar', proto_type="sfixed64", optional=true, default_value=-9123456789123456789LL}, + {name="default_float", id=251, kind='scalar', proto_type="float", optional=true, default_value=8.999999488e+09}, + {name="default_double", id=252, kind='scalar', proto_type="double", optional=true, default_value=7e+22}, + {name="default_bool", id=253, kind='scalar', proto_type="bool", optional=true, default_value=true}, + {name="default_string", id=254, kind='scalar', proto_type="string", optional=true, default_value="Rosebud"}, + {name="default_bytes", id=255, kind='scalar', proto_type="bytes", optional=true, default_value="\x6a\x6f\x73\x68\x75\x61"}, + {name="fieldname1", id=401, kind='scalar', proto_type="int32", optional=true}, + {name="field_name2", id=402, kind='scalar', proto_type="int32", optional=true}, + {name="_field_name3", id=403, kind='scalar', proto_type="int32", optional=true}, + {name="field__name4_", id=404, kind='scalar', proto_type="int32", optional=true}, + {name="field0name5", id=405, kind='scalar', proto_type="int32", optional=true}, + {name="field_0_name6", id=406, kind='scalar', proto_type="int32", optional=true}, + {name="fieldName7", id=407, kind='scalar', proto_type="int32", optional=true}, + {name="FieldName8", id=408, kind='scalar', proto_type="int32", optional=true}, + {name="field_Name9", id=409, kind='scalar', proto_type="int32", optional=true}, + {name="Field_Name10", id=410, kind='scalar', proto_type="int32", optional=true}, + {name="FIELD_NAME11", id=411, kind='scalar', proto_type="int32", optional=true}, + {name="FIELD_name12", id=412, kind='scalar', proto_type="int32", optional=true}, + {name="__field_name13", id=413, kind='scalar', proto_type="int32", optional=true}, + {name="__Field_name14", id=414, kind='scalar', proto_type="int32", optional=true}, + {name="field__name15", id=415, kind='scalar', proto_type="int32", optional=true}, + {name="field__Name16", id=416, kind='scalar', proto_type="int32", optional=true}, + {name="field_name17__", id=417, kind='scalar', proto_type="int32", optional=true}, + {name="Field_name18__", id=418, kind='scalar', proto_type="int32", optional=true}, +} +M.TestAllTypesProto2_descriptor.oneofs = { + oneof_field = {"oneof_uint32", "oneof_nested_message", "oneof_string", "oneof_bytes", "oneof_bool", "oneof_uint64", "oneof_float", "oneof_double", "oneof_enum"}, +} +M.TestAllTypesProto2_descriptor.reserved_names = { + ["reserved_field"] = true, +} +pb.finalize_message(M.TestAllTypesProto2_descriptor) +M.TestAllTypesProto2_fields = pb.field_names({ + optional_int32 = "optional_int32", + optional_int64 = "optional_int64", + optional_uint32 = "optional_uint32", + optional_uint64 = "optional_uint64", + optional_sint32 = "optional_sint32", + optional_sint64 = "optional_sint64", + optional_fixed32 = "optional_fixed32", + optional_fixed64 = "optional_fixed64", + optional_sfixed32 = "optional_sfixed32", + optional_sfixed64 = "optional_sfixed64", + optional_float = "optional_float", + optional_double = "optional_double", + optional_bool = "optional_bool", + optional_string = "optional_string", + optional_bytes = "optional_bytes", + optional_nested_message = "optional_nested_message", + optional_foreign_message = "optional_foreign_message", + optional_nested_enum = "optional_nested_enum", + optional_foreign_enum = "optional_foreign_enum", + optional_string_piece = "optional_string_piece", + optional_cord = "optional_cord", + recursive_message = "recursive_message", + repeated_int32 = "repeated_int32", + repeated_int64 = "repeated_int64", + repeated_uint32 = "repeated_uint32", + repeated_uint64 = "repeated_uint64", + repeated_sint32 = "repeated_sint32", + repeated_sint64 = "repeated_sint64", + repeated_fixed32 = "repeated_fixed32", + repeated_fixed64 = "repeated_fixed64", + repeated_sfixed32 = "repeated_sfixed32", + repeated_sfixed64 = "repeated_sfixed64", + repeated_float = "repeated_float", + repeated_double = "repeated_double", + repeated_bool = "repeated_bool", + repeated_string = "repeated_string", + repeated_bytes = "repeated_bytes", + repeated_nested_message = "repeated_nested_message", + repeated_foreign_message = "repeated_foreign_message", + repeated_nested_enum = "repeated_nested_enum", + repeated_foreign_enum = "repeated_foreign_enum", + repeated_string_piece = "repeated_string_piece", + repeated_cord = "repeated_cord", + packed_int32 = "packed_int32", + packed_int64 = "packed_int64", + packed_uint32 = "packed_uint32", + packed_uint64 = "packed_uint64", + packed_sint32 = "packed_sint32", + packed_sint64 = "packed_sint64", + packed_fixed32 = "packed_fixed32", + packed_fixed64 = "packed_fixed64", + packed_sfixed32 = "packed_sfixed32", + packed_sfixed64 = "packed_sfixed64", + packed_float = "packed_float", + packed_double = "packed_double", + packed_bool = "packed_bool", + packed_nested_enum = "packed_nested_enum", + unpacked_int32 = "unpacked_int32", + unpacked_int64 = "unpacked_int64", + unpacked_uint32 = "unpacked_uint32", + unpacked_uint64 = "unpacked_uint64", + unpacked_sint32 = "unpacked_sint32", + unpacked_sint64 = "unpacked_sint64", + unpacked_fixed32 = "unpacked_fixed32", + unpacked_fixed64 = "unpacked_fixed64", + unpacked_sfixed32 = "unpacked_sfixed32", + unpacked_sfixed64 = "unpacked_sfixed64", + unpacked_float = "unpacked_float", + unpacked_double = "unpacked_double", + unpacked_bool = "unpacked_bool", + unpacked_nested_enum = "unpacked_nested_enum", + map_int32_int32 = "map_int32_int32", + map_int64_int64 = "map_int64_int64", + map_uint32_uint32 = "map_uint32_uint32", + map_uint64_uint64 = "map_uint64_uint64", + map_sint32_sint32 = "map_sint32_sint32", + map_sint64_sint64 = "map_sint64_sint64", + map_fixed32_fixed32 = "map_fixed32_fixed32", + map_fixed64_fixed64 = "map_fixed64_fixed64", + map_sfixed32_sfixed32 = "map_sfixed32_sfixed32", + map_sfixed64_sfixed64 = "map_sfixed64_sfixed64", + map_int32_bool = "map_int32_bool", + map_int32_float = "map_int32_float", + map_int32_double = "map_int32_double", + map_int32_nested_message = "map_int32_nested_message", + map_bool_bool = "map_bool_bool", + map_string_string = "map_string_string", + map_string_bytes = "map_string_bytes", + map_string_nested_message = "map_string_nested_message", + map_string_foreign_message = "map_string_foreign_message", + map_string_nested_enum = "map_string_nested_enum", + map_string_foreign_enum = "map_string_foreign_enum", + oneof_uint32 = "oneof_uint32", + oneof_nested_message = "oneof_nested_message", + oneof_string = "oneof_string", + oneof_bytes = "oneof_bytes", + oneof_bool = "oneof_bool", + oneof_uint64 = "oneof_uint64", + oneof_float = "oneof_float", + oneof_double = "oneof_double", + oneof_enum = "oneof_enum", + data = "data", + multiwordgroupfield = "multiwordgroupfield", + default_int32 = "default_int32", + default_int64 = "default_int64", + default_uint32 = "default_uint32", + default_uint64 = "default_uint64", + default_sint32 = "default_sint32", + default_sint64 = "default_sint64", + default_fixed32 = "default_fixed32", + default_fixed64 = "default_fixed64", + default_sfixed32 = "default_sfixed32", + default_sfixed64 = "default_sfixed64", + default_float = "default_float", + default_double = "default_double", + default_bool = "default_bool", + default_string = "default_string", + default_bytes = "default_bytes", + fieldname1 = "fieldname1", + field_name2 = "field_name2", + _field_name3 = "_field_name3", + field__name4_ = "field__name4_", + field0name5 = "field0name5", + field_0_name6 = "field_0_name6", + fieldName7 = "fieldName7", + FieldName8 = "FieldName8", + field_Name9 = "field_Name9", + Field_Name10 = "Field_Name10", + FIELD_NAME11 = "FIELD_NAME11", + FIELD_name12 = "FIELD_name12", + __field_name13 = "__field_name13", + __Field_name14 = "__Field_name14", + field__name15 = "field__name15", + field__Name16 = "field__Name16", + field_name17__ = "field_name17__", + Field_name18__ = "Field_name18__", +}) +M.TestAllTypesProto2_oneofs = pb.field_names({ + oneof_field = "oneof_field", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +M.TestAllTypesProto2_NestedMessage_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="corecursive", id=2, kind='message', message=M.TestAllTypesProto2_descriptor, optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_NestedMessage_descriptor) +M.TestAllTypesProto2_NestedMessage_fields = pb.field_names({ + a = "a", + corecursive = "corecursive", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.Data +M.TestAllTypesProto2_Data_descriptor.fields = { + {name="group_int32", id=202, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=203, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_Data_descriptor) +M.TestAllTypesProto2_Data_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +M.TestAllTypesProto2_MultiWordGroupField_descriptor.fields = { + {name="group_int32", id=205, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=206, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_MultiWordGroupField_descriptor) +M.TestAllTypesProto2_MultiWordGroupField_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.ForeignMessageProto2 +M.ForeignMessageProto2_descriptor.fields = { + {name="c", id=1, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.ForeignMessageProto2_descriptor) +M.ForeignMessageProto2_fields = pb.field_names({ + c = "c", +}) + +-- Message: protobuf_test_messages.proto2.GroupField +M.GroupField_descriptor.fields = { + {name="group_int32", id=122, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=123, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.GroupField_descriptor) +M.GroupField_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.UnknownToTestAllTypes +M.UnknownToTestAllTypes_descriptor.fields = { + {name="optional_int32", id=1001, kind='scalar', proto_type="int32", optional=true}, + {name="optional_string", id=1002, kind='scalar', proto_type="string", optional=true}, + {name="nested_message", id=1003, kind='message', message=M.ForeignMessageProto2_descriptor, optional=true}, + {name="optionalgroup", id=1004, kind='group', message=M.UnknownToTestAllTypes_OptionalGroup_descriptor, optional=true}, + {name="optional_bool", id=1006, kind='scalar', proto_type="bool", optional=true}, + {name="repeated_int32", id=1011, kind='scalar', proto_type="int32", repeated=true, packed=false}, +} +pb.finalize_message(M.UnknownToTestAllTypes_descriptor) +M.UnknownToTestAllTypes_fields = pb.field_names({ + optional_int32 = "optional_int32", + optional_string = "optional_string", + nested_message = "nested_message", + optionalgroup = "optionalgroup", + optional_bool = "optional_bool", + repeated_int32 = "repeated_int32", +}) + +-- Message: protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +M.UnknownToTestAllTypes_OptionalGroup_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.UnknownToTestAllTypes_OptionalGroup_descriptor) +M.UnknownToTestAllTypes_OptionalGroup_fields = pb.field_names({ + a = "a", +}) + +-- Message: protobuf_test_messages.proto2.NullHypothesisProto2 +M.NullHypothesisProto2_descriptor.fields = { +} +pb.finalize_message(M.NullHypothesisProto2_descriptor) + +-- Message: protobuf_test_messages.proto2.EnumOnlyProto2 +M.EnumOnlyProto2_descriptor.fields = { +} +pb.finalize_message(M.EnumOnlyProto2_descriptor) + +-- Message: protobuf_test_messages.proto2.OneStringProto2 +M.OneStringProto2_descriptor.fields = { + {name="data", id=1, kind='scalar', proto_type="string", optional=true}, +} +pb.finalize_message(M.OneStringProto2_descriptor) +M.OneStringProto2_fields = pb.field_names({ + data = "data", +}) + +-- Message: protobuf_test_messages.proto2.ProtoWithKeywords +M.ProtoWithKeywords_descriptor.fields = { + {name="inline", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="concept", id=2, kind='scalar', proto_type="string", optional=true}, + {name="requires", id=3, kind='scalar', proto_type="string", repeated=true}, +} +pb.finalize_message(M.ProtoWithKeywords_descriptor) +M.ProtoWithKeywords_fields = pb.field_names({ + inline = "inline", + concept = "concept", + requires = "requires", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +M.TestAllRequiredTypesProto2_descriptor.fields = { + {name="required_int32", id=1, kind='scalar', proto_type="int32", required=true}, + {name="required_int64", id=2, kind='scalar', proto_type="int64", required=true}, + {name="required_uint32", id=3, kind='scalar', proto_type="uint32", required=true}, + {name="required_uint64", id=4, kind='scalar', proto_type="uint64", required=true}, + {name="required_sint32", id=5, kind='scalar', proto_type="sint32", required=true}, + {name="required_sint64", id=6, kind='scalar', proto_type="sint64", required=true}, + {name="required_fixed32", id=7, kind='scalar', proto_type="fixed32", required=true}, + {name="required_fixed64", id=8, kind='scalar', proto_type="fixed64", required=true}, + {name="required_sfixed32", id=9, kind='scalar', proto_type="sfixed32", required=true}, + {name="required_sfixed64", id=10, kind='scalar', proto_type="sfixed64", required=true}, + {name="required_float", id=11, kind='scalar', proto_type="float", required=true}, + {name="required_double", id=12, kind='scalar', proto_type="double", required=true}, + {name="required_bool", id=13, kind='scalar', proto_type="bool", required=true}, + {name="required_string", id=14, kind='scalar', proto_type="string", required=true}, + {name="required_bytes", id=15, kind='scalar', proto_type="bytes", required=true}, + {name="required_nested_message", id=18, kind='message', message=M.TestAllRequiredTypesProto2_NestedMessage_descriptor, required=true}, + {name="required_foreign_message", id=19, kind='message', message=M.ForeignMessageProto2_descriptor, required=true}, + {name="required_nested_enum", id=21, kind='enum', enum=M.TestAllRequiredTypesProto2_NestedEnum_descriptor, required=true}, + {name="required_foreign_enum", id=22, kind='enum', enum=M.ForeignEnumProto2_descriptor, required=true}, + {name="required_string_piece", id=24, kind='scalar', proto_type="string", required=true, options={ctype = "STRING_PIECE"}}, + {name="required_cord", id=25, kind='scalar', proto_type="string", required=true, options={ctype = "CORD"}}, + {name="recursive_message", id=27, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, required=true}, + {name="optional_recursive_message", id=28, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, optional=true}, + {name="data", id=201, kind='group', message=M.TestAllRequiredTypesProto2_Data_descriptor, required=true}, + {name="default_int32", id=241, kind='scalar', proto_type="int32", required=true, default_value=-123456789}, + {name="default_int64", id=242, kind='scalar', proto_type="int64", required=true, default_value=-9123456789123456789LL}, + {name="default_uint32", id=243, kind='scalar', proto_type="uint32", required=true, default_value=2123456789}, + {name="default_uint64", id=244, kind='scalar', proto_type="uint64", required=true, default_value=10123456789123456789ULL}, + {name="default_sint32", id=245, kind='scalar', proto_type="sint32", required=true, default_value=-123456789}, + {name="default_sint64", id=246, kind='scalar', proto_type="sint64", required=true, default_value=-9123456789123456789LL}, + {name="default_fixed32", id=247, kind='scalar', proto_type="fixed32", required=true, default_value=2123456789}, + {name="default_fixed64", id=248, kind='scalar', proto_type="fixed64", required=true, default_value=10123456789123456789ULL}, + {name="default_sfixed32", id=249, kind='scalar', proto_type="sfixed32", required=true, default_value=-123456789}, + {name="default_sfixed64", id=250, kind='scalar', proto_type="sfixed64", required=true, default_value=-9123456789123456789LL}, + {name="default_float", id=251, kind='scalar', proto_type="float", required=true, default_value=8.999999488e+09}, + {name="default_double", id=252, kind='scalar', proto_type="double", required=true, default_value=7e+22}, + {name="default_bool", id=253, kind='scalar', proto_type="bool", required=true, default_value=true}, + {name="default_string", id=254, kind='scalar', proto_type="string", required=true, default_value="Rosebud"}, + {name="default_bytes", id=255, kind='scalar', proto_type="bytes", required=true, default_value="\x6a\x6f\x73\x68\x75\x61"}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_descriptor) +M.TestAllRequiredTypesProto2_fields = pb.field_names({ + required_int32 = "required_int32", + required_int64 = "required_int64", + required_uint32 = "required_uint32", + required_uint64 = "required_uint64", + required_sint32 = "required_sint32", + required_sint64 = "required_sint64", + required_fixed32 = "required_fixed32", + required_fixed64 = "required_fixed64", + required_sfixed32 = "required_sfixed32", + required_sfixed64 = "required_sfixed64", + required_float = "required_float", + required_double = "required_double", + required_bool = "required_bool", + required_string = "required_string", + required_bytes = "required_bytes", + required_nested_message = "required_nested_message", + required_foreign_message = "required_foreign_message", + required_nested_enum = "required_nested_enum", + required_foreign_enum = "required_foreign_enum", + required_string_piece = "required_string_piece", + required_cord = "required_cord", + recursive_message = "recursive_message", + optional_recursive_message = "optional_recursive_message", + data = "data", + default_int32 = "default_int32", + default_int64 = "default_int64", + default_uint32 = "default_uint32", + default_uint64 = "default_uint64", + default_sint32 = "default_sint32", + default_sint64 = "default_sint64", + default_fixed32 = "default_fixed32", + default_fixed64 = "default_fixed64", + default_sfixed32 = "default_sfixed32", + default_sfixed64 = "default_sfixed64", + default_float = "default_float", + default_double = "default_double", + default_bool = "default_bool", + default_string = "default_string", + default_bytes = "default_bytes", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +M.TestAllRequiredTypesProto2_NestedMessage_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", required=true}, + {name="corecursive", id=2, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, required=true}, + {name="optional_corecursive", id=3, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, optional=true}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_NestedMessage_descriptor) +M.TestAllRequiredTypesProto2_NestedMessage_fields = pb.field_names({ + a = "a", + corecursive = "corecursive", + optional_corecursive = "optional_corecursive", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +M.TestAllRequiredTypesProto2_Data_descriptor.fields = { + {name="group_int32", id=202, kind='scalar', proto_type="int32", required=true}, + {name="group_uint32", id=203, kind='scalar', proto_type="uint32", required=true}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_Data_descriptor) +M.TestAllRequiredTypesProto2_Data_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof +M.TestLargeOneof_descriptor.fields = { + {name="a1", id=1, kind='message', message=M.TestLargeOneof_A1_descriptor, oneof="large_oneof"}, + {name="a2", id=2, kind='message', message=M.TestLargeOneof_A2_descriptor, oneof="large_oneof"}, + {name="a3", id=3, kind='message', message=M.TestLargeOneof_A3_descriptor, oneof="large_oneof"}, + {name="a4", id=4, kind='message', message=M.TestLargeOneof_A4_descriptor, oneof="large_oneof"}, + {name="a5", id=5, kind='message', message=M.TestLargeOneof_A5_descriptor, oneof="large_oneof"}, +} +M.TestLargeOneof_descriptor.oneofs = { + large_oneof = {"a1", "a2", "a3", "a4", "a5"}, +} +pb.finalize_message(M.TestLargeOneof_descriptor) +M.TestLargeOneof_fields = pb.field_names({ + a1 = "a1", + a2 = "a2", + a3 = "a3", + a4 = "a4", + a5 = "a5", +}) +M.TestLargeOneof_oneofs = pb.field_names({ + large_oneof = "large_oneof", +}) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A1 +M.TestLargeOneof_A1_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A1_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A2 +M.TestLargeOneof_A2_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A2_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A3 +M.TestLargeOneof_A3_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A3_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A4 +M.TestLargeOneof_A4_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A4_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A5 +M.TestLargeOneof_A5_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A5_descriptor) + +-- EmmyLua / lua-language-server type annotations. +-- These are comments — no runtime effect. They give editors +-- autocomplete and type-checking for the generated wrappers. +---@alias protobuf_test_messages.proto2.ForeignEnumProto2 integer +---@alias protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum integer +---@alias protobuf_test_messages.proto2.EnumOnlyProto2.Bool integer +---@alias protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum integer + +--- This proto includes every type of field in both singular and repeated +--- forms. +--- +--- Also, crucially, all messages and enums in this file are eventually +--- submessages of this message. So for example, a fuzz test of TestAllTypes +--- could trigger bugs that occur in any message type in this file. We verify +--- this stays true in a unit test. +---@class protobuf_test_messages.proto2.TestAllTypesProto2 +---@field optional_int32? integer @ Singular +---@field optional_int64? integer +---@field optional_uint32? integer +---@field optional_uint64? integer +---@field optional_sint32? integer +---@field optional_sint64? integer +---@field optional_fixed32? integer +---@field optional_fixed64? integer +---@field optional_sfixed32? integer +---@field optional_sfixed64? integer +---@field optional_float? number +---@field optional_double? number +---@field optional_bool? boolean +---@field optional_string? string +---@field optional_bytes? string +---@field optional_nested_message? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field optional_foreign_message? protobuf_test_messages.proto2.ForeignMessageProto2 +---@field optional_nested_enum? protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +---@field optional_foreign_enum? protobuf_test_messages.proto2.ForeignEnumProto2 +---@field optional_string_piece? string +---@field optional_cord? string +---@field recursive_message? protobuf_test_messages.proto2.TestAllTypesProto2 +---@field repeated_int32 integer[] @ Repeated +---@field repeated_int64 integer[] +---@field repeated_uint32 integer[] +---@field repeated_uint64 integer[] +---@field repeated_sint32 integer[] +---@field repeated_sint64 integer[] +---@field repeated_fixed32 integer[] +---@field repeated_fixed64 integer[] +---@field repeated_sfixed32 integer[] +---@field repeated_sfixed64 integer[] +---@field repeated_float number[] +---@field repeated_double number[] +---@field repeated_bool boolean[] +---@field repeated_string string[] +---@field repeated_bytes string[] +---@field repeated_nested_message protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage[] +---@field repeated_foreign_message protobuf_test_messages.proto2.ForeignMessageProto2[] +---@field repeated_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field repeated_foreign_enum protobuf_test_messages.proto2.ForeignEnumProto2[] +---@field repeated_string_piece string[] +---@field repeated_cord string[] +---@field packed_int32 integer[] @ Packed +---@field packed_int64 integer[] +---@field packed_uint32 integer[] +---@field packed_uint64 integer[] +---@field packed_sint32 integer[] +---@field packed_sint64 integer[] +---@field packed_fixed32 integer[] +---@field packed_fixed64 integer[] +---@field packed_sfixed32 integer[] +---@field packed_sfixed64 integer[] +---@field packed_float number[] +---@field packed_double number[] +---@field packed_bool boolean[] +---@field packed_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field unpacked_int32 integer[] @ Unpacked +---@field unpacked_int64 integer[] +---@field unpacked_uint32 integer[] +---@field unpacked_uint64 integer[] +---@field unpacked_sint32 integer[] +---@field unpacked_sint64 integer[] +---@field unpacked_fixed32 integer[] +---@field unpacked_fixed64 integer[] +---@field unpacked_sfixed32 integer[] +---@field unpacked_sfixed64 integer[] +---@field unpacked_float number[] +---@field unpacked_double number[] +---@field unpacked_bool boolean[] +---@field unpacked_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field map_int32_int32 table @ Map +---@field map_int64_int64 table +---@field map_uint32_uint32 table +---@field map_uint64_uint64 table +---@field map_sint32_sint32 table +---@field map_sint64_sint64 table +---@field map_fixed32_fixed32 table +---@field map_fixed64_fixed64 table +---@field map_sfixed32_sfixed32 table +---@field map_sfixed64_sfixed64 table +---@field map_int32_bool table +---@field map_int32_float table +---@field map_int32_double table +---@field map_int32_nested_message table +---@field map_bool_bool table +---@field map_string_string table +---@field map_string_bytes table +---@field map_string_nested_message table +---@field map_string_foreign_message table +---@field map_string_nested_enum table +---@field map_string_foreign_enum table +---@field oneof_uint32? integer +---@field oneof_nested_message? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field oneof_string? string +---@field oneof_bytes? string +---@field oneof_bool? boolean +---@field oneof_uint64? integer +---@field oneof_float? number +---@field oneof_double? number +---@field oneof_enum? protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +---@field data? protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@field multiwordgroupfield? protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@field default_int32? integer @ default values +---@field default_int64? integer +---@field default_uint32? integer +---@field default_uint64? integer +---@field default_sint32? integer +---@field default_sint64? integer +---@field default_fixed32? integer +---@field default_fixed64? integer +---@field default_sfixed32? integer +---@field default_sfixed64? integer +---@field default_float? number +---@field default_double? number +---@field default_bool? boolean +---@field default_string? string +---@field default_bytes? string +---@field fieldname1? integer @ Test field-name-to-JSON-name convention. (protobuf says names can be any valid C/C++ identifier.) +---@field field_name2? integer +---@field _field_name3? integer +---@field field__name4_? integer +---@field field0name5? integer +---@field field_0_name6? integer +---@field fieldName7? integer +---@field FieldName8? integer +---@field field_Name9? integer +---@field Field_Name10? integer +---@field FIELD_NAME11? integer +---@field FIELD_name12? integer +---@field __field_name13? integer +---@field __Field_name14? integer +---@field field__name15? integer +---@field field__Name16? integer +---@field field_name17__? integer +---@field Field_name18__? integer + +---@class protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field a? integer +---@field corecursive? protobuf_test_messages.proto2.TestAllTypesProto2 + +--- groups +---@class protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.ForeignMessageProto2 +---@field c? integer + +---@class protobuf_test_messages.proto2.GroupField +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.UnknownToTestAllTypes +---@field optional_int32? integer +---@field optional_string? string +---@field nested_message? protobuf_test_messages.proto2.ForeignMessageProto2 +---@field optionalgroup? protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@field optional_bool? boolean +---@field repeated_int32 integer[] + +---@class protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@field a? integer + +---@class protobuf_test_messages.proto2.NullHypothesisProto2 + +---@class protobuf_test_messages.proto2.EnumOnlyProto2 + +---@class protobuf_test_messages.proto2.OneStringProto2 +---@field data? string + +---@class protobuf_test_messages.proto2.ProtoWithKeywords +---@field inline? integer +---@field concept? string +---@field requires string[] + +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field required_int32 integer @ Singular +---@field required_int64 integer +---@field required_uint32 integer +---@field required_uint64 integer +---@field required_sint32 integer +---@field required_sint64 integer +---@field required_fixed32 integer +---@field required_fixed64 integer +---@field required_sfixed32 integer +---@field required_sfixed64 integer +---@field required_float number +---@field required_double number +---@field required_bool boolean +---@field required_string string +---@field required_bytes string +---@field required_nested_message protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@field required_foreign_message protobuf_test_messages.proto2.ForeignMessageProto2 +---@field required_nested_enum protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum +---@field required_foreign_enum protobuf_test_messages.proto2.ForeignEnumProto2 +---@field required_string_piece string +---@field required_cord string +---@field recursive_message protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field optional_recursive_message? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field data protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@field default_int32 integer @ default values +---@field default_int64 integer +---@field default_uint32 integer +---@field default_uint64 integer +---@field default_sint32 integer +---@field default_sint64 integer +---@field default_fixed32 integer +---@field default_fixed64 integer +---@field default_sfixed32 integer +---@field default_sfixed64 integer +---@field default_float number +---@field default_double number +---@field default_bool boolean +---@field default_string string +---@field default_bytes string + +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@field a integer +---@field corecursive protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field optional_corecursive? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 + +--- groups +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@field group_int32 integer +---@field group_uint32 integer + +---@class protobuf_test_messages.proto2.TestLargeOneof +---@field a1? protobuf_test_messages.proto2.TestLargeOneof.A1 +---@field a2? protobuf_test_messages.proto2.TestLargeOneof.A2 +---@field a3? protobuf_test_messages.proto2.TestLargeOneof.A3 +---@field a4? protobuf_test_messages.proto2.TestLargeOneof.A4 +---@field a5? protobuf_test_messages.proto2.TestLargeOneof.A5 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A1 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A2 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A3 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A4 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A5 + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2 +---@return protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return string +function M.TestAllTypesProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllTypesProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _of_oneof_field + if t.oneof_uint32 ~= nil then _of_oneof_field = "oneof_uint32" end + if t.oneof_nested_message ~= nil then _of_oneof_field = "oneof_nested_message" end + if t.oneof_string ~= nil then _of_oneof_field = "oneof_string" end + if t.oneof_bytes ~= nil then _of_oneof_field = "oneof_bytes" end + if t.oneof_bool ~= nil then _of_oneof_field = "oneof_bool" end + if t.oneof_uint64 ~= nil then _of_oneof_field = "oneof_uint64" end + if t.oneof_float ~= nil then _of_oneof_field = "oneof_float" end + if t.oneof_double ~= nil then _of_oneof_field = "oneof_double" end + if t.oneof_enum ~= nil then _of_oneof_field = "oneof_enum" end + -- field 1: optional_int32 + v = t.optional_int32 + if v ~= nil then + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 2: optional_int64 + v = t.optional_int64 + if v ~= nil then + n = n + 1; out[n] = "\x10" + n = n + 1; out[n] = wire.encode_int64(v) + end + -- field 3: optional_uint32 + v = t.optional_uint32 + if v ~= nil then + n = n + 1; out[n] = "\x18" + n = n + 1; out[n] = wire.encode_uint32(v) + end + -- field 4: optional_uint64 + v = t.optional_uint64 + if v ~= nil then + n = n + 1; out[n] = "\x20" + n = n + 1; out[n] = wire.encode_uint64(v) + end + -- field 5: optional_sint32 + v = t.optional_sint32 + if v ~= nil then + n = n + 1; out[n] = "\x28" + n = n + 1; out[n] = wire.encode_sint32(v) + end + -- field 6: optional_sint64 + v = t.optional_sint64 + if v ~= nil then + n = n + 1; out[n] = "\x30" + n = n + 1; out[n] = wire.encode_sint64(v) + end + -- field 7: optional_fixed32 + v = t.optional_fixed32 + if v ~= nil then + n = n + 1; out[n] = "\x3d" + n = n + 1; out[n] = wire.encode_fixed32(v) + end + -- field 8: optional_fixed64 + v = t.optional_fixed64 + if v ~= nil then + n = n + 1; out[n] = "\x41" + n = n + 1; out[n] = wire.encode_fixed64(v) + end + -- field 9: optional_sfixed32 + v = t.optional_sfixed32 + if v ~= nil then + n = n + 1; out[n] = "\x4d" + n = n + 1; out[n] = wire.encode_sfixed32(v) + end + -- field 10: optional_sfixed64 + v = t.optional_sfixed64 + if v ~= nil then + n = n + 1; out[n] = "\x51" + n = n + 1; out[n] = wire.encode_sfixed64(v) + end + -- field 11: optional_float + v = t.optional_float + if v ~= nil then + n = n + 1; out[n] = "\x5d" + n = n + 1; out[n] = wire.encode_float(v) + end + -- field 12: optional_double + v = t.optional_double + if v ~= nil then + n = n + 1; out[n] = "\x61" + n = n + 1; out[n] = wire.encode_double(v) + end + -- field 13: optional_bool + v = t.optional_bool + if v ~= nil then + n = n + 1; out[n] = "\x68" + n = n + 1; out[n] = wire.encode_bool(v) + end + -- field 14: optional_string + v = t.optional_string + if v ~= nil then + n = n + 1; out[n] = "\x72" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 15: optional_bytes + v = t.optional_bytes + if v ~= nil then + n = n + 1; out[n] = "\x7a" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 18: optional_nested_message + v = t.optional_nested_message + if v ~= nil or type(v) == 'cdata' then + local _b = M.TestAllTypesProto2_NestedMessage_encode(v) + n = n + 1; out[n] = "\x92\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 19: optional_foreign_message + v = t.optional_foreign_message + if v ~= nil or type(v) == 'cdata' then + local _b = M.ForeignMessageProto2_encode(v) + n = n + 1; out[n] = "\x9a\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 21: optional_nested_enum + v = t.optional_nested_enum + if v ~= nil then + local nv = v + if type(v) == 'string' then + nv = M.TestAllTypesProto2_NestedEnum[v] + if nv == nil then error("unknown enum value '" .. v .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + n = n + 1; out[n] = "\xa8\x01" + n = n + 1; out[n] = wire.encode_int32(nv) + end + -- field 22: optional_foreign_enum + v = t.optional_foreign_enum + if v ~= nil then + local nv = v + if type(v) == 'string' then + nv = M.ForeignEnumProto2[v] + if nv == nil then error("unknown enum value '" .. v .. "' for protobuf_test_messages.proto2.ForeignEnumProto2", 0) end + end + n = n + 1; out[n] = "\xb0\x01" + n = n + 1; out[n] = wire.encode_int32(nv) + end + -- field 24: optional_string_piece + v = t.optional_string_piece + if v ~= nil then + n = n + 1; out[n] = "\xc2\x01" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 25: optional_cord + v = t.optional_cord + if v ~= nil then + n = n + 1; out[n] = "\xca\x01" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 27: recursive_message + v = t.recursive_message + if v ~= nil or type(v) == 'cdata' then + local _b = M.TestAllTypesProto2_encode(v) + n = n + 1; out[n] = "\xda\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 31: repeated_int32 + v = t.repeated_int32 + if v ~= nil and #v > 0 then + local _tag = "\xf8\x01" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_int32(v[_i]) + end + end + -- field 32: repeated_int64 + v = t.repeated_int64 + if v ~= nil and #v > 0 then + local _tag = "\x80\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_int64(v[_i]) + end + end + -- field 33: repeated_uint32 + v = t.repeated_uint32 + if v ~= nil and #v > 0 then + local _tag = "\x88\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_uint32(v[_i]) + end + end + -- field 34: repeated_uint64 + v = t.repeated_uint64 + if v ~= nil and #v > 0 then + local _tag = "\x90\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_uint64(v[_i]) + end + end + -- field 35: repeated_sint32 + v = t.repeated_sint32 + if v ~= nil and #v > 0 then + local _tag = "\x98\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sint32(v[_i]) + end + end + -- field 36: repeated_sint64 + v = t.repeated_sint64 + if v ~= nil and #v > 0 then + local _tag = "\xa0\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sint64(v[_i]) + end + end + -- field 37: repeated_fixed32 + v = t.repeated_fixed32 + if v ~= nil and #v > 0 then + local _tag = "\xad\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_fixed32(v[_i]) + end + end + -- field 38: repeated_fixed64 + v = t.repeated_fixed64 + if v ~= nil and #v > 0 then + local _tag = "\xb1\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_fixed64(v[_i]) + end + end + -- field 39: repeated_sfixed32 + v = t.repeated_sfixed32 + if v ~= nil and #v > 0 then + local _tag = "\xbd\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sfixed32(v[_i]) + end + end + -- field 40: repeated_sfixed64 + v = t.repeated_sfixed64 + if v ~= nil and #v > 0 then + local _tag = "\xc1\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sfixed64(v[_i]) + end + end + -- field 41: repeated_float + v = t.repeated_float + if v ~= nil and #v > 0 then + local _tag = "\xcd\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_float(v[_i]) + end + end + -- field 42: repeated_double + v = t.repeated_double + if v ~= nil and #v > 0 then + local _tag = "\xd1\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_double(v[_i]) + end + end + -- field 43: repeated_bool + v = t.repeated_bool + if v ~= nil and #v > 0 then + local _tag = "\xd8\x02" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_bool(v[_i]) + end + end + -- field 44: repeated_string + v = t.repeated_string + if v ~= nil and #v > 0 then + local _tag = "\xe2\x02" + for _i = 1, #v do + local _b = v[_i] + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 45: repeated_bytes + v = t.repeated_bytes + if v ~= nil and #v > 0 then + local _tag = "\xea\x02" + for _i = 1, #v do + local _b = v[_i] + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 48: repeated_nested_message + v = t.repeated_nested_message + if v ~= nil and #v > 0 then + local _tag = "\x82\x03" + for _i = 1, #v do + local _b = M.TestAllTypesProto2_NestedMessage_encode(v[_i]) + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 49: repeated_foreign_message + v = t.repeated_foreign_message + if v ~= nil and #v > 0 then + local _tag = "\x8a\x03" + for _i = 1, #v do + local _b = M.ForeignMessageProto2_encode(v[_i]) + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 51: repeated_nested_enum + v = t.repeated_nested_enum + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + local elem = v[_i] + local nv = elem + if type(elem) == 'string' then + nv = M.TestAllTypesProto2_NestedEnum[elem] + if nv == nil then error("unknown enum value '" .. elem .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + m = m + 1; parts[m] = wire.encode_int32(nv) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\x98\x03" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 52: repeated_foreign_enum + v = t.repeated_foreign_enum + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + local elem = v[_i] + local nv = elem + if type(elem) == 'string' then + nv = M.ForeignEnumProto2[elem] + if nv == nil then error("unknown enum value '" .. elem .. "' for protobuf_test_messages.proto2.ForeignEnumProto2", 0) end + end + m = m + 1; parts[m] = wire.encode_int32(nv) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xa0\x03" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 54: repeated_string_piece + v = t.repeated_string_piece + if v ~= nil and #v > 0 then + local _tag = "\xb2\x03" + for _i = 1, #v do + local _b = v[_i] + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 55: repeated_cord + v = t.repeated_cord + if v ~= nil and #v > 0 then + local _tag = "\xba\x03" + for _i = 1, #v do + local _b = v[_i] + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + -- field 75: packed_int32 + v = t.packed_int32 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_int32(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xda\x04" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 76: packed_int64 + v = t.packed_int64 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_int64(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xe2\x04" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 77: packed_uint32 + v = t.packed_uint32 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_uint32(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xea\x04" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 78: packed_uint64 + v = t.packed_uint64 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_uint64(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xf2\x04" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 79: packed_sint32 + v = t.packed_sint32 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_sint32(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xfa\x04" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 80: packed_sint64 + v = t.packed_sint64 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_sint64(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\x82\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 81: packed_fixed32 + v = t.packed_fixed32 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_fixed32(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\x8a\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 82: packed_fixed64 + v = t.packed_fixed64 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_fixed64(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\x92\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 83: packed_sfixed32 + v = t.packed_sfixed32 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_sfixed32(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\x9a\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 84: packed_sfixed64 + v = t.packed_sfixed64 + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_sfixed64(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xa2\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 85: packed_float + v = t.packed_float + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_float(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xaa\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 86: packed_double + v = t.packed_double + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_double(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xb2\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 87: packed_bool + v = t.packed_bool + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + m = m + 1; parts[m] = wire.encode_bool(v[_i]) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xba\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 88: packed_nested_enum + v = t.packed_nested_enum + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + local elem = v[_i] + local nv = elem + if type(elem) == 'string' then + nv = M.TestAllTypesProto2_NestedEnum[elem] + if nv == nil then error("unknown enum value '" .. elem .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + m = m + 1; parts[m] = wire.encode_int32(nv) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xc2\x05" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 89: unpacked_int32 + v = t.unpacked_int32 + if v ~= nil and #v > 0 then + local _tag = "\xc8\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_int32(v[_i]) + end + end + -- field 90: unpacked_int64 + v = t.unpacked_int64 + if v ~= nil and #v > 0 then + local _tag = "\xd0\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_int64(v[_i]) + end + end + -- field 91: unpacked_uint32 + v = t.unpacked_uint32 + if v ~= nil and #v > 0 then + local _tag = "\xd8\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_uint32(v[_i]) + end + end + -- field 92: unpacked_uint64 + v = t.unpacked_uint64 + if v ~= nil and #v > 0 then + local _tag = "\xe0\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_uint64(v[_i]) + end + end + -- field 93: unpacked_sint32 + v = t.unpacked_sint32 + if v ~= nil and #v > 0 then + local _tag = "\xe8\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sint32(v[_i]) + end + end + -- field 94: unpacked_sint64 + v = t.unpacked_sint64 + if v ~= nil and #v > 0 then + local _tag = "\xf0\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sint64(v[_i]) + end + end + -- field 95: unpacked_fixed32 + v = t.unpacked_fixed32 + if v ~= nil and #v > 0 then + local _tag = "\xfd\x05" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_fixed32(v[_i]) + end + end + -- field 96: unpacked_fixed64 + v = t.unpacked_fixed64 + if v ~= nil and #v > 0 then + local _tag = "\x81\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_fixed64(v[_i]) + end + end + -- field 97: unpacked_sfixed32 + v = t.unpacked_sfixed32 + if v ~= nil and #v > 0 then + local _tag = "\x8d\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sfixed32(v[_i]) + end + end + -- field 98: unpacked_sfixed64 + v = t.unpacked_sfixed64 + if v ~= nil and #v > 0 then + local _tag = "\x91\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_sfixed64(v[_i]) + end + end + -- field 99: unpacked_float + v = t.unpacked_float + if v ~= nil and #v > 0 then + local _tag = "\x9d\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_float(v[_i]) + end + end + -- field 100: unpacked_double + v = t.unpacked_double + if v ~= nil and #v > 0 then + local _tag = "\xa1\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_double(v[_i]) + end + end + -- field 101: unpacked_bool + v = t.unpacked_bool + if v ~= nil and #v > 0 then + local _tag = "\xa8\x06" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_bool(v[_i]) + end + end + -- field 102: unpacked_nested_enum + v = t.unpacked_nested_enum + if v ~= nil and #v > 0 then + local parts, m = {}, 0 + for _i = 1, #v do + local elem = v[_i] + local nv = elem + if type(elem) == 'string' then + nv = M.TestAllTypesProto2_NestedEnum[elem] + if nv == nil then error("unknown enum value '" .. elem .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + m = m + 1; parts[m] = wire.encode_int32(nv) + end + local _b = table.concat(parts) + n = n + 1; out[n] = "\xb0\x06" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 56: map_int32_int32 + v = t.map_int32_int32 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xc2\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int32(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_int32(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 57: map_int64_int64 + v = t.map_int64_int64 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xca\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int64(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_int64(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 58: map_uint32_uint32 + v = t.map_uint32_uint32 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xd2\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_uint32(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_uint32(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 59: map_uint64_uint64 + v = t.map_uint64_uint64 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xda\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_uint64(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_uint64(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 60: map_sint32_sint32 + v = t.map_sint32_sint32 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xe2\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_sint32(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_sint32(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 61: map_sint64_sint64 + v = t.map_sint64_sint64 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xea\x03", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_sint64(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_sint64(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 62: map_fixed32_fixed32 + v = t.map_fixed32_fixed32 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xf2\x03", "\x0d", "\x15" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_fixed32(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_fixed32(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 63: map_fixed64_fixed64 + v = t.map_fixed64_fixed64 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xfa\x03", "\x09", "\x11" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_fixed64(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_fixed64(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 64: map_sfixed32_sfixed32 + v = t.map_sfixed32_sfixed32 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\x82\x04", "\x0d", "\x15" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_sfixed32(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_sfixed32(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 65: map_sfixed64_sfixed64 + v = t.map_sfixed64_sfixed64 + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\x8a\x04", "\x09", "\x11" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_sfixed64(_k) + end + if _val ~= 0 then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_sfixed64(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 104: map_int32_bool + v = t.map_int32_bool + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xc2\x06", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int32(_k) + end + if _val ~= false then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_bool(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 66: map_int32_float + v = t.map_int32_float + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\x92\x04", "\x08", "\x15" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int32(_k) + end + if (_val ~= 0 or 1/_val == -math.huge) then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_float(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 67: map_int32_double + v = t.map_int32_double + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\x9a\x04", "\x08", "\x11" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int32(_k) + end + if (_val ~= 0 or 1/_val == -math.huge) then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_double(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 103: map_int32_nested_message + v = t.map_int32_nested_message + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xba\x06", "\x08", "\x12" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= 0 then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_int32(_k) + end + if _val ~= nil then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_len(M.TestAllTypesProto2_NestedMessage_encode(_val)) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 68: map_bool_bool + v = t.map_bool_bool + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xa2\x04", "\x08", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= false then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_bool(_k) + end + if _val ~= false then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_bool(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 69: map_string_string + v = t.map_string_string + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xaa\x04", "\x0a", "\x12" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + if _val ~= '' then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_string(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 70: map_string_bytes + v = t.map_string_bytes + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xb2\x04", "\x0a", "\x12" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + if _val ~= '' then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_bytes(_val) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 71: map_string_nested_message + v = t.map_string_nested_message + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xba\x04", "\x0a", "\x12" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + if _val ~= nil then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_len(M.TestAllTypesProto2_NestedMessage_encode(_val)) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 72: map_string_foreign_message + v = t.map_string_foreign_message + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xc2\x04", "\x0a", "\x12" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + if _val ~= nil then + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_len(M.ForeignMessageProto2_encode(_val)) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 73: map_string_nested_enum + v = t.map_string_nested_enum + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xca\x04", "\x0a", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + do + local _nv = _val + if type(_val) == 'string' then + _nv = M.TestAllTypesProto2_NestedEnum[_val] + if _nv == nil then error("unknown enum value '" .. _val .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_int32(_nv) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 74: map_string_foreign_enum + v = t.map_string_foreign_enum + if v ~= nil and next(v) ~= nil then + local _tag, _ktag, _vtag = "\xd2\x04", "\x0a", "\x10" + for _k, _val in pairs(v) do + local entry, _m = {}, 0 + if _k ~= '' then + _m = _m + 1; entry[_m] = _ktag + _m = _m + 1; entry[_m] = wire.encode_string(_k) + end + do + local _nv = _val + if type(_val) == 'string' then + _nv = M.ForeignEnumProto2[_val] + if _nv == nil then error("unknown enum value '" .. _val .. "' for protobuf_test_messages.proto2.ForeignEnumProto2", 0) end + end + _m = _m + 1; entry[_m] = _vtag + _m = _m + 1; entry[_m] = wire.encode_int32(_nv) + end + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_len(table.concat(entry)) + end + end + -- field 111: oneof_uint32 + v = t.oneof_uint32 + if _of_oneof_field == "oneof_uint32" then + n = n + 1; out[n] = "\xf8\x06" + n = n + 1; out[n] = wire.encode_uint32(v) + end + -- field 112: oneof_nested_message + v = t.oneof_nested_message + if _of_oneof_field == "oneof_nested_message" then + local _b = M.TestAllTypesProto2_NestedMessage_encode(v) + n = n + 1; out[n] = "\x82\x07" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 113: oneof_string + v = t.oneof_string + if _of_oneof_field == "oneof_string" then + n = n + 1; out[n] = "\x8a\x07" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 114: oneof_bytes + v = t.oneof_bytes + if _of_oneof_field == "oneof_bytes" then + n = n + 1; out[n] = "\x92\x07" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 115: oneof_bool + v = t.oneof_bool + if _of_oneof_field == "oneof_bool" then + n = n + 1; out[n] = "\x98\x07" + n = n + 1; out[n] = wire.encode_bool(v) + end + -- field 116: oneof_uint64 + v = t.oneof_uint64 + if _of_oneof_field == "oneof_uint64" then + n = n + 1; out[n] = "\xa0\x07" + n = n + 1; out[n] = wire.encode_uint64(v) + end + -- field 117: oneof_float + v = t.oneof_float + if _of_oneof_field == "oneof_float" then + n = n + 1; out[n] = "\xad\x07" + n = n + 1; out[n] = wire.encode_float(v) + end + -- field 118: oneof_double + v = t.oneof_double + if _of_oneof_field == "oneof_double" then + n = n + 1; out[n] = "\xb1\x07" + n = n + 1; out[n] = wire.encode_double(v) + end + -- field 119: oneof_enum + v = t.oneof_enum + if _of_oneof_field == "oneof_enum" then + local nv = v + if type(v) == 'string' then + nv = M.TestAllTypesProto2_NestedEnum[v] + if nv == nil then error("unknown enum value '" .. v .. "' for protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", 0) end + end + n = n + 1; out[n] = "\xb8\x07" + n = n + 1; out[n] = wire.encode_int32(nv) + end + -- field 201: data + v = t.data + if v ~= nil or type(v) == 'cdata' then + n = n + 1; out[n] = "\xcb\x0c" + n = n + 1; out[n] = M.TestAllTypesProto2_Data_encode(v) + n = n + 1; out[n] = "\xcc\x0c" + end + -- field 204: multiwordgroupfield + v = t.multiwordgroupfield + if v ~= nil or type(v) == 'cdata' then + n = n + 1; out[n] = "\xe3\x0c" + n = n + 1; out[n] = M.TestAllTypesProto2_MultiWordGroupField_encode(v) + n = n + 1; out[n] = "\xe4\x0c" + end + -- field 241: default_int32 + v = t.default_int32 + if v ~= nil then + n = n + 1; out[n] = "\x88\x0f" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 242: default_int64 + v = t.default_int64 + if v ~= nil then + n = n + 1; out[n] = "\x90\x0f" + n = n + 1; out[n] = wire.encode_int64(v) + end + -- field 243: default_uint32 + v = t.default_uint32 + if v ~= nil then + n = n + 1; out[n] = "\x98\x0f" + n = n + 1; out[n] = wire.encode_uint32(v) + end + -- field 244: default_uint64 + v = t.default_uint64 + if v ~= nil then + n = n + 1; out[n] = "\xa0\x0f" + n = n + 1; out[n] = wire.encode_uint64(v) + end + -- field 245: default_sint32 + v = t.default_sint32 + if v ~= nil then + n = n + 1; out[n] = "\xa8\x0f" + n = n + 1; out[n] = wire.encode_sint32(v) + end + -- field 246: default_sint64 + v = t.default_sint64 + if v ~= nil then + n = n + 1; out[n] = "\xb0\x0f" + n = n + 1; out[n] = wire.encode_sint64(v) + end + -- field 247: default_fixed32 + v = t.default_fixed32 + if v ~= nil then + n = n + 1; out[n] = "\xbd\x0f" + n = n + 1; out[n] = wire.encode_fixed32(v) + end + -- field 248: default_fixed64 + v = t.default_fixed64 + if v ~= nil then + n = n + 1; out[n] = "\xc1\x0f" + n = n + 1; out[n] = wire.encode_fixed64(v) + end + -- field 249: default_sfixed32 + v = t.default_sfixed32 + if v ~= nil then + n = n + 1; out[n] = "\xcd\x0f" + n = n + 1; out[n] = wire.encode_sfixed32(v) + end + -- field 250: default_sfixed64 + v = t.default_sfixed64 + if v ~= nil then + n = n + 1; out[n] = "\xd1\x0f" + n = n + 1; out[n] = wire.encode_sfixed64(v) + end + -- field 251: default_float + v = t.default_float + if v ~= nil then + n = n + 1; out[n] = "\xdd\x0f" + n = n + 1; out[n] = wire.encode_float(v) + end + -- field 252: default_double + v = t.default_double + if v ~= nil then + n = n + 1; out[n] = "\xe1\x0f" + n = n + 1; out[n] = wire.encode_double(v) + end + -- field 253: default_bool + v = t.default_bool + if v ~= nil then + n = n + 1; out[n] = "\xe8\x0f" + n = n + 1; out[n] = wire.encode_bool(v) + end + -- field 254: default_string + v = t.default_string + if v ~= nil then + n = n + 1; out[n] = "\xf2\x0f" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 255: default_bytes + v = t.default_bytes + if v ~= nil then + n = n + 1; out[n] = "\xfa\x0f" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 401: fieldname1 + v = t.fieldname1 + if v ~= nil then + n = n + 1; out[n] = "\x88\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 402: field_name2 + v = t.field_name2 + if v ~= nil then + n = n + 1; out[n] = "\x90\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 403: _field_name3 + v = t._field_name3 + if v ~= nil then + n = n + 1; out[n] = "\x98\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 404: field__name4_ + v = t.field__name4_ + if v ~= nil then + n = n + 1; out[n] = "\xa0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 405: field0name5 + v = t.field0name5 + if v ~= nil then + n = n + 1; out[n] = "\xa8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 406: field_0_name6 + v = t.field_0_name6 + if v ~= nil then + n = n + 1; out[n] = "\xb0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 407: fieldName7 + v = t.fieldName7 + if v ~= nil then + n = n + 1; out[n] = "\xb8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 408: FieldName8 + v = t.FieldName8 + if v ~= nil then + n = n + 1; out[n] = "\xc0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 409: field_Name9 + v = t.field_Name9 + if v ~= nil then + n = n + 1; out[n] = "\xc8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 410: Field_Name10 + v = t.Field_Name10 + if v ~= nil then + n = n + 1; out[n] = "\xd0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 411: FIELD_NAME11 + v = t.FIELD_NAME11 + if v ~= nil then + n = n + 1; out[n] = "\xd8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 412: FIELD_name12 + v = t.FIELD_name12 + if v ~= nil then + n = n + 1; out[n] = "\xe0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 413: __field_name13 + v = t.__field_name13 + if v ~= nil then + n = n + 1; out[n] = "\xe8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 414: __Field_name14 + v = t.__Field_name14 + if v ~= nil then + n = n + 1; out[n] = "\xf0\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 415: field__name15 + v = t.field__name15 + if v ~= nil then + n = n + 1; out[n] = "\xf8\x19" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 416: field__Name16 + v = t.field__Name16 + if v ~= nil then + n = n + 1; out[n] = "\x80\x1a" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 417: field_name17__ + v = t.field_name17__ + if v ~= nil then + n = n + 1; out[n] = "\x88\x1a" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 418: Field_name18__ + v = t.Field_name18__ + if v ~= nil then + n = n + 1; out[n] = "\x90\x1a" + n = n + 1; out[n] = wire.encode_int32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllTypesProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.optional_int32 = val + elseif id == 2 then + local val + val, pos = wire.decode_int64(buf, pos) + result.optional_int64 = val + elseif id == 3 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.optional_uint32 = val + elseif id == 4 then + local val + val, pos = wire.decode_uint64(buf, pos) + result.optional_uint64 = val + elseif id == 5 then + local val + val, pos = wire.decode_sint32(buf, pos) + result.optional_sint32 = val + elseif id == 6 then + local val + val, pos = wire.decode_sint64(buf, pos) + result.optional_sint64 = val + elseif id == 7 then + local val + val, pos = wire.decode_fixed32(buf, pos) + result.optional_fixed32 = val + elseif id == 8 then + local val + val, pos = wire.decode_fixed64(buf, pos) + result.optional_fixed64 = val + elseif id == 9 then + local val + val, pos = wire.decode_sfixed32(buf, pos) + result.optional_sfixed32 = val + elseif id == 10 then + local val + val, pos = wire.decode_sfixed64(buf, pos) + result.optional_sfixed64 = val + elseif id == 11 then + local val + val, pos = wire.decode_float(buf, pos) + result.optional_float = val + elseif id == 12 then + local val + val, pos = wire.decode_double(buf, pos) + result.optional_double = val + elseif id == 13 then + local val + val, pos = wire.decode_bool(buf, pos) + result.optional_bool = val + elseif id == 14 then + local val + val, pos = wire.decode_string(buf, pos) + result.optional_string = val + elseif id == 15 then + local val + val, pos = wire.decode_bytes(buf, pos) + result.optional_bytes = val + elseif id == 18 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.optional_nested_message + if prev == nil then + result.optional_nested_message = M.TestAllTypesProto2_NestedMessage_decode(payload) + else + pb.codec.merge_message(M.TestAllTypesProto2_NestedMessage_descriptor, prev, M.TestAllTypesProto2_NestedMessage_decode(payload)) + end + elseif id == 19 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.optional_foreign_message + if prev == nil then + result.optional_foreign_message = M.ForeignMessageProto2_decode(payload) + else + pb.codec.merge_message(M.ForeignMessageProto2_descriptor, prev, M.ForeignMessageProto2_decode(payload)) + end + elseif id == 21 then + local u + u, pos = wire.decode_varint(buf, pos) + result.optional_nested_enum = wire.varint_to_int32(u) + elseif id == 22 then + local u + u, pos = wire.decode_varint(buf, pos) + result.optional_foreign_enum = wire.varint_to_int32(u) + elseif id == 24 then + local val + val, pos = wire.decode_string(buf, pos) + result.optional_string_piece = val + elseif id == 25 then + local val + val, pos = wire.decode_string(buf, pos) + result.optional_cord = val + elseif id == 27 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.recursive_message + if prev == nil then + result.recursive_message = M.TestAllTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllTypesProto2_descriptor, prev, M.TestAllTypesProto2_decode(payload)) + end + elseif id == 31 then + local list = result.repeated_int32 + if list == nil then list = {}; result.repeated_int32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int32(buf, pos) + list[#list + 1] = val + end + elseif id == 32 then + local list = result.repeated_int64 + if list == nil then list = {}; result.repeated_int64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int64(buf, pos) + list[#list + 1] = val + end + elseif id == 33 then + local list = result.repeated_uint32 + if list == nil then list = {}; result.repeated_uint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint32(buf, pos) + list[#list + 1] = val + end + elseif id == 34 then + local list = result.repeated_uint64 + if list == nil then list = {}; result.repeated_uint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint64(buf, pos) + list[#list + 1] = val + end + elseif id == 35 then + local list = result.repeated_sint32 + if list == nil then list = {}; result.repeated_sint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint32(buf, pos) + list[#list + 1] = val + end + elseif id == 36 then + local list = result.repeated_sint64 + if list == nil then list = {}; result.repeated_sint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint64(buf, pos) + list[#list + 1] = val + end + elseif id == 37 then + local list = result.repeated_fixed32 + if list == nil then list = {}; result.repeated_fixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 38 then + local list = result.repeated_fixed64 + if list == nil then list = {}; result.repeated_fixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 39 then + local list = result.repeated_sfixed32 + if list == nil then list = {}; result.repeated_sfixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 40 then + local list = result.repeated_sfixed64 + if list == nil then list = {}; result.repeated_sfixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 41 then + local list = result.repeated_float + if list == nil then list = {}; result.repeated_float = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_float(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_float(buf, pos) + list[#list + 1] = val + end + elseif id == 42 then + local list = result.repeated_double + if list == nil then list = {}; result.repeated_double = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_double(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_double(buf, pos) + list[#list + 1] = val + end + elseif id == 43 then + local list = result.repeated_bool + if list == nil then list = {}; result.repeated_bool = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_bool(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_bool(buf, pos) + list[#list + 1] = val + end + elseif id == 44 then + local list = result.repeated_string + if list == nil then list = {}; result.repeated_string = list end + local val + val, pos = wire.decode_string(buf, pos) + list[#list + 1] = val + elseif id == 45 then + local list = result.repeated_bytes + if list == nil then list = {}; result.repeated_bytes = list end + local val + val, pos = wire.decode_bytes(buf, pos) + list[#list + 1] = val + elseif id == 48 then + local list = result.repeated_nested_message + if list == nil then list = {}; result.repeated_nested_message = list end + local payload + payload, pos = wire.decode_len(buf, pos) + list[#list + 1] = M.TestAllTypesProto2_NestedMessage_decode(payload) + elseif id == 49 then + local list = result.repeated_foreign_message + if list == nil then list = {}; result.repeated_foreign_message = list end + local payload + payload, pos = wire.decode_len(buf, pos) + list[#list + 1] = M.ForeignMessageProto2_decode(payload) + elseif id == 51 then + local list = result.repeated_nested_enum + if list == nil then list = {}; result.repeated_nested_enum = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local u + u, p2 = wire.decode_varint(payload, p2) + list[#list + 1] = wire.varint_to_int32(u) + end + else + local u + u, pos = wire.decode_varint(buf, pos) + list[#list + 1] = wire.varint_to_int32(u) + end + elseif id == 52 then + local list = result.repeated_foreign_enum + if list == nil then list = {}; result.repeated_foreign_enum = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local u + u, p2 = wire.decode_varint(payload, p2) + list[#list + 1] = wire.varint_to_int32(u) + end + else + local u + u, pos = wire.decode_varint(buf, pos) + list[#list + 1] = wire.varint_to_int32(u) + end + elseif id == 54 then + local list = result.repeated_string_piece + if list == nil then list = {}; result.repeated_string_piece = list end + local val + val, pos = wire.decode_string(buf, pos) + list[#list + 1] = val + elseif id == 55 then + local list = result.repeated_cord + if list == nil then list = {}; result.repeated_cord = list end + local val + val, pos = wire.decode_string(buf, pos) + list[#list + 1] = val + elseif id == 75 then + local list = result.packed_int32 + if list == nil then list = {}; result.packed_int32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int32(buf, pos) + list[#list + 1] = val + end + elseif id == 76 then + local list = result.packed_int64 + if list == nil then list = {}; result.packed_int64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int64(buf, pos) + list[#list + 1] = val + end + elseif id == 77 then + local list = result.packed_uint32 + if list == nil then list = {}; result.packed_uint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint32(buf, pos) + list[#list + 1] = val + end + elseif id == 78 then + local list = result.packed_uint64 + if list == nil then list = {}; result.packed_uint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint64(buf, pos) + list[#list + 1] = val + end + elseif id == 79 then + local list = result.packed_sint32 + if list == nil then list = {}; result.packed_sint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint32(buf, pos) + list[#list + 1] = val + end + elseif id == 80 then + local list = result.packed_sint64 + if list == nil then list = {}; result.packed_sint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint64(buf, pos) + list[#list + 1] = val + end + elseif id == 81 then + local list = result.packed_fixed32 + if list == nil then list = {}; result.packed_fixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 82 then + local list = result.packed_fixed64 + if list == nil then list = {}; result.packed_fixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 83 then + local list = result.packed_sfixed32 + if list == nil then list = {}; result.packed_sfixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 84 then + local list = result.packed_sfixed64 + if list == nil then list = {}; result.packed_sfixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 85 then + local list = result.packed_float + if list == nil then list = {}; result.packed_float = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_float(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_float(buf, pos) + list[#list + 1] = val + end + elseif id == 86 then + local list = result.packed_double + if list == nil then list = {}; result.packed_double = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_double(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_double(buf, pos) + list[#list + 1] = val + end + elseif id == 87 then + local list = result.packed_bool + if list == nil then list = {}; result.packed_bool = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_bool(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_bool(buf, pos) + list[#list + 1] = val + end + elseif id == 88 then + local list = result.packed_nested_enum + if list == nil then list = {}; result.packed_nested_enum = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local u + u, p2 = wire.decode_varint(payload, p2) + list[#list + 1] = wire.varint_to_int32(u) + end + else + local u + u, pos = wire.decode_varint(buf, pos) + list[#list + 1] = wire.varint_to_int32(u) + end + elseif id == 89 then + local list = result.unpacked_int32 + if list == nil then list = {}; result.unpacked_int32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int32(buf, pos) + list[#list + 1] = val + end + elseif id == 90 then + local list = result.unpacked_int64 + if list == nil then list = {}; result.unpacked_int64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int64(buf, pos) + list[#list + 1] = val + end + elseif id == 91 then + local list = result.unpacked_uint32 + if list == nil then list = {}; result.unpacked_uint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint32(buf, pos) + list[#list + 1] = val + end + elseif id == 92 then + local list = result.unpacked_uint64 + if list == nil then list = {}; result.unpacked_uint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_uint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_uint64(buf, pos) + list[#list + 1] = val + end + elseif id == 93 then + local list = result.unpacked_sint32 + if list == nil then list = {}; result.unpacked_sint32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint32(buf, pos) + list[#list + 1] = val + end + elseif id == 94 then + local list = result.unpacked_sint64 + if list == nil then list = {}; result.unpacked_sint64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sint64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sint64(buf, pos) + list[#list + 1] = val + end + elseif id == 95 then + local list = result.unpacked_fixed32 + if list == nil then list = {}; result.unpacked_fixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 96 then + local list = result.unpacked_fixed64 + if list == nil then list = {}; result.unpacked_fixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_fixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_fixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 97 then + local list = result.unpacked_sfixed32 + if list == nil then list = {}; result.unpacked_sfixed32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed32(buf, pos) + list[#list + 1] = val + end + elseif id == 98 then + local list = result.unpacked_sfixed64 + if list == nil then list = {}; result.unpacked_sfixed64 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_sfixed64(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_sfixed64(buf, pos) + list[#list + 1] = val + end + elseif id == 99 then + local list = result.unpacked_float + if list == nil then list = {}; result.unpacked_float = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_float(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_float(buf, pos) + list[#list + 1] = val + end + elseif id == 100 then + local list = result.unpacked_double + if list == nil then list = {}; result.unpacked_double = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_double(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_double(buf, pos) + list[#list + 1] = val + end + elseif id == 101 then + local list = result.unpacked_bool + if list == nil then list = {}; result.unpacked_bool = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_bool(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_bool(buf, pos) + list[#list + 1] = val + end + elseif id == 102 then + local list = result.unpacked_nested_enum + if list == nil then list = {}; result.unpacked_nested_enum = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local u + u, p2 = wire.decode_varint(payload, p2) + list[#list + 1] = wire.varint_to_int32(u) + end + else + local u + u, pos = wire.decode_varint(buf, pos) + list[#list + 1] = wire.varint_to_int32(u) + end + elseif id == 56 then + local map = result.map_int32_int32 + if map == nil then map = {}; result.map_int32_int32 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_int32(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 57 then + local map = result.map_int64_int64 + if map == nil then map = {}; result.map_int64_int64 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int64(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_int64(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + for _k in pairs(map) do + if _k == _key then _key = _k; break end + end + map[_key] = _val + elseif id == 58 then + local map = result.map_uint32_uint32 + if map == nil then map = {}; result.map_uint32_uint32 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_uint32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_uint32(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 59 then + local map = result.map_uint64_uint64 + if map == nil then map = {}; result.map_uint64_uint64 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_uint64(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_uint64(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + for _k in pairs(map) do + if _k == _key then _key = _k; break end + end + map[_key] = _val + elseif id == 60 then + local map = result.map_sint32_sint32 + if map == nil then map = {}; result.map_sint32_sint32 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_sint32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_sint32(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 61 then + local map = result.map_sint64_sint64 + if map == nil then map = {}; result.map_sint64_sint64 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_sint64(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_sint64(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + for _k in pairs(map) do + if _k == _key then _key = _k; break end + end + map[_key] = _val + elseif id == 62 then + local map = result.map_fixed32_fixed32 + if map == nil then map = {}; result.map_fixed32_fixed32 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_fixed32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_fixed32(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 63 then + local map = result.map_fixed64_fixed64 + if map == nil then map = {}; result.map_fixed64_fixed64 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_fixed64(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_fixed64(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + for _k in pairs(map) do + if _k == _key then _key = _k; break end + end + map[_key] = _val + elseif id == 64 then + local map = result.map_sfixed32_sfixed32 + if map == nil then map = {}; result.map_sfixed32_sfixed32 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_sfixed32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_sfixed32(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 65 then + local map = result.map_sfixed64_sfixed64 + if map == nil then map = {}; result.map_sfixed64_sfixed64 = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_sfixed64(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_sfixed64(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + for _k in pairs(map) do + if _k == _key then _key = _k; break end + end + map[_key] = _val + elseif id == 104 then + local map = result.map_int32_bool + if map == nil then map = {}; result.map_int32_bool = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, false + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_bool(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 66 then + local map = result.map_int32_float + if map == nil then map = {}; result.map_int32_float = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_float(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 67 then + local map = result.map_int32_double + if map == nil then map = {}; result.map_int32_double = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int32(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_double(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 103 then + local map = result.map_int32_nested_message + if map == nil then map = {}; result.map_int32_nested_message = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = 0, {} + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_int32(payload, _ep) + elseif eid == 2 then + local _payload + _payload, _ep = wire.decode_len(payload, _ep) + _val = M.TestAllTypesProto2_NestedMessage_decode(_payload) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 68 then + local map = result.map_bool_bool + if map == nil then map = {}; result.map_bool_bool = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = false, false + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_bool(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_bool(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 69 then + local map = result.map_string_string + if map == nil then map = {}; result.map_string_string = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', '' + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_string(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 70 then + local map = result.map_string_bytes + if map == nil then map = {}; result.map_string_bytes = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', '' + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + _val, _ep = wire.decode_bytes(payload, _ep) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 71 then + local map = result.map_string_nested_message + if map == nil then map = {}; result.map_string_nested_message = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', {} + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + local _payload + _payload, _ep = wire.decode_len(payload, _ep) + _val = M.TestAllTypesProto2_NestedMessage_decode(_payload) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 72 then + local map = result.map_string_foreign_message + if map == nil then map = {}; result.map_string_foreign_message = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', {} + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + local _payload + _payload, _ep = wire.decode_len(payload, _ep) + _val = M.ForeignMessageProto2_decode(_payload) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 73 then + local map = result.map_string_nested_enum + if map == nil then map = {}; result.map_string_nested_enum = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + local _u + _u, _ep = wire.decode_varint(payload, _ep) + _val = wire.varint_to_int32(_u) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 74 then + local map = result.map_string_foreign_enum + if map == nil then map = {}; result.map_string_foreign_enum = map end + local payload + payload, pos = wire.decode_len(buf, pos) + local _ep, _elim = 1, #payload + local _key, _val = '', 0 + while _ep <= _elim do + local eid, ewt + eid, ewt, _ep = wire.decode_tag(payload, _ep) + if eid == 1 then + _key, _ep = wire.decode_string(payload, _ep) + elseif eid == 2 then + local _u + _u, _ep = wire.decode_varint(payload, _ep) + _val = wire.varint_to_int32(_u) + else + _ep = wire.skip_field(payload, _ep, ewt, eid) + end + end + map[_key] = _val + elseif id == 111 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.oneof_uint32 = val + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 112 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.oneof_nested_message + if prev == nil then + result.oneof_nested_message = M.TestAllTypesProto2_NestedMessage_decode(payload) + else + pb.codec.merge_message(M.TestAllTypesProto2_NestedMessage_descriptor, prev, M.TestAllTypesProto2_NestedMessage_decode(payload)) + end + result.oneof_uint32 = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 113 then + local val + val, pos = wire.decode_string(buf, pos) + result.oneof_string = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 114 then + local val + val, pos = wire.decode_bytes(buf, pos) + result.oneof_bytes = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 115 then + local val + val, pos = wire.decode_bool(buf, pos) + result.oneof_bool = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 116 then + local val + val, pos = wire.decode_uint64(buf, pos) + result.oneof_uint64 = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_float = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 117 then + local val + val, pos = wire.decode_float(buf, pos) + result.oneof_float = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_double = nil + result.oneof_enum = nil + elseif id == 118 then + local val + val, pos = wire.decode_double(buf, pos) + result.oneof_double = val + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_enum = nil + elseif id == 119 then + local u + u, pos = wire.decode_varint(buf, pos) + result.oneof_enum = wire.varint_to_int32(u) + result.oneof_uint32 = nil + result.oneof_nested_message = nil + result.oneof_string = nil + result.oneof_bytes = nil + result.oneof_bool = nil + result.oneof_uint64 = nil + result.oneof_float = nil + result.oneof_double = nil + elseif id == 201 then + local payload + payload, pos = pb.codec.decode_group(M.TestAllTypesProto2_Data_descriptor, buf, pos, 201) + local prev = result.data + if prev == nil then + result.data = payload + else + pb.codec.merge_message(M.TestAllTypesProto2_Data_descriptor, prev, payload) + end + elseif id == 204 then + local payload + payload, pos = pb.codec.decode_group(M.TestAllTypesProto2_MultiWordGroupField_descriptor, buf, pos, 204) + local prev = result.multiwordgroupfield + if prev == nil then + result.multiwordgroupfield = payload + else + pb.codec.merge_message(M.TestAllTypesProto2_MultiWordGroupField_descriptor, prev, payload) + end + elseif id == 241 then + local val + val, pos = wire.decode_int32(buf, pos) + result.default_int32 = val + elseif id == 242 then + local val + val, pos = wire.decode_int64(buf, pos) + result.default_int64 = val + elseif id == 243 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.default_uint32 = val + elseif id == 244 then + local val + val, pos = wire.decode_uint64(buf, pos) + result.default_uint64 = val + elseif id == 245 then + local val + val, pos = wire.decode_sint32(buf, pos) + result.default_sint32 = val + elseif id == 246 then + local val + val, pos = wire.decode_sint64(buf, pos) + result.default_sint64 = val + elseif id == 247 then + local val + val, pos = wire.decode_fixed32(buf, pos) + result.default_fixed32 = val + elseif id == 248 then + local val + val, pos = wire.decode_fixed64(buf, pos) + result.default_fixed64 = val + elseif id == 249 then + local val + val, pos = wire.decode_sfixed32(buf, pos) + result.default_sfixed32 = val + elseif id == 250 then + local val + val, pos = wire.decode_sfixed64(buf, pos) + result.default_sfixed64 = val + elseif id == 251 then + local val + val, pos = wire.decode_float(buf, pos) + result.default_float = val + elseif id == 252 then + local val + val, pos = wire.decode_double(buf, pos) + result.default_double = val + elseif id == 253 then + local val + val, pos = wire.decode_bool(buf, pos) + result.default_bool = val + elseif id == 254 then + local val + val, pos = wire.decode_string(buf, pos) + result.default_string = val + elseif id == 255 then + local val + val, pos = wire.decode_bytes(buf, pos) + result.default_bytes = val + elseif id == 401 then + local val + val, pos = wire.decode_int32(buf, pos) + result.fieldname1 = val + elseif id == 402 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field_name2 = val + elseif id == 403 then + local val + val, pos = wire.decode_int32(buf, pos) + result._field_name3 = val + elseif id == 404 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field__name4_ = val + elseif id == 405 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field0name5 = val + elseif id == 406 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field_0_name6 = val + elseif id == 407 then + local val + val, pos = wire.decode_int32(buf, pos) + result.fieldName7 = val + elseif id == 408 then + local val + val, pos = wire.decode_int32(buf, pos) + result.FieldName8 = val + elseif id == 409 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field_Name9 = val + elseif id == 410 then + local val + val, pos = wire.decode_int32(buf, pos) + result.Field_Name10 = val + elseif id == 411 then + local val + val, pos = wire.decode_int32(buf, pos) + result.FIELD_NAME11 = val + elseif id == 412 then + local val + val, pos = wire.decode_int32(buf, pos) + result.FIELD_name12 = val + elseif id == 413 then + local val + val, pos = wire.decode_int32(buf, pos) + result.__field_name13 = val + elseif id == 414 then + local val + val, pos = wire.decode_int32(buf, pos) + result.__Field_name14 = val + elseif id == 415 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field__name15 = val + elseif id == 416 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field__Name16 = val + elseif id == 417 then + local val + val, pos = wire.decode_int32(buf, pos) + result.field_name17__ = val + elseif id == 418 then + local val + val, pos = wire.decode_int32(buf, pos) + result.Field_name18__ = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_int32(t) return t.optional_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_int32(t) t.optional_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_int64(t) return t.optional_int64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_int64(t) t.optional_int64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_uint32(t) return t.optional_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_uint32(t) t.optional_uint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_uint64(t) return t.optional_uint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_uint64(t) t.optional_uint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sint32(t) return t.optional_sint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sint32(t) t.optional_sint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sint64(t) return t.optional_sint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sint64(t) t.optional_sint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_fixed32(t) return t.optional_fixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_fixed32(t) t.optional_fixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_fixed64(t) return t.optional_fixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_fixed64(t) t.optional_fixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sfixed32(t) return t.optional_sfixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sfixed32(t) t.optional_sfixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sfixed64(t) return t.optional_sfixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sfixed64(t) t.optional_sfixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_float(t) return t.optional_float ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_float(t) t.optional_float = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_double(t) return t.optional_double ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_double(t) t.optional_double = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_bool(t) return t.optional_bool ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_bool(t) t.optional_bool = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_string(t) return t.optional_string ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_string(t) t.optional_string = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_bytes(t) return t.optional_bytes ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_bytes(t) t.optional_bytes = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_nested_message(t) return t.optional_nested_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_nested_message(t) t.optional_nested_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_foreign_message(t) return t.optional_foreign_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_foreign_message(t) t.optional_foreign_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_nested_enum(t) return t.optional_nested_enum ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_nested_enum(t) t.optional_nested_enum = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_foreign_enum(t) return t.optional_foreign_enum ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_foreign_enum(t) t.optional_foreign_enum = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_string_piece(t) return t.optional_string_piece ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_string_piece(t) t.optional_string_piece = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_cord(t) return t.optional_cord ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_cord(t) t.optional_cord = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_recursive_message(t) return t.recursive_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_recursive_message(t) t.recursive_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_data(t) return t.data ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_data(t) t.data = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_multiwordgroupfield(t) return t.multiwordgroupfield ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_multiwordgroupfield(t) t.multiwordgroupfield = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_int32(t) return t.default_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_int32(t) t.default_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_int64(t) return t.default_int64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_int64(t) t.default_int64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_uint32(t) return t.default_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_uint32(t) t.default_uint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_uint64(t) return t.default_uint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_uint64(t) t.default_uint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sint32(t) return t.default_sint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sint32(t) t.default_sint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sint64(t) return t.default_sint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sint64(t) t.default_sint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_fixed32(t) return t.default_fixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_fixed32(t) t.default_fixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_fixed64(t) return t.default_fixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_fixed64(t) t.default_fixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sfixed32(t) return t.default_sfixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sfixed32(t) t.default_sfixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sfixed64(t) return t.default_sfixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sfixed64(t) t.default_sfixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_float(t) return t.default_float ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_float(t) t.default_float = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_double(t) return t.default_double ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_double(t) t.default_double = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_bool(t) return t.default_bool ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_bool(t) t.default_bool = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_string(t) return t.default_string ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_string(t) t.default_string = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_bytes(t) return t.default_bytes ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_bytes(t) t.default_bytes = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_fieldname1(t) return t.fieldname1 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_fieldname1(t) t.fieldname1 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_name2(t) return t.field_name2 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_name2(t) t.field_name2 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has__field_name3(t) return t._field_name3 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear__field_name3(t) t._field_name3 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__name4_(t) return t.field__name4_ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__name4_(t) t.field__name4_ = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field0name5(t) return t.field0name5 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field0name5(t) t.field0name5 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_0_name6(t) return t.field_0_name6 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_0_name6(t) t.field_0_name6 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_fieldName7(t) return t.fieldName7 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_fieldName7(t) t.fieldName7 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FieldName8(t) return t.FieldName8 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FieldName8(t) t.FieldName8 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_Name9(t) return t.field_Name9 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_Name9(t) t.field_Name9 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_Field_Name10(t) return t.Field_Name10 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_Field_Name10(t) t.Field_Name10 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FIELD_NAME11(t) return t.FIELD_NAME11 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FIELD_NAME11(t) t.FIELD_NAME11 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FIELD_name12(t) return t.FIELD_name12 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FIELD_name12(t) t.FIELD_name12 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has___field_name13(t) return t.__field_name13 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear___field_name13(t) t.__field_name13 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has___Field_name14(t) return t.__Field_name14 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear___Field_name14(t) t.__Field_name14 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__name15(t) return t.field__name15 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__name15(t) t.field__name15 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__Name16(t) return t.field__Name16 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__Name16(t) t.field__Name16 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_name17__(t) return t.field_name17__ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_name17__(t) t.field_name17__ = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_Field_name18__(t) return t.Field_name18__ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_Field_name18__(t) t.Field_name18__ = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return string +function M.TestAllTypesProto2_NestedMessage_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: a + v = t.a + if v ~= nil then + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 2: corecursive + v = t.corecursive + if v ~= nil or type(v) == 'cdata' then + local _b = M.TestAllTypesProto2_encode(v) + n = n + 1; out[n] = "\x12" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.a = val + elseif id == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.corecursive + if prev == nil then + result.corecursive = M.TestAllTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllTypesProto2_descriptor, prev, M.TestAllTypesProto2_decode(payload)) + end + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_NestedMessage_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_NestedMessage_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_NestedMessage_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_NestedMessage_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return boolean +function M.TestAllTypesProto2_NestedMessage_has_a(t) return t.a ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_clear_a(t) t.a = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return boolean +function M.TestAllTypesProto2_NestedMessage_has_corecursive(t) return t.corecursive ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_clear_corecursive(t) t.corecursive = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return string +function M.TestAllTypesProto2_Data_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllTypesProto2.Data, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 202: group_int32 + v = t.group_int32 + if v ~= nil then + n = n + 1; out[n] = "\xd0\x0c" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 203: group_uint32 + v = t.group_uint32 + if v ~= nil then + n = n + 1; out[n] = "\xd8\x0c" + n = n + 1; out[n] = wire.encode_uint32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllTypesProto2.Data decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 202 then + local val + val, pos = wire.decode_int32(buf, pos) + result.group_int32 = val + elseif id == 203 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.group_uint32 = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_Data_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_Data_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_Data_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_Data_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return boolean +function M.TestAllTypesProto2_Data_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return boolean +function M.TestAllTypesProto2_Data_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return string +function M.TestAllTypesProto2_MultiWordGroupField_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 205: group_int32 + v = t.group_int32 + if v ~= nil then + n = n + 1; out[n] = "\xe8\x0c" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 206: group_uint32 + v = t.group_uint32 + if v ~= nil then + n = n + 1; out[n] = "\xf0\x0c" + n = n + 1; out[n] = wire.encode_uint32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 205 then + local val + val, pos = wire.decode_int32(buf, pos) + result.group_int32 = val + elseif id == 206 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.group_uint32 = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_MultiWordGroupField_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_MultiWordGroupField_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_MultiWordGroupField_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_MultiWordGroupField_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return boolean +function M.TestAllTypesProto2_MultiWordGroupField_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return boolean +function M.TestAllTypesProto2_MultiWordGroupField_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.ForeignMessageProto2 +---@return protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@return string +function M.ForeignMessageProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.ForeignMessageProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: c + v = t.c + if v ~= nil then + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.ForeignMessageProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.c = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.ForeignMessageProto2_decode_lazy(b) return pb.decode_lazy(M.ForeignMessageProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.ForeignMessageProto2_text(t, opts) return pb.text.encode(M.ForeignMessageProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@return boolean +function M.ForeignMessageProto2_has_c(t) return t.c ~= nil end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_clear_c(t) t.c = nil end + +---@param t? protobuf_test_messages.proto2.GroupField +---@return protobuf_test_messages.proto2.GroupField +function M.GroupField_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.GroupField +---@return string +function M.GroupField_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.GroupField, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 122: group_int32 + v = t.group_int32 + if v ~= nil then + n = n + 1; out[n] = "\xd0\x07" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 123: group_uint32 + v = t.group_uint32 + if v ~= nil then + n = n + 1; out[n] = "\xd8\x07" + n = n + 1; out[n] = wire.encode_uint32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.GroupField +function M.GroupField_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.GroupField decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 122 then + local val + val, pos = wire.decode_int32(buf, pos) + result.group_int32 = val + elseif id == 123 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.group_uint32 = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.GroupField_decode_lazy(b) return pb.decode_lazy(M.GroupField_descriptor, b) end +---@param t protobuf_test_messages.proto2.GroupField +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.GroupField_text(t, opts) return pb.text.encode(M.GroupField_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.GroupField +---@return boolean +function M.GroupField_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.GroupField +function M.GroupField_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.GroupField +---@return boolean +function M.GroupField_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.GroupField +function M.GroupField_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return string +function M.UnknownToTestAllTypes_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.UnknownToTestAllTypes, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1001: optional_int32 + v = t.optional_int32 + if v ~= nil then + n = n + 1; out[n] = "\xc8\x3e" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 1002: optional_string + v = t.optional_string + if v ~= nil then + n = n + 1; out[n] = "\xd2\x3e" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 1003: nested_message + v = t.nested_message + if v ~= nil or type(v) == 'cdata' then + local _b = M.ForeignMessageProto2_encode(v) + n = n + 1; out[n] = "\xda\x3e" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 1004: optionalgroup + v = t.optionalgroup + if v ~= nil or type(v) == 'cdata' then + n = n + 1; out[n] = "\xe3\x3e" + n = n + 1; out[n] = M.UnknownToTestAllTypes_OptionalGroup_encode(v) + n = n + 1; out[n] = "\xe4\x3e" + end + -- field 1006: optional_bool + v = t.optional_bool + if v ~= nil then + n = n + 1; out[n] = "\xf0\x3e" + n = n + 1; out[n] = wire.encode_bool(v) + end + -- field 1011: repeated_int32 + v = t.repeated_int32 + if v ~= nil and #v > 0 then + local _tag = "\x98\x3f" + for _i = 1, #v do + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_int32(v[_i]) + end + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.UnknownToTestAllTypes decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1001 then + local val + val, pos = wire.decode_int32(buf, pos) + result.optional_int32 = val + elseif id == 1002 then + local val + val, pos = wire.decode_string(buf, pos) + result.optional_string = val + elseif id == 1003 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.nested_message + if prev == nil then + result.nested_message = M.ForeignMessageProto2_decode(payload) + else + pb.codec.merge_message(M.ForeignMessageProto2_descriptor, prev, M.ForeignMessageProto2_decode(payload)) + end + elseif id == 1004 then + local payload + payload, pos = pb.codec.decode_group(M.UnknownToTestAllTypes_OptionalGroup_descriptor, buf, pos, 1004) + local prev = result.optionalgroup + if prev == nil then + result.optionalgroup = payload + else + pb.codec.merge_message(M.UnknownToTestAllTypes_OptionalGroup_descriptor, prev, payload) + end + elseif id == 1006 then + local val + val, pos = wire.decode_bool(buf, pos) + result.optional_bool = val + elseif id == 1011 then + local list = result.repeated_int32 + if list == nil then list = {}; result.repeated_int32 = list end + if wt == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local p2, lim = 1, #payload + while p2 <= lim do + local val + val, p2 = wire.decode_int32(payload, p2) + list[#list + 1] = val + end + else + local val + val, pos = wire.decode_int32(buf, pos) + list[#list + 1] = val + end + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.UnknownToTestAllTypes_decode_lazy(b) return pb.decode_lazy(M.UnknownToTestAllTypes_descriptor, b) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.UnknownToTestAllTypes_text(t, opts) return pb.text.encode(M.UnknownToTestAllTypes_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_int32(t) return t.optional_int32 ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_int32(t) t.optional_int32 = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_string(t) return t.optional_string ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_string(t) t.optional_string = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_nested_message(t) return t.nested_message ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_nested_message(t) t.nested_message = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optionalgroup(t) return t.optionalgroup ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optionalgroup(t) t.optionalgroup = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_bool(t) return t.optional_bool ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_bool(t) t.optional_bool = nil end + +---@param t? protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return string +function M.UnknownToTestAllTypes_OptionalGroup_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: a + v = t.a + if v ~= nil then + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.a = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.UnknownToTestAllTypes_OptionalGroup_decode_lazy(b) return pb.decode_lazy(M.UnknownToTestAllTypes_OptionalGroup_descriptor, b) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.UnknownToTestAllTypes_OptionalGroup_text(t, opts) return pb.text.encode(M.UnknownToTestAllTypes_OptionalGroup_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return boolean +function M.UnknownToTestAllTypes_OptionalGroup_has_a(t) return t.a ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_clear_a(t) t.a = nil end + +---@param t? protobuf_test_messages.proto2.NullHypothesisProto2 +---@return protobuf_test_messages.proto2.NullHypothesisProto2 +function M.NullHypothesisProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.NullHypothesisProto2 +---@return string +function M.NullHypothesisProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.NullHypothesisProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.NullHypothesisProto2 +function M.NullHypothesisProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.NullHypothesisProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.NullHypothesisProto2_decode_lazy(b) return pb.decode_lazy(M.NullHypothesisProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.NullHypothesisProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.NullHypothesisProto2_text(t, opts) return pb.text.encode(M.NullHypothesisProto2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.EnumOnlyProto2 +---@return protobuf_test_messages.proto2.EnumOnlyProto2 +function M.EnumOnlyProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.EnumOnlyProto2 +---@return string +function M.EnumOnlyProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.EnumOnlyProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.EnumOnlyProto2 +function M.EnumOnlyProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.EnumOnlyProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.EnumOnlyProto2_decode_lazy(b) return pb.decode_lazy(M.EnumOnlyProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.EnumOnlyProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.EnumOnlyProto2_text(t, opts) return pb.text.encode(M.EnumOnlyProto2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.OneStringProto2 +---@return protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@return string +function M.OneStringProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.OneStringProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: data + v = t.data + if v ~= nil then + n = n + 1; out[n] = "\x0a" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.OneStringProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_string(buf, pos) + result.data = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.OneStringProto2_decode_lazy(b) return pb.decode_lazy(M.OneStringProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.OneStringProto2_text(t, opts) return pb.text.encode(M.OneStringProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@return boolean +function M.OneStringProto2_has_data(t) return t.data ~= nil end +---@param t protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_clear_data(t) t.data = nil end + +---@param t? protobuf_test_messages.proto2.ProtoWithKeywords +---@return protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return string +function M.ProtoWithKeywords_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.ProtoWithKeywords, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: inline + v = t.inline + if v ~= nil then + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + end + -- field 2: concept + v = t.concept + if v ~= nil then + n = n + 1; out[n] = "\x12" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + end + -- field 3: requires + v = t.requires + if v ~= nil and #v > 0 then + local _tag = "\x1a" + for _i = 1, #v do + local _b = v[_i] + n = n + 1; out[n] = _tag + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.ProtoWithKeywords decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.inline = val + elseif id == 2 then + local val + val, pos = wire.decode_string(buf, pos) + result.concept = val + elseif id == 3 then + local list = result.requires + if list == nil then list = {}; result.requires = list end + local val + val, pos = wire.decode_string(buf, pos) + list[#list + 1] = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.ProtoWithKeywords_decode_lazy(b) return pb.decode_lazy(M.ProtoWithKeywords_descriptor, b) end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.ProtoWithKeywords_text(t, opts) return pb.text.encode(M.ProtoWithKeywords_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return boolean +function M.ProtoWithKeywords_has_inline(t) return t.inline ~= nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_clear_inline(t) t.inline = nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return boolean +function M.ProtoWithKeywords_has_concept(t) return t.concept ~= nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_clear_concept(t) t.concept = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return string +function M.TestAllRequiredTypesProto2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllRequiredTypesProto2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: required_int32 + v = t.required_int32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_int32", 0) + end + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + -- field 2: required_int64 + v = t.required_int64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_int64", 0) + end + n = n + 1; out[n] = "\x10" + n = n + 1; out[n] = wire.encode_int64(v) + -- field 3: required_uint32 + v = t.required_uint32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_uint32", 0) + end + n = n + 1; out[n] = "\x18" + n = n + 1; out[n] = wire.encode_uint32(v) + -- field 4: required_uint64 + v = t.required_uint64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_uint64", 0) + end + n = n + 1; out[n] = "\x20" + n = n + 1; out[n] = wire.encode_uint64(v) + -- field 5: required_sint32 + v = t.required_sint32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_sint32", 0) + end + n = n + 1; out[n] = "\x28" + n = n + 1; out[n] = wire.encode_sint32(v) + -- field 6: required_sint64 + v = t.required_sint64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_sint64", 0) + end + n = n + 1; out[n] = "\x30" + n = n + 1; out[n] = wire.encode_sint64(v) + -- field 7: required_fixed32 + v = t.required_fixed32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_fixed32", 0) + end + n = n + 1; out[n] = "\x3d" + n = n + 1; out[n] = wire.encode_fixed32(v) + -- field 8: required_fixed64 + v = t.required_fixed64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_fixed64", 0) + end + n = n + 1; out[n] = "\x41" + n = n + 1; out[n] = wire.encode_fixed64(v) + -- field 9: required_sfixed32 + v = t.required_sfixed32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_sfixed32", 0) + end + n = n + 1; out[n] = "\x4d" + n = n + 1; out[n] = wire.encode_sfixed32(v) + -- field 10: required_sfixed64 + v = t.required_sfixed64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_sfixed64", 0) + end + n = n + 1; out[n] = "\x51" + n = n + 1; out[n] = wire.encode_sfixed64(v) + -- field 11: required_float + v = t.required_float + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_float", 0) + end + n = n + 1; out[n] = "\x5d" + n = n + 1; out[n] = wire.encode_float(v) + -- field 12: required_double + v = t.required_double + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_double", 0) + end + n = n + 1; out[n] = "\x61" + n = n + 1; out[n] = wire.encode_double(v) + -- field 13: required_bool + v = t.required_bool + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_bool", 0) + end + n = n + 1; out[n] = "\x68" + n = n + 1; out[n] = wire.encode_bool(v) + -- field 14: required_string + v = t.required_string + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_string", 0) + end + n = n + 1; out[n] = "\x72" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + -- field 15: required_bytes + v = t.required_bytes + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_bytes", 0) + end + n = n + 1; out[n] = "\x7a" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + -- field 18: required_nested_message + v = t.required_nested_message + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_nested_message", 0) + end + local _b = M.TestAllRequiredTypesProto2_NestedMessage_encode(v) + n = n + 1; out[n] = "\x92\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + -- field 19: required_foreign_message + v = t.required_foreign_message + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_foreign_message", 0) + end + local _b = M.ForeignMessageProto2_encode(v) + n = n + 1; out[n] = "\x9a\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + -- field 21: required_nested_enum + v = t.required_nested_enum + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_nested_enum", 0) + end + do + local nv = v + if type(v) == 'string' then + nv = M.TestAllRequiredTypesProto2_NestedEnum[v] + if nv == nil then error("unknown enum value '" .. v .. "' for protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum", 0) end + end + n = n + 1; out[n] = "\xa8\x01" + n = n + 1; out[n] = wire.encode_int32(nv) + end + -- field 22: required_foreign_enum + v = t.required_foreign_enum + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_foreign_enum", 0) + end + do + local nv = v + if type(v) == 'string' then + nv = M.ForeignEnumProto2[v] + if nv == nil then error("unknown enum value '" .. v .. "' for protobuf_test_messages.proto2.ForeignEnumProto2", 0) end + end + n = n + 1; out[n] = "\xb0\x01" + n = n + 1; out[n] = wire.encode_int32(nv) + end + -- field 24: required_string_piece + v = t.required_string_piece + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_string_piece", 0) + end + n = n + 1; out[n] = "\xc2\x01" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + -- field 25: required_cord + v = t.required_cord + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.required_cord", 0) + end + n = n + 1; out[n] = "\xca\x01" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + -- field 27: recursive_message + v = t.recursive_message + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.recursive_message", 0) + end + local _b = M.TestAllRequiredTypesProto2_encode(v) + n = n + 1; out[n] = "\xda\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + -- field 28: optional_recursive_message + v = t.optional_recursive_message + if v ~= nil or type(v) == 'cdata' then + local _b = M.TestAllRequiredTypesProto2_encode(v) + n = n + 1; out[n] = "\xe2\x01" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 201: data + v = t.data + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.data", 0) + end + local _b = M.TestAllRequiredTypesProto2_Data_encode(v) + n = n + 1; out[n] = "\xcb\x0c" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + -- field 241: default_int32 + v = t.default_int32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_int32", 0) + end + n = n + 1; out[n] = "\x88\x0f" + n = n + 1; out[n] = wire.encode_int32(v) + -- field 242: default_int64 + v = t.default_int64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_int64", 0) + end + n = n + 1; out[n] = "\x90\x0f" + n = n + 1; out[n] = wire.encode_int64(v) + -- field 243: default_uint32 + v = t.default_uint32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_uint32", 0) + end + n = n + 1; out[n] = "\x98\x0f" + n = n + 1; out[n] = wire.encode_uint32(v) + -- field 244: default_uint64 + v = t.default_uint64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_uint64", 0) + end + n = n + 1; out[n] = "\xa0\x0f" + n = n + 1; out[n] = wire.encode_uint64(v) + -- field 245: default_sint32 + v = t.default_sint32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_sint32", 0) + end + n = n + 1; out[n] = "\xa8\x0f" + n = n + 1; out[n] = wire.encode_sint32(v) + -- field 246: default_sint64 + v = t.default_sint64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_sint64", 0) + end + n = n + 1; out[n] = "\xb0\x0f" + n = n + 1; out[n] = wire.encode_sint64(v) + -- field 247: default_fixed32 + v = t.default_fixed32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_fixed32", 0) + end + n = n + 1; out[n] = "\xbd\x0f" + n = n + 1; out[n] = wire.encode_fixed32(v) + -- field 248: default_fixed64 + v = t.default_fixed64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_fixed64", 0) + end + n = n + 1; out[n] = "\xc1\x0f" + n = n + 1; out[n] = wire.encode_fixed64(v) + -- field 249: default_sfixed32 + v = t.default_sfixed32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_sfixed32", 0) + end + n = n + 1; out[n] = "\xcd\x0f" + n = n + 1; out[n] = wire.encode_sfixed32(v) + -- field 250: default_sfixed64 + v = t.default_sfixed64 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_sfixed64", 0) + end + n = n + 1; out[n] = "\xd1\x0f" + n = n + 1; out[n] = wire.encode_sfixed64(v) + -- field 251: default_float + v = t.default_float + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_float", 0) + end + n = n + 1; out[n] = "\xdd\x0f" + n = n + 1; out[n] = wire.encode_float(v) + -- field 252: default_double + v = t.default_double + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_double", 0) + end + n = n + 1; out[n] = "\xe1\x0f" + n = n + 1; out[n] = wire.encode_double(v) + -- field 253: default_bool + v = t.default_bool + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_bool", 0) + end + n = n + 1; out[n] = "\xe8\x0f" + n = n + 1; out[n] = wire.encode_bool(v) + -- field 254: default_string + v = t.default_string + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_string", 0) + end + n = n + 1; out[n] = "\xf2\x0f" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + -- field 255: default_bytes + v = t.default_bytes + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.default_bytes", 0) + end + n = n + 1; out[n] = "\xfa\x0f" + n = n + 1; out[n] = wire.encode_varint(#v) + n = n + 1; out[n] = v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllRequiredTypesProto2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.required_int32 = val + elseif id == 2 then + local val + val, pos = wire.decode_int64(buf, pos) + result.required_int64 = val + elseif id == 3 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.required_uint32 = val + elseif id == 4 then + local val + val, pos = wire.decode_uint64(buf, pos) + result.required_uint64 = val + elseif id == 5 then + local val + val, pos = wire.decode_sint32(buf, pos) + result.required_sint32 = val + elseif id == 6 then + local val + val, pos = wire.decode_sint64(buf, pos) + result.required_sint64 = val + elseif id == 7 then + local val + val, pos = wire.decode_fixed32(buf, pos) + result.required_fixed32 = val + elseif id == 8 then + local val + val, pos = wire.decode_fixed64(buf, pos) + result.required_fixed64 = val + elseif id == 9 then + local val + val, pos = wire.decode_sfixed32(buf, pos) + result.required_sfixed32 = val + elseif id == 10 then + local val + val, pos = wire.decode_sfixed64(buf, pos) + result.required_sfixed64 = val + elseif id == 11 then + local val + val, pos = wire.decode_float(buf, pos) + result.required_float = val + elseif id == 12 then + local val + val, pos = wire.decode_double(buf, pos) + result.required_double = val + elseif id == 13 then + local val + val, pos = wire.decode_bool(buf, pos) + result.required_bool = val + elseif id == 14 then + local val + val, pos = wire.decode_string(buf, pos) + result.required_string = val + elseif id == 15 then + local val + val, pos = wire.decode_bytes(buf, pos) + result.required_bytes = val + elseif id == 18 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.required_nested_message + if prev == nil then + result.required_nested_message = M.TestAllRequiredTypesProto2_NestedMessage_decode(payload) + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, prev, M.TestAllRequiredTypesProto2_NestedMessage_decode(payload)) + end + elseif id == 19 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.required_foreign_message + if prev == nil then + result.required_foreign_message = M.ForeignMessageProto2_decode(payload) + else + pb.codec.merge_message(M.ForeignMessageProto2_descriptor, prev, M.ForeignMessageProto2_decode(payload)) + end + elseif id == 21 then + local u + u, pos = wire.decode_varint(buf, pos) + result.required_nested_enum = wire.varint_to_int32(u) + elseif id == 22 then + local u + u, pos = wire.decode_varint(buf, pos) + result.required_foreign_enum = wire.varint_to_int32(u) + elseif id == 24 then + local val + val, pos = wire.decode_string(buf, pos) + result.required_string_piece = val + elseif id == 25 then + local val + val, pos = wire.decode_string(buf, pos) + result.required_cord = val + elseif id == 27 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.recursive_message + if prev == nil then + result.recursive_message = M.TestAllRequiredTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_descriptor, prev, M.TestAllRequiredTypesProto2_decode(payload)) + end + elseif id == 28 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.optional_recursive_message + if prev == nil then + result.optional_recursive_message = M.TestAllRequiredTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_descriptor, prev, M.TestAllRequiredTypesProto2_decode(payload)) + end + elseif id == 201 then + local payload + payload, pos = pb.codec.decode_group(M.TestAllRequiredTypesProto2_Data_descriptor, buf, pos, 201) + local prev = result.data + if prev == nil then + result.data = payload + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_Data_descriptor, prev, payload) + end + elseif id == 241 then + local val + val, pos = wire.decode_int32(buf, pos) + result.default_int32 = val + elseif id == 242 then + local val + val, pos = wire.decode_int64(buf, pos) + result.default_int64 = val + elseif id == 243 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.default_uint32 = val + elseif id == 244 then + local val + val, pos = wire.decode_uint64(buf, pos) + result.default_uint64 = val + elseif id == 245 then + local val + val, pos = wire.decode_sint32(buf, pos) + result.default_sint32 = val + elseif id == 246 then + local val + val, pos = wire.decode_sint64(buf, pos) + result.default_sint64 = val + elseif id == 247 then + local val + val, pos = wire.decode_fixed32(buf, pos) + result.default_fixed32 = val + elseif id == 248 then + local val + val, pos = wire.decode_fixed64(buf, pos) + result.default_fixed64 = val + elseif id == 249 then + local val + val, pos = wire.decode_sfixed32(buf, pos) + result.default_sfixed32 = val + elseif id == 250 then + local val + val, pos = wire.decode_sfixed64(buf, pos) + result.default_sfixed64 = val + elseif id == 251 then + local val + val, pos = wire.decode_float(buf, pos) + result.default_float = val + elseif id == 252 then + local val + val, pos = wire.decode_double(buf, pos) + result.default_double = val + elseif id == 253 then + local val + val, pos = wire.decode_bool(buf, pos) + result.default_bool = val + elseif id == 254 then + local val + val, pos = wire.decode_string(buf, pos) + result.default_string = val + elseif id == 255 then + local val + val, pos = wire.decode_bytes(buf, pos) + result.default_bytes = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return boolean +function M.TestAllRequiredTypesProto2_has_optional_recursive_message(t) return t.optional_recursive_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_clear_optional_recursive_message(t) t.optional_recursive_message = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return string +function M.TestAllRequiredTypesProto2_NestedMessage_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 1: a + v = t.a + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage.a", 0) + end + n = n + 1; out[n] = "\x08" + n = n + 1; out[n] = wire.encode_int32(v) + -- field 2: corecursive + v = t.corecursive + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage.corecursive", 0) + end + local _b = M.TestAllRequiredTypesProto2_encode(v) + n = n + 1; out[n] = "\x12" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + -- field 3: optional_corecursive + v = t.optional_corecursive + if v ~= nil or type(v) == 'cdata' then + local _b = M.TestAllRequiredTypesProto2_encode(v) + n = n + 1; out[n] = "\x1a" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local val + val, pos = wire.decode_int32(buf, pos) + result.a = val + elseif id == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.corecursive + if prev == nil then + result.corecursive = M.TestAllRequiredTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_descriptor, prev, M.TestAllRequiredTypesProto2_decode(payload)) + end + elseif id == 3 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.optional_corecursive + if prev == nil then + result.optional_corecursive = M.TestAllRequiredTypesProto2_decode(payload) + else + pb.codec.merge_message(M.TestAllRequiredTypesProto2_descriptor, prev, M.TestAllRequiredTypesProto2_decode(payload)) + end + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_NestedMessage_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_NestedMessage_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return boolean +function M.TestAllRequiredTypesProto2_NestedMessage_has_optional_corecursive(t) return t.optional_corecursive ~= nil end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_clear_optional_corecursive(t) t.optional_corecursive = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +function M.TestAllRequiredTypesProto2_Data_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@return string +function M.TestAllRequiredTypesProto2_Data_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + -- field 202: group_int32 + v = t.group_int32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data.group_int32", 0) + end + n = n + 1; out[n] = "\xd0\x0c" + n = n + 1; out[n] = wire.encode_int32(v) + -- field 203: group_uint32 + v = t.group_uint32 + if v == nil then + error("required field missing on encode: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data.group_uint32", 0) + end + n = n + 1; out[n] = "\xd8\x0c" + n = n + 1; out[n] = wire.encode_uint32(v) + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +function M.TestAllRequiredTypesProto2_Data_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 202 then + local val + val, pos = wire.decode_int32(buf, pos) + result.group_int32 = val + elseif id == 203 then + local val + val, pos = wire.decode_uint32(buf, pos) + result.group_uint32 = val + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_Data_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_Data_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_Data_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_Data_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof +---@return protobuf_test_messages.proto2.TestLargeOneof +function M.TestLargeOneof_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof +---@return string +function M.TestLargeOneof_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _of_large_oneof + if t.a1 ~= nil then _of_large_oneof = "a1" end + if t.a2 ~= nil then _of_large_oneof = "a2" end + if t.a3 ~= nil then _of_large_oneof = "a3" end + if t.a4 ~= nil then _of_large_oneof = "a4" end + if t.a5 ~= nil then _of_large_oneof = "a5" end + -- field 1: a1 + v = t.a1 + if _of_large_oneof == "a1" then + local _b = M.TestLargeOneof_A1_encode(v) + n = n + 1; out[n] = "\x0a" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 2: a2 + v = t.a2 + if _of_large_oneof == "a2" then + local _b = M.TestLargeOneof_A2_encode(v) + n = n + 1; out[n] = "\x12" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 3: a3 + v = t.a3 + if _of_large_oneof == "a3" then + local _b = M.TestLargeOneof_A3_encode(v) + n = n + 1; out[n] = "\x1a" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 4: a4 + v = t.a4 + if _of_large_oneof == "a4" then + local _b = M.TestLargeOneof_A4_encode(v) + n = n + 1; out[n] = "\x22" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + -- field 5: a5 + v = t.a5 + if _of_large_oneof == "a5" then + local _b = M.TestLargeOneof_A5_encode(v) + n = n + 1; out[n] = "\x2a" + n = n + 1; out[n] = wire.encode_varint(#_b) + n = n + 1; out[n] = _b + end + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof +function M.TestLargeOneof_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if id == 1 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.a1 + if prev == nil then + result.a1 = M.TestLargeOneof_A1_decode(payload) + else + pb.codec.merge_message(M.TestLargeOneof_A1_descriptor, prev, M.TestLargeOneof_A1_decode(payload)) + end + result.a2 = nil + result.a3 = nil + result.a4 = nil + result.a5 = nil + elseif id == 2 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.a2 + if prev == nil then + result.a2 = M.TestLargeOneof_A2_decode(payload) + else + pb.codec.merge_message(M.TestLargeOneof_A2_descriptor, prev, M.TestLargeOneof_A2_decode(payload)) + end + result.a1 = nil + result.a3 = nil + result.a4 = nil + result.a5 = nil + elseif id == 3 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.a3 + if prev == nil then + result.a3 = M.TestLargeOneof_A3_decode(payload) + else + pb.codec.merge_message(M.TestLargeOneof_A3_descriptor, prev, M.TestLargeOneof_A3_decode(payload)) + end + result.a1 = nil + result.a2 = nil + result.a4 = nil + result.a5 = nil + elseif id == 4 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.a4 + if prev == nil then + result.a4 = M.TestLargeOneof_A4_decode(payload) + else + pb.codec.merge_message(M.TestLargeOneof_A4_descriptor, prev, M.TestLargeOneof_A4_decode(payload)) + end + result.a1 = nil + result.a2 = nil + result.a3 = nil + result.a5 = nil + elseif id == 5 then + local payload + payload, pos = wire.decode_len(buf, pos) + local prev = result.a5 + if prev == nil then + result.a5 = M.TestLargeOneof_A5_decode(payload) + else + pb.codec.merge_message(M.TestLargeOneof_A5_descriptor, prev, M.TestLargeOneof_A5_decode(payload)) + end + result.a1 = nil + result.a2 = nil + result.a3 = nil + result.a4 = nil + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_text(t, opts) return pb.text.encode(M.TestLargeOneof_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A1 +---@return protobuf_test_messages.proto2.TestLargeOneof.A1 +function M.TestLargeOneof_A1_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof.A1 +---@return string +function M.TestLargeOneof_A1_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof.A1, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A1 +function M.TestLargeOneof_A1_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof.A1 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A1_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A1_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A1 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A1_text(t, opts) return pb.text.encode(M.TestLargeOneof_A1_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A2 +---@return protobuf_test_messages.proto2.TestLargeOneof.A2 +function M.TestLargeOneof_A2_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof.A2 +---@return string +function M.TestLargeOneof_A2_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof.A2, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A2 +function M.TestLargeOneof_A2_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof.A2 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A2_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A2_text(t, opts) return pb.text.encode(M.TestLargeOneof_A2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A3 +---@return protobuf_test_messages.proto2.TestLargeOneof.A3 +function M.TestLargeOneof_A3_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof.A3 +---@return string +function M.TestLargeOneof_A3_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof.A3, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A3 +function M.TestLargeOneof_A3_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof.A3 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A3_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A3_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A3 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A3_text(t, opts) return pb.text.encode(M.TestLargeOneof_A3_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A4 +---@return protobuf_test_messages.proto2.TestLargeOneof.A4 +function M.TestLargeOneof_A4_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof.A4 +---@return string +function M.TestLargeOneof_A4_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof.A4, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A4 +function M.TestLargeOneof_A4_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof.A4 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A4_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A4_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A4 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A4_text(t, opts) return pb.text.encode(M.TestLargeOneof_A4_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A5 +---@return protobuf_test_messages.proto2.TestLargeOneof.A5 +function M.TestLargeOneof_A5_new(t) return t or {} end + +---@param t protobuf_test_messages.proto2.TestLargeOneof.A5 +---@return string +function M.TestLargeOneof_A5_encode(t) + if type(t) ~= 'table' then + error("expected table for protobuf_test_messages.proto2.TestLargeOneof.A5, got " .. type(t), 0) + end + local out, n = {}, 0 + local v + local _uf = t._unknown_fields + if _uf ~= nil and _uf ~= '' then n = n + 1; out[n] = _uf end + return table.concat(out) +end + +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A5 +function M.TestLargeOneof_A5_decode(buf) + if type(buf) ~= 'string' then + error("expected string for protobuf_test_messages.proto2.TestLargeOneof.A5 decode, got " .. type(buf), 0) + end + local result = {} + local pos, len = 1, #buf + local _uf + while pos <= len do + local _tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if true then + else + pos = wire.skip_field(buf, pos, wt, id) + if _uf == nil then _uf = {} end + _uf[#_uf + 1] = buf:sub(_tag_start, pos - 1) + end + end + if _uf ~= nil then result._unknown_fields = table.concat(_uf) end + return result +end + +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A5_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A5_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A5 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A5_text(t, opts) return pb.text.encode(M.TestLargeOneof_A5_descriptor, t, opts) end + +return M diff --git a/examples/expected/runtime/proto2_basic/proto2_basic_pb.lua b/examples/expected/runtime/proto2_basic/proto2_basic_pb.lua index c776efc6ee61dc6420fa50303385950f9805a634..7100d8420cf41f9939bda04747a86ab1df51dd77 100644 --- a/examples/expected/runtime/proto2_basic/proto2_basic_pb.lua +++ b/examples/expected/runtime/proto2_basic/proto2_basic_pb.lua @@ -23,6 +23,9 @@ M.Defaults_descriptor = {name = "proto2_basic.Defaults"} M.Cardinality_descriptor = {name = "proto2_basic.Cardinality"} M.Nested_descriptor = {name = "proto2_basic.Nested"} M.Nested_Inner_descriptor = {name = "proto2_basic.Nested.Inner"} +M.WithGroup_descriptor = {name = "proto2_basic.WithGroup"} +M.WithGroup_SingleGroup_descriptor = {name = "proto2_basic.WithGroup.SingleGroup"} +M.WithGroup_RepGroup_descriptor = {name = "proto2_basic.WithGroup.RepGroup"} -- Message: proto2_basic.Defaults M.Defaults_descriptor.fields = { @@ -86,6 +89,37 @@ M.Nested_Inner_fields = pb.field_names({ x = "x", }) +-- Message: proto2_basic.WithGroup +M.WithGroup_descriptor.fields = { + {name="singlegroup", id=1, kind='group', message=M.WithGroup_SingleGroup_descriptor, optional=true}, + {name="repgroup", id=4, kind='group', message=M.WithGroup_RepGroup_descriptor, repeated=true}, +} +pb.finalize_message(M.WithGroup_descriptor) +M.WithGroup_fields = pb.field_names({ + singlegroup = "singlegroup", + repgroup = "repgroup", +}) + +-- Message: proto2_basic.WithGroup.SingleGroup +M.WithGroup_SingleGroup_descriptor.fields = { + {name="a", id=2, kind='scalar', proto_type="int32", optional=true}, + {name="s", id=3, kind='scalar', proto_type="string", optional=true}, +} +pb.finalize_message(M.WithGroup_SingleGroup_descriptor) +M.WithGroup_SingleGroup_fields = pb.field_names({ + a = "a", + s = "s", +}) + +-- Message: proto2_basic.WithGroup.RepGroup +M.WithGroup_RepGroup_descriptor.fields = { + {name="n", id=5, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.WithGroup_RepGroup_descriptor) +M.WithGroup_RepGroup_fields = pb.field_names({ + n = "n", +}) + -- EmmyLua / lua-language-server type annotations. -- These are comments — no runtime effect. They give editors -- autocomplete and type-checking for the generated wrappers. @@ -116,6 +150,19 @@ M.Nested_Inner_fields = pb.field_names({ ---@class proto2_basic.Nested.Inner ---@field x integer +--- Proto2 legacy groups. Wire format uses SGROUP (3) / EGROUP (4) tag +--- pairs instead of a length-prefixed message body. +---@class proto2_basic.WithGroup +---@field singlegroup? proto2_basic.WithGroup.SingleGroup +---@field repgroup proto2_basic.WithGroup.RepGroup[] + +---@class proto2_basic.WithGroup.SingleGroup +---@field a? integer +---@field s? string + +---@class proto2_basic.WithGroup.RepGroup +---@field n? integer + ---@param t? proto2_basic.Defaults ---@return proto2_basic.Defaults function M.Defaults_new(t) return t or {} end @@ -239,4 +286,75 @@ function M.Nested_Inner_decode_lazy(b) return pb.decode_lazy(M.Nested_Inner_desc ---@return string function M.Nested_Inner_text(t, opts) return pb.text.encode(M.Nested_Inner_descriptor, t, opts) end +---@param t? proto2_basic.WithGroup +---@return proto2_basic.WithGroup +function M.WithGroup_new(t) return t or {} end +---@param t proto2_basic.WithGroup +---@return string +function M.WithGroup_encode(t) return pb.encode(M.WithGroup_descriptor, t) end +---@param b string +---@return proto2_basic.WithGroup +function M.WithGroup_decode(b) return pb.decode(M.WithGroup_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.WithGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_descriptor, b) end +---@param t proto2_basic.WithGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_text(t, opts) return pb.text.encode(M.WithGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup +---@return boolean +function M.WithGroup_has_singlegroup(t) return t.singlegroup ~= nil end +---@param t proto2_basic.WithGroup +function M.WithGroup_clear_singlegroup(t) t.singlegroup = nil end + +---@param t? proto2_basic.WithGroup.SingleGroup +---@return proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_new(t) return t or {} end +---@param t proto2_basic.WithGroup.SingleGroup +---@return string +function M.WithGroup_SingleGroup_encode(t) return pb.encode(M.WithGroup_SingleGroup_descriptor, t) end +---@param b string +---@return proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_decode(b) return pb.decode(M.WithGroup_SingleGroup_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.WithGroup_SingleGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_SingleGroup_descriptor, b) end +---@param t proto2_basic.WithGroup.SingleGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_SingleGroup_text(t, opts) return pb.text.encode(M.WithGroup_SingleGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup.SingleGroup +---@return boolean +function M.WithGroup_SingleGroup_has_a(t) return t.a ~= nil end +---@param t proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_clear_a(t) t.a = nil end +---@param t proto2_basic.WithGroup.SingleGroup +---@return boolean +function M.WithGroup_SingleGroup_has_s(t) return t.s ~= nil end +---@param t proto2_basic.WithGroup.SingleGroup +function M.WithGroup_SingleGroup_clear_s(t) t.s = nil end + +---@param t? proto2_basic.WithGroup.RepGroup +---@return proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_new(t) return t or {} end +---@param t proto2_basic.WithGroup.RepGroup +---@return string +function M.WithGroup_RepGroup_encode(t) return pb.encode(M.WithGroup_RepGroup_descriptor, t) end +---@param b string +---@return proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_decode(b) return pb.decode(M.WithGroup_RepGroup_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.WithGroup_RepGroup_decode_lazy(b) return pb.decode_lazy(M.WithGroup_RepGroup_descriptor, b) end +---@param t proto2_basic.WithGroup.RepGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.WithGroup_RepGroup_text(t, opts) return pb.text.encode(M.WithGroup_RepGroup_descriptor, t, opts) end +---@param t proto2_basic.WithGroup.RepGroup +---@return boolean +function M.WithGroup_RepGroup_has_n(t) return t.n ~= nil end +---@param t proto2_basic.WithGroup.RepGroup +function M.WithGroup_RepGroup_clear_n(t) t.n = nil end + return M diff --git a/examples/expected/runtime/protobuf_test_messages/proto2/test_messages_proto2_pb.lua b/examples/expected/runtime/protobuf_test_messages/proto2/test_messages_proto2_pb.lua new file mode 100644 index 0000000000000000000000000000000000000000..4d577b04c34678f69224e5248a37237436160ae2 --- /dev/null +++ b/examples/expected/runtime/protobuf_test_messages/proto2/test_messages_proto2_pb.lua @@ -0,0 +1,1633 @@ +-- Code generated by protoc-gen-tarantool. DO NOT EDIT. +-- source: test_messages_proto2.proto +-- syntax: proto2 +-- package: protobuf_test_messages.proto2 + +local pb = require("pb") +local wire = pb.wire + +local M = {} + +M.options = {cc_enable_arenas = true, go_package = "tarantoolpb_synthetic/test_messages_proto2", java_package = "com.google.protobuf_test_messages.proto2", objc_class_prefix = "Proto2", optimize_for = "SPEED"} + +-- Enum: protobuf_test_messages.proto2.ForeignEnumProto2 +M.ForeignEnumProto2_descriptor = pb.enum("protobuf_test_messages.proto2.ForeignEnumProto2", { + FOREIGN_FOO = 0, + FOREIGN_BAR = 1, + FOREIGN_BAZ = 2, +}) +M.ForeignEnumProto2 = M.ForeignEnumProto2_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +M.TestAllTypesProto2_NestedEnum_descriptor = pb.enum("protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum", { + FOO = 0, + BAR = 1, + BAZ = 2, + NEG = -1, +}) +M.TestAllTypesProto2_NestedEnum = M.TestAllTypesProto2_NestedEnum_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.EnumOnlyProto2.Bool +M.EnumOnlyProto2_Bool_descriptor = pb.enum("protobuf_test_messages.proto2.EnumOnlyProto2.Bool", { + kFalse = 0, + kTrue = 1, +}) +M.EnumOnlyProto2_Bool = M.EnumOnlyProto2_Bool_descriptor.by_name + +-- Enum: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum +M.TestAllRequiredTypesProto2_NestedEnum_descriptor = pb.enum("protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum", { + FOO = 0, + BAR = 1, + BAZ = 2, + NEG = -1, +}) +M.TestAllRequiredTypesProto2_NestedEnum = M.TestAllRequiredTypesProto2_NestedEnum_descriptor.by_name + +-- Pre-declare message descriptors so cross-references resolve. +M.TestAllTypesProto2_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2"} +M.TestAllTypesProto2_NestedMessage_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage"} +M.TestAllTypesProto2_Data_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.Data"} +M.TestAllTypesProto2_MultiWordGroupField_descriptor = {name = "protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField"} +M.ForeignMessageProto2_descriptor = {name = "protobuf_test_messages.proto2.ForeignMessageProto2"} +M.GroupField_descriptor = {name = "protobuf_test_messages.proto2.GroupField"} +M.UnknownToTestAllTypes_descriptor = {name = "protobuf_test_messages.proto2.UnknownToTestAllTypes"} +M.UnknownToTestAllTypes_OptionalGroup_descriptor = {name = "protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup"} +M.NullHypothesisProto2_descriptor = {name = "protobuf_test_messages.proto2.NullHypothesisProto2"} +M.EnumOnlyProto2_descriptor = {name = "protobuf_test_messages.proto2.EnumOnlyProto2"} +M.OneStringProto2_descriptor = {name = "protobuf_test_messages.proto2.OneStringProto2"} +M.ProtoWithKeywords_descriptor = {name = "protobuf_test_messages.proto2.ProtoWithKeywords"} +M.TestAllRequiredTypesProto2_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2"} +M.TestAllRequiredTypesProto2_NestedMessage_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage"} +M.TestAllRequiredTypesProto2_Data_descriptor = {name = "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data"} +M.TestLargeOneof_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof"} +M.TestLargeOneof_A1_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A1"} +M.TestLargeOneof_A2_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A2"} +M.TestLargeOneof_A3_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A3"} +M.TestLargeOneof_A4_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A4"} +M.TestLargeOneof_A5_descriptor = {name = "protobuf_test_messages.proto2.TestLargeOneof.A5"} + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2 +M.TestAllTypesProto2_descriptor.fields = { + {name="optional_int32", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="optional_int64", id=2, kind='scalar', proto_type="int64", optional=true}, + {name="optional_uint32", id=3, kind='scalar', proto_type="uint32", optional=true}, + {name="optional_uint64", id=4, kind='scalar', proto_type="uint64", optional=true}, + {name="optional_sint32", id=5, kind='scalar', proto_type="sint32", optional=true}, + {name="optional_sint64", id=6, kind='scalar', proto_type="sint64", optional=true}, + {name="optional_fixed32", id=7, kind='scalar', proto_type="fixed32", optional=true}, + {name="optional_fixed64", id=8, kind='scalar', proto_type="fixed64", optional=true}, + {name="optional_sfixed32", id=9, kind='scalar', proto_type="sfixed32", optional=true}, + {name="optional_sfixed64", id=10, kind='scalar', proto_type="sfixed64", optional=true}, + {name="optional_float", id=11, kind='scalar', proto_type="float", optional=true}, + {name="optional_double", id=12, kind='scalar', proto_type="double", optional=true}, + {name="optional_bool", id=13, kind='scalar', proto_type="bool", optional=true}, + {name="optional_string", id=14, kind='scalar', proto_type="string", optional=true}, + {name="optional_bytes", id=15, kind='scalar', proto_type="bytes", optional=true}, + {name="optional_nested_message", id=18, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, optional=true}, + {name="optional_foreign_message", id=19, kind='message', message=M.ForeignMessageProto2_descriptor, optional=true}, + {name="optional_nested_enum", id=21, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, optional=true}, + {name="optional_foreign_enum", id=22, kind='enum', enum=M.ForeignEnumProto2_descriptor, optional=true}, + {name="optional_string_piece", id=24, kind='scalar', proto_type="string", optional=true, options={ctype = "STRING_PIECE"}}, + {name="optional_cord", id=25, kind='scalar', proto_type="string", optional=true, options={ctype = "CORD"}}, + {name="recursive_message", id=27, kind='message', message=M.TestAllTypesProto2_descriptor, optional=true}, + {name="repeated_int32", id=31, kind='scalar', proto_type="int32", repeated=true, packed=false}, + {name="repeated_int64", id=32, kind='scalar', proto_type="int64", repeated=true, packed=false}, + {name="repeated_uint32", id=33, kind='scalar', proto_type="uint32", repeated=true, packed=false}, + {name="repeated_uint64", id=34, kind='scalar', proto_type="uint64", repeated=true, packed=false}, + {name="repeated_sint32", id=35, kind='scalar', proto_type="sint32", repeated=true, packed=false}, + {name="repeated_sint64", id=36, kind='scalar', proto_type="sint64", repeated=true, packed=false}, + {name="repeated_fixed32", id=37, kind='scalar', proto_type="fixed32", repeated=true, packed=false}, + {name="repeated_fixed64", id=38, kind='scalar', proto_type="fixed64", repeated=true, packed=false}, + {name="repeated_sfixed32", id=39, kind='scalar', proto_type="sfixed32", repeated=true, packed=false}, + {name="repeated_sfixed64", id=40, kind='scalar', proto_type="sfixed64", repeated=true, packed=false}, + {name="repeated_float", id=41, kind='scalar', proto_type="float", repeated=true, packed=false}, + {name="repeated_double", id=42, kind='scalar', proto_type="double", repeated=true, packed=false}, + {name="repeated_bool", id=43, kind='scalar', proto_type="bool", repeated=true, packed=false}, + {name="repeated_string", id=44, kind='scalar', proto_type="string", repeated=true}, + {name="repeated_bytes", id=45, kind='scalar', proto_type="bytes", repeated=true}, + {name="repeated_nested_message", id=48, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, repeated=true}, + {name="repeated_foreign_message", id=49, kind='message', message=M.ForeignMessageProto2_descriptor, repeated=true}, + {name="repeated_nested_enum", id=51, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=false}, + {name="repeated_foreign_enum", id=52, kind='enum', enum=M.ForeignEnumProto2_descriptor, repeated=true, packed=false}, + {name="repeated_string_piece", id=54, kind='scalar', proto_type="string", repeated=true, options={ctype = "STRING_PIECE"}}, + {name="repeated_cord", id=55, kind='scalar', proto_type="string", repeated=true, options={ctype = "CORD"}}, + {name="packed_int32", id=75, kind='scalar', proto_type="int32", repeated=true, packed=true, options={packed = true}}, + {name="packed_int64", id=76, kind='scalar', proto_type="int64", repeated=true, packed=true, options={packed = true}}, + {name="packed_uint32", id=77, kind='scalar', proto_type="uint32", repeated=true, packed=true, options={packed = true}}, + {name="packed_uint64", id=78, kind='scalar', proto_type="uint64", repeated=true, packed=true, options={packed = true}}, + {name="packed_sint32", id=79, kind='scalar', proto_type="sint32", repeated=true, packed=true, options={packed = true}}, + {name="packed_sint64", id=80, kind='scalar', proto_type="sint64", repeated=true, packed=true, options={packed = true}}, + {name="packed_fixed32", id=81, kind='scalar', proto_type="fixed32", repeated=true, packed=true, options={packed = true}}, + {name="packed_fixed64", id=82, kind='scalar', proto_type="fixed64", repeated=true, packed=true, options={packed = true}}, + {name="packed_sfixed32", id=83, kind='scalar', proto_type="sfixed32", repeated=true, packed=true, options={packed = true}}, + {name="packed_sfixed64", id=84, kind='scalar', proto_type="sfixed64", repeated=true, packed=true, options={packed = true}}, + {name="packed_float", id=85, kind='scalar', proto_type="float", repeated=true, packed=true, options={packed = true}}, + {name="packed_double", id=86, kind='scalar', proto_type="double", repeated=true, packed=true, options={packed = true}}, + {name="packed_bool", id=87, kind='scalar', proto_type="bool", repeated=true, packed=true, options={packed = true}}, + {name="packed_nested_enum", id=88, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=true, options={packed = true}}, + {name="unpacked_int32", id=89, kind='scalar', proto_type="int32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_int64", id=90, kind='scalar', proto_type="int64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_uint32", id=91, kind='scalar', proto_type="uint32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_uint64", id=92, kind='scalar', proto_type="uint64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sint32", id=93, kind='scalar', proto_type="sint32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sint64", id=94, kind='scalar', proto_type="sint64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_fixed32", id=95, kind='scalar', proto_type="fixed32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_fixed64", id=96, kind='scalar', proto_type="fixed64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sfixed32", id=97, kind='scalar', proto_type="sfixed32", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_sfixed64", id=98, kind='scalar', proto_type="sfixed64", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_float", id=99, kind='scalar', proto_type="float", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_double", id=100, kind='scalar', proto_type="double", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_bool", id=101, kind='scalar', proto_type="bool", repeated=true, packed=false, options={packed = false}}, + {name="unpacked_nested_enum", id=102, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, repeated=true, packed=false, options={packed = false}}, + {name="map_int32_int32", id=56, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="int32"}}, + {name="map_int64_int64", id=57, kind='map', key={kind='scalar', proto_type="int64"}, value={kind='scalar', proto_type="int64"}}, + {name="map_uint32_uint32", id=58, kind='map', key={kind='scalar', proto_type="uint32"}, value={kind='scalar', proto_type="uint32"}}, + {name="map_uint64_uint64", id=59, kind='map', key={kind='scalar', proto_type="uint64"}, value={kind='scalar', proto_type="uint64"}}, + {name="map_sint32_sint32", id=60, kind='map', key={kind='scalar', proto_type="sint32"}, value={kind='scalar', proto_type="sint32"}}, + {name="map_sint64_sint64", id=61, kind='map', key={kind='scalar', proto_type="sint64"}, value={kind='scalar', proto_type="sint64"}}, + {name="map_fixed32_fixed32", id=62, kind='map', key={kind='scalar', proto_type="fixed32"}, value={kind='scalar', proto_type="fixed32"}}, + {name="map_fixed64_fixed64", id=63, kind='map', key={kind='scalar', proto_type="fixed64"}, value={kind='scalar', proto_type="fixed64"}}, + {name="map_sfixed32_sfixed32", id=64, kind='map', key={kind='scalar', proto_type="sfixed32"}, value={kind='scalar', proto_type="sfixed32"}}, + {name="map_sfixed64_sfixed64", id=65, kind='map', key={kind='scalar', proto_type="sfixed64"}, value={kind='scalar', proto_type="sfixed64"}}, + {name="map_int32_bool", id=104, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="bool"}}, + {name="map_int32_float", id=66, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="float"}}, + {name="map_int32_double", id=67, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='scalar', proto_type="double"}}, + {name="map_int32_nested_message", id=103, kind='map', key={kind='scalar', proto_type="int32"}, value={kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor}}, + {name="map_bool_bool", id=68, kind='map', key={kind='scalar', proto_type="bool"}, value={kind='scalar', proto_type="bool"}}, + {name="map_string_string", id=69, kind='map', key={kind='scalar', proto_type="string"}, value={kind='scalar', proto_type="string"}}, + {name="map_string_bytes", id=70, kind='map', key={kind='scalar', proto_type="string"}, value={kind='scalar', proto_type="bytes"}}, + {name="map_string_nested_message", id=71, kind='map', key={kind='scalar', proto_type="string"}, value={kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor}}, + {name="map_string_foreign_message", id=72, kind='map', key={kind='scalar', proto_type="string"}, value={kind='message', message=M.ForeignMessageProto2_descriptor}}, + {name="map_string_nested_enum", id=73, kind='map', key={kind='scalar', proto_type="string"}, value={kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor}}, + {name="map_string_foreign_enum", id=74, kind='map', key={kind='scalar', proto_type="string"}, value={kind='enum', enum=M.ForeignEnumProto2_descriptor}}, + {name="oneof_uint32", id=111, kind='scalar', proto_type="uint32", oneof="oneof_field"}, + {name="oneof_nested_message", id=112, kind='message', message=M.TestAllTypesProto2_NestedMessage_descriptor, oneof="oneof_field"}, + {name="oneof_string", id=113, kind='scalar', proto_type="string", oneof="oneof_field"}, + {name="oneof_bytes", id=114, kind='scalar', proto_type="bytes", oneof="oneof_field"}, + {name="oneof_bool", id=115, kind='scalar', proto_type="bool", oneof="oneof_field"}, + {name="oneof_uint64", id=116, kind='scalar', proto_type="uint64", oneof="oneof_field"}, + {name="oneof_float", id=117, kind='scalar', proto_type="float", oneof="oneof_field"}, + {name="oneof_double", id=118, kind='scalar', proto_type="double", oneof="oneof_field"}, + {name="oneof_enum", id=119, kind='enum', enum=M.TestAllTypesProto2_NestedEnum_descriptor, oneof="oneof_field"}, + {name="data", id=201, kind='group', message=M.TestAllTypesProto2_Data_descriptor, optional=true}, + {name="multiwordgroupfield", id=204, kind='group', message=M.TestAllTypesProto2_MultiWordGroupField_descriptor, optional=true}, + {name="default_int32", id=241, kind='scalar', proto_type="int32", optional=true, default_value=-123456789}, + {name="default_int64", id=242, kind='scalar', proto_type="int64", optional=true, default_value=-9123456789123456789LL}, + {name="default_uint32", id=243, kind='scalar', proto_type="uint32", optional=true, default_value=2123456789}, + {name="default_uint64", id=244, kind='scalar', proto_type="uint64", optional=true, default_value=10123456789123456789ULL}, + {name="default_sint32", id=245, kind='scalar', proto_type="sint32", optional=true, default_value=-123456789}, + {name="default_sint64", id=246, kind='scalar', proto_type="sint64", optional=true, default_value=-9123456789123456789LL}, + {name="default_fixed32", id=247, kind='scalar', proto_type="fixed32", optional=true, default_value=2123456789}, + {name="default_fixed64", id=248, kind='scalar', proto_type="fixed64", optional=true, default_value=10123456789123456789ULL}, + {name="default_sfixed32", id=249, kind='scalar', proto_type="sfixed32", optional=true, default_value=-123456789}, + {name="default_sfixed64", id=250, kind='scalar', proto_type="sfixed64", optional=true, default_value=-9123456789123456789LL}, + {name="default_float", id=251, kind='scalar', proto_type="float", optional=true, default_value=8.999999488e+09}, + {name="default_double", id=252, kind='scalar', proto_type="double", optional=true, default_value=7e+22}, + {name="default_bool", id=253, kind='scalar', proto_type="bool", optional=true, default_value=true}, + {name="default_string", id=254, kind='scalar', proto_type="string", optional=true, default_value="Rosebud"}, + {name="default_bytes", id=255, kind='scalar', proto_type="bytes", optional=true, default_value="\x6a\x6f\x73\x68\x75\x61"}, + {name="fieldname1", id=401, kind='scalar', proto_type="int32", optional=true}, + {name="field_name2", id=402, kind='scalar', proto_type="int32", optional=true}, + {name="_field_name3", id=403, kind='scalar', proto_type="int32", optional=true}, + {name="field__name4_", id=404, kind='scalar', proto_type="int32", optional=true}, + {name="field0name5", id=405, kind='scalar', proto_type="int32", optional=true}, + {name="field_0_name6", id=406, kind='scalar', proto_type="int32", optional=true}, + {name="fieldName7", id=407, kind='scalar', proto_type="int32", optional=true}, + {name="FieldName8", id=408, kind='scalar', proto_type="int32", optional=true}, + {name="field_Name9", id=409, kind='scalar', proto_type="int32", optional=true}, + {name="Field_Name10", id=410, kind='scalar', proto_type="int32", optional=true}, + {name="FIELD_NAME11", id=411, kind='scalar', proto_type="int32", optional=true}, + {name="FIELD_name12", id=412, kind='scalar', proto_type="int32", optional=true}, + {name="__field_name13", id=413, kind='scalar', proto_type="int32", optional=true}, + {name="__Field_name14", id=414, kind='scalar', proto_type="int32", optional=true}, + {name="field__name15", id=415, kind='scalar', proto_type="int32", optional=true}, + {name="field__Name16", id=416, kind='scalar', proto_type="int32", optional=true}, + {name="field_name17__", id=417, kind='scalar', proto_type="int32", optional=true}, + {name="Field_name18__", id=418, kind='scalar', proto_type="int32", optional=true}, +} +M.TestAllTypesProto2_descriptor.oneofs = { + oneof_field = {"oneof_uint32", "oneof_nested_message", "oneof_string", "oneof_bytes", "oneof_bool", "oneof_uint64", "oneof_float", "oneof_double", "oneof_enum"}, +} +M.TestAllTypesProto2_descriptor.reserved_names = { + ["reserved_field"] = true, +} +pb.finalize_message(M.TestAllTypesProto2_descriptor) +M.TestAllTypesProto2_fields = pb.field_names({ + optional_int32 = "optional_int32", + optional_int64 = "optional_int64", + optional_uint32 = "optional_uint32", + optional_uint64 = "optional_uint64", + optional_sint32 = "optional_sint32", + optional_sint64 = "optional_sint64", + optional_fixed32 = "optional_fixed32", + optional_fixed64 = "optional_fixed64", + optional_sfixed32 = "optional_sfixed32", + optional_sfixed64 = "optional_sfixed64", + optional_float = "optional_float", + optional_double = "optional_double", + optional_bool = "optional_bool", + optional_string = "optional_string", + optional_bytes = "optional_bytes", + optional_nested_message = "optional_nested_message", + optional_foreign_message = "optional_foreign_message", + optional_nested_enum = "optional_nested_enum", + optional_foreign_enum = "optional_foreign_enum", + optional_string_piece = "optional_string_piece", + optional_cord = "optional_cord", + recursive_message = "recursive_message", + repeated_int32 = "repeated_int32", + repeated_int64 = "repeated_int64", + repeated_uint32 = "repeated_uint32", + repeated_uint64 = "repeated_uint64", + repeated_sint32 = "repeated_sint32", + repeated_sint64 = "repeated_sint64", + repeated_fixed32 = "repeated_fixed32", + repeated_fixed64 = "repeated_fixed64", + repeated_sfixed32 = "repeated_sfixed32", + repeated_sfixed64 = "repeated_sfixed64", + repeated_float = "repeated_float", + repeated_double = "repeated_double", + repeated_bool = "repeated_bool", + repeated_string = "repeated_string", + repeated_bytes = "repeated_bytes", + repeated_nested_message = "repeated_nested_message", + repeated_foreign_message = "repeated_foreign_message", + repeated_nested_enum = "repeated_nested_enum", + repeated_foreign_enum = "repeated_foreign_enum", + repeated_string_piece = "repeated_string_piece", + repeated_cord = "repeated_cord", + packed_int32 = "packed_int32", + packed_int64 = "packed_int64", + packed_uint32 = "packed_uint32", + packed_uint64 = "packed_uint64", + packed_sint32 = "packed_sint32", + packed_sint64 = "packed_sint64", + packed_fixed32 = "packed_fixed32", + packed_fixed64 = "packed_fixed64", + packed_sfixed32 = "packed_sfixed32", + packed_sfixed64 = "packed_sfixed64", + packed_float = "packed_float", + packed_double = "packed_double", + packed_bool = "packed_bool", + packed_nested_enum = "packed_nested_enum", + unpacked_int32 = "unpacked_int32", + unpacked_int64 = "unpacked_int64", + unpacked_uint32 = "unpacked_uint32", + unpacked_uint64 = "unpacked_uint64", + unpacked_sint32 = "unpacked_sint32", + unpacked_sint64 = "unpacked_sint64", + unpacked_fixed32 = "unpacked_fixed32", + unpacked_fixed64 = "unpacked_fixed64", + unpacked_sfixed32 = "unpacked_sfixed32", + unpacked_sfixed64 = "unpacked_sfixed64", + unpacked_float = "unpacked_float", + unpacked_double = "unpacked_double", + unpacked_bool = "unpacked_bool", + unpacked_nested_enum = "unpacked_nested_enum", + map_int32_int32 = "map_int32_int32", + map_int64_int64 = "map_int64_int64", + map_uint32_uint32 = "map_uint32_uint32", + map_uint64_uint64 = "map_uint64_uint64", + map_sint32_sint32 = "map_sint32_sint32", + map_sint64_sint64 = "map_sint64_sint64", + map_fixed32_fixed32 = "map_fixed32_fixed32", + map_fixed64_fixed64 = "map_fixed64_fixed64", + map_sfixed32_sfixed32 = "map_sfixed32_sfixed32", + map_sfixed64_sfixed64 = "map_sfixed64_sfixed64", + map_int32_bool = "map_int32_bool", + map_int32_float = "map_int32_float", + map_int32_double = "map_int32_double", + map_int32_nested_message = "map_int32_nested_message", + map_bool_bool = "map_bool_bool", + map_string_string = "map_string_string", + map_string_bytes = "map_string_bytes", + map_string_nested_message = "map_string_nested_message", + map_string_foreign_message = "map_string_foreign_message", + map_string_nested_enum = "map_string_nested_enum", + map_string_foreign_enum = "map_string_foreign_enum", + oneof_uint32 = "oneof_uint32", + oneof_nested_message = "oneof_nested_message", + oneof_string = "oneof_string", + oneof_bytes = "oneof_bytes", + oneof_bool = "oneof_bool", + oneof_uint64 = "oneof_uint64", + oneof_float = "oneof_float", + oneof_double = "oneof_double", + oneof_enum = "oneof_enum", + data = "data", + multiwordgroupfield = "multiwordgroupfield", + default_int32 = "default_int32", + default_int64 = "default_int64", + default_uint32 = "default_uint32", + default_uint64 = "default_uint64", + default_sint32 = "default_sint32", + default_sint64 = "default_sint64", + default_fixed32 = "default_fixed32", + default_fixed64 = "default_fixed64", + default_sfixed32 = "default_sfixed32", + default_sfixed64 = "default_sfixed64", + default_float = "default_float", + default_double = "default_double", + default_bool = "default_bool", + default_string = "default_string", + default_bytes = "default_bytes", + fieldname1 = "fieldname1", + field_name2 = "field_name2", + _field_name3 = "_field_name3", + field__name4_ = "field__name4_", + field0name5 = "field0name5", + field_0_name6 = "field_0_name6", + fieldName7 = "fieldName7", + FieldName8 = "FieldName8", + field_Name9 = "field_Name9", + Field_Name10 = "Field_Name10", + FIELD_NAME11 = "FIELD_NAME11", + FIELD_name12 = "FIELD_name12", + __field_name13 = "__field_name13", + __Field_name14 = "__Field_name14", + field__name15 = "field__name15", + field__Name16 = "field__Name16", + field_name17__ = "field_name17__", + Field_name18__ = "Field_name18__", +}) +M.TestAllTypesProto2_oneofs = pb.field_names({ + oneof_field = "oneof_field", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +M.TestAllTypesProto2_NestedMessage_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="corecursive", id=2, kind='message', message=M.TestAllTypesProto2_descriptor, optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_NestedMessage_descriptor) +M.TestAllTypesProto2_NestedMessage_fields = pb.field_names({ + a = "a", + corecursive = "corecursive", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.Data +M.TestAllTypesProto2_Data_descriptor.fields = { + {name="group_int32", id=202, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=203, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_Data_descriptor) +M.TestAllTypesProto2_Data_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +M.TestAllTypesProto2_MultiWordGroupField_descriptor.fields = { + {name="group_int32", id=205, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=206, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.TestAllTypesProto2_MultiWordGroupField_descriptor) +M.TestAllTypesProto2_MultiWordGroupField_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.ForeignMessageProto2 +M.ForeignMessageProto2_descriptor.fields = { + {name="c", id=1, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.ForeignMessageProto2_descriptor) +M.ForeignMessageProto2_fields = pb.field_names({ + c = "c", +}) + +-- Message: protobuf_test_messages.proto2.GroupField +M.GroupField_descriptor.fields = { + {name="group_int32", id=122, kind='scalar', proto_type="int32", optional=true}, + {name="group_uint32", id=123, kind='scalar', proto_type="uint32", optional=true}, +} +pb.finalize_message(M.GroupField_descriptor) +M.GroupField_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.UnknownToTestAllTypes +M.UnknownToTestAllTypes_descriptor.fields = { + {name="optional_int32", id=1001, kind='scalar', proto_type="int32", optional=true}, + {name="optional_string", id=1002, kind='scalar', proto_type="string", optional=true}, + {name="nested_message", id=1003, kind='message', message=M.ForeignMessageProto2_descriptor, optional=true}, + {name="optionalgroup", id=1004, kind='group', message=M.UnknownToTestAllTypes_OptionalGroup_descriptor, optional=true}, + {name="optional_bool", id=1006, kind='scalar', proto_type="bool", optional=true}, + {name="repeated_int32", id=1011, kind='scalar', proto_type="int32", repeated=true, packed=false}, +} +pb.finalize_message(M.UnknownToTestAllTypes_descriptor) +M.UnknownToTestAllTypes_fields = pb.field_names({ + optional_int32 = "optional_int32", + optional_string = "optional_string", + nested_message = "nested_message", + optionalgroup = "optionalgroup", + optional_bool = "optional_bool", + repeated_int32 = "repeated_int32", +}) + +-- Message: protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +M.UnknownToTestAllTypes_OptionalGroup_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", optional=true}, +} +pb.finalize_message(M.UnknownToTestAllTypes_OptionalGroup_descriptor) +M.UnknownToTestAllTypes_OptionalGroup_fields = pb.field_names({ + a = "a", +}) + +-- Message: protobuf_test_messages.proto2.NullHypothesisProto2 +M.NullHypothesisProto2_descriptor.fields = { +} +pb.finalize_message(M.NullHypothesisProto2_descriptor) + +-- Message: protobuf_test_messages.proto2.EnumOnlyProto2 +M.EnumOnlyProto2_descriptor.fields = { +} +pb.finalize_message(M.EnumOnlyProto2_descriptor) + +-- Message: protobuf_test_messages.proto2.OneStringProto2 +M.OneStringProto2_descriptor.fields = { + {name="data", id=1, kind='scalar', proto_type="string", optional=true}, +} +pb.finalize_message(M.OneStringProto2_descriptor) +M.OneStringProto2_fields = pb.field_names({ + data = "data", +}) + +-- Message: protobuf_test_messages.proto2.ProtoWithKeywords +M.ProtoWithKeywords_descriptor.fields = { + {name="inline", id=1, kind='scalar', proto_type="int32", optional=true}, + {name="concept", id=2, kind='scalar', proto_type="string", optional=true}, + {name="requires", id=3, kind='scalar', proto_type="string", repeated=true}, +} +pb.finalize_message(M.ProtoWithKeywords_descriptor) +M.ProtoWithKeywords_fields = pb.field_names({ + inline = "inline", + concept = "concept", + requires = "requires", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +M.TestAllRequiredTypesProto2_descriptor.fields = { + {name="required_int32", id=1, kind='scalar', proto_type="int32", required=true}, + {name="required_int64", id=2, kind='scalar', proto_type="int64", required=true}, + {name="required_uint32", id=3, kind='scalar', proto_type="uint32", required=true}, + {name="required_uint64", id=4, kind='scalar', proto_type="uint64", required=true}, + {name="required_sint32", id=5, kind='scalar', proto_type="sint32", required=true}, + {name="required_sint64", id=6, kind='scalar', proto_type="sint64", required=true}, + {name="required_fixed32", id=7, kind='scalar', proto_type="fixed32", required=true}, + {name="required_fixed64", id=8, kind='scalar', proto_type="fixed64", required=true}, + {name="required_sfixed32", id=9, kind='scalar', proto_type="sfixed32", required=true}, + {name="required_sfixed64", id=10, kind='scalar', proto_type="sfixed64", required=true}, + {name="required_float", id=11, kind='scalar', proto_type="float", required=true}, + {name="required_double", id=12, kind='scalar', proto_type="double", required=true}, + {name="required_bool", id=13, kind='scalar', proto_type="bool", required=true}, + {name="required_string", id=14, kind='scalar', proto_type="string", required=true}, + {name="required_bytes", id=15, kind='scalar', proto_type="bytes", required=true}, + {name="required_nested_message", id=18, kind='message', message=M.TestAllRequiredTypesProto2_NestedMessage_descriptor, required=true}, + {name="required_foreign_message", id=19, kind='message', message=M.ForeignMessageProto2_descriptor, required=true}, + {name="required_nested_enum", id=21, kind='enum', enum=M.TestAllRequiredTypesProto2_NestedEnum_descriptor, required=true}, + {name="required_foreign_enum", id=22, kind='enum', enum=M.ForeignEnumProto2_descriptor, required=true}, + {name="required_string_piece", id=24, kind='scalar', proto_type="string", required=true, options={ctype = "STRING_PIECE"}}, + {name="required_cord", id=25, kind='scalar', proto_type="string", required=true, options={ctype = "CORD"}}, + {name="recursive_message", id=27, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, required=true}, + {name="optional_recursive_message", id=28, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, optional=true}, + {name="data", id=201, kind='group', message=M.TestAllRequiredTypesProto2_Data_descriptor, required=true}, + {name="default_int32", id=241, kind='scalar', proto_type="int32", required=true, default_value=-123456789}, + {name="default_int64", id=242, kind='scalar', proto_type="int64", required=true, default_value=-9123456789123456789LL}, + {name="default_uint32", id=243, kind='scalar', proto_type="uint32", required=true, default_value=2123456789}, + {name="default_uint64", id=244, kind='scalar', proto_type="uint64", required=true, default_value=10123456789123456789ULL}, + {name="default_sint32", id=245, kind='scalar', proto_type="sint32", required=true, default_value=-123456789}, + {name="default_sint64", id=246, kind='scalar', proto_type="sint64", required=true, default_value=-9123456789123456789LL}, + {name="default_fixed32", id=247, kind='scalar', proto_type="fixed32", required=true, default_value=2123456789}, + {name="default_fixed64", id=248, kind='scalar', proto_type="fixed64", required=true, default_value=10123456789123456789ULL}, + {name="default_sfixed32", id=249, kind='scalar', proto_type="sfixed32", required=true, default_value=-123456789}, + {name="default_sfixed64", id=250, kind='scalar', proto_type="sfixed64", required=true, default_value=-9123456789123456789LL}, + {name="default_float", id=251, kind='scalar', proto_type="float", required=true, default_value=8.999999488e+09}, + {name="default_double", id=252, kind='scalar', proto_type="double", required=true, default_value=7e+22}, + {name="default_bool", id=253, kind='scalar', proto_type="bool", required=true, default_value=true}, + {name="default_string", id=254, kind='scalar', proto_type="string", required=true, default_value="Rosebud"}, + {name="default_bytes", id=255, kind='scalar', proto_type="bytes", required=true, default_value="\x6a\x6f\x73\x68\x75\x61"}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_descriptor) +M.TestAllRequiredTypesProto2_fields = pb.field_names({ + required_int32 = "required_int32", + required_int64 = "required_int64", + required_uint32 = "required_uint32", + required_uint64 = "required_uint64", + required_sint32 = "required_sint32", + required_sint64 = "required_sint64", + required_fixed32 = "required_fixed32", + required_fixed64 = "required_fixed64", + required_sfixed32 = "required_sfixed32", + required_sfixed64 = "required_sfixed64", + required_float = "required_float", + required_double = "required_double", + required_bool = "required_bool", + required_string = "required_string", + required_bytes = "required_bytes", + required_nested_message = "required_nested_message", + required_foreign_message = "required_foreign_message", + required_nested_enum = "required_nested_enum", + required_foreign_enum = "required_foreign_enum", + required_string_piece = "required_string_piece", + required_cord = "required_cord", + recursive_message = "recursive_message", + optional_recursive_message = "optional_recursive_message", + data = "data", + default_int32 = "default_int32", + default_int64 = "default_int64", + default_uint32 = "default_uint32", + default_uint64 = "default_uint64", + default_sint32 = "default_sint32", + default_sint64 = "default_sint64", + default_fixed32 = "default_fixed32", + default_fixed64 = "default_fixed64", + default_sfixed32 = "default_sfixed32", + default_sfixed64 = "default_sfixed64", + default_float = "default_float", + default_double = "default_double", + default_bool = "default_bool", + default_string = "default_string", + default_bytes = "default_bytes", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +M.TestAllRequiredTypesProto2_NestedMessage_descriptor.fields = { + {name="a", id=1, kind='scalar', proto_type="int32", required=true}, + {name="corecursive", id=2, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, required=true}, + {name="optional_corecursive", id=3, kind='message', message=M.TestAllRequiredTypesProto2_descriptor, optional=true}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_NestedMessage_descriptor) +M.TestAllRequiredTypesProto2_NestedMessage_fields = pb.field_names({ + a = "a", + corecursive = "corecursive", + optional_corecursive = "optional_corecursive", +}) + +-- Message: protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +M.TestAllRequiredTypesProto2_Data_descriptor.fields = { + {name="group_int32", id=202, kind='scalar', proto_type="int32", required=true}, + {name="group_uint32", id=203, kind='scalar', proto_type="uint32", required=true}, +} +pb.finalize_message(M.TestAllRequiredTypesProto2_Data_descriptor) +M.TestAllRequiredTypesProto2_Data_fields = pb.field_names({ + group_int32 = "group_int32", + group_uint32 = "group_uint32", +}) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof +M.TestLargeOneof_descriptor.fields = { + {name="a1", id=1, kind='message', message=M.TestLargeOneof_A1_descriptor, oneof="large_oneof"}, + {name="a2", id=2, kind='message', message=M.TestLargeOneof_A2_descriptor, oneof="large_oneof"}, + {name="a3", id=3, kind='message', message=M.TestLargeOneof_A3_descriptor, oneof="large_oneof"}, + {name="a4", id=4, kind='message', message=M.TestLargeOneof_A4_descriptor, oneof="large_oneof"}, + {name="a5", id=5, kind='message', message=M.TestLargeOneof_A5_descriptor, oneof="large_oneof"}, +} +M.TestLargeOneof_descriptor.oneofs = { + large_oneof = {"a1", "a2", "a3", "a4", "a5"}, +} +pb.finalize_message(M.TestLargeOneof_descriptor) +M.TestLargeOneof_fields = pb.field_names({ + a1 = "a1", + a2 = "a2", + a3 = "a3", + a4 = "a4", + a5 = "a5", +}) +M.TestLargeOneof_oneofs = pb.field_names({ + large_oneof = "large_oneof", +}) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A1 +M.TestLargeOneof_A1_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A1_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A2 +M.TestLargeOneof_A2_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A2_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A3 +M.TestLargeOneof_A3_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A3_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A4 +M.TestLargeOneof_A4_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A4_descriptor) + +-- Message: protobuf_test_messages.proto2.TestLargeOneof.A5 +M.TestLargeOneof_A5_descriptor.fields = { +} +pb.finalize_message(M.TestLargeOneof_A5_descriptor) + +-- EmmyLua / lua-language-server type annotations. +-- These are comments — no runtime effect. They give editors +-- autocomplete and type-checking for the generated wrappers. +---@alias protobuf_test_messages.proto2.ForeignEnumProto2 integer +---@alias protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum integer +---@alias protobuf_test_messages.proto2.EnumOnlyProto2.Bool integer +---@alias protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum integer + +--- This proto includes every type of field in both singular and repeated +--- forms. +--- +--- Also, crucially, all messages and enums in this file are eventually +--- submessages of this message. So for example, a fuzz test of TestAllTypes +--- could trigger bugs that occur in any message type in this file. We verify +--- this stays true in a unit test. +---@class protobuf_test_messages.proto2.TestAllTypesProto2 +---@field optional_int32? integer @ Singular +---@field optional_int64? integer +---@field optional_uint32? integer +---@field optional_uint64? integer +---@field optional_sint32? integer +---@field optional_sint64? integer +---@field optional_fixed32? integer +---@field optional_fixed64? integer +---@field optional_sfixed32? integer +---@field optional_sfixed64? integer +---@field optional_float? number +---@field optional_double? number +---@field optional_bool? boolean +---@field optional_string? string +---@field optional_bytes? string +---@field optional_nested_message? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field optional_foreign_message? protobuf_test_messages.proto2.ForeignMessageProto2 +---@field optional_nested_enum? protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +---@field optional_foreign_enum? protobuf_test_messages.proto2.ForeignEnumProto2 +---@field optional_string_piece? string +---@field optional_cord? string +---@field recursive_message? protobuf_test_messages.proto2.TestAllTypesProto2 +---@field repeated_int32 integer[] @ Repeated +---@field repeated_int64 integer[] +---@field repeated_uint32 integer[] +---@field repeated_uint64 integer[] +---@field repeated_sint32 integer[] +---@field repeated_sint64 integer[] +---@field repeated_fixed32 integer[] +---@field repeated_fixed64 integer[] +---@field repeated_sfixed32 integer[] +---@field repeated_sfixed64 integer[] +---@field repeated_float number[] +---@field repeated_double number[] +---@field repeated_bool boolean[] +---@field repeated_string string[] +---@field repeated_bytes string[] +---@field repeated_nested_message protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage[] +---@field repeated_foreign_message protobuf_test_messages.proto2.ForeignMessageProto2[] +---@field repeated_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field repeated_foreign_enum protobuf_test_messages.proto2.ForeignEnumProto2[] +---@field repeated_string_piece string[] +---@field repeated_cord string[] +---@field packed_int32 integer[] @ Packed +---@field packed_int64 integer[] +---@field packed_uint32 integer[] +---@field packed_uint64 integer[] +---@field packed_sint32 integer[] +---@field packed_sint64 integer[] +---@field packed_fixed32 integer[] +---@field packed_fixed64 integer[] +---@field packed_sfixed32 integer[] +---@field packed_sfixed64 integer[] +---@field packed_float number[] +---@field packed_double number[] +---@field packed_bool boolean[] +---@field packed_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field unpacked_int32 integer[] @ Unpacked +---@field unpacked_int64 integer[] +---@field unpacked_uint32 integer[] +---@field unpacked_uint64 integer[] +---@field unpacked_sint32 integer[] +---@field unpacked_sint64 integer[] +---@field unpacked_fixed32 integer[] +---@field unpacked_fixed64 integer[] +---@field unpacked_sfixed32 integer[] +---@field unpacked_sfixed64 integer[] +---@field unpacked_float number[] +---@field unpacked_double number[] +---@field unpacked_bool boolean[] +---@field unpacked_nested_enum protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum[] +---@field map_int32_int32 table @ Map +---@field map_int64_int64 table +---@field map_uint32_uint32 table +---@field map_uint64_uint64 table +---@field map_sint32_sint32 table +---@field map_sint64_sint64 table +---@field map_fixed32_fixed32 table +---@field map_fixed64_fixed64 table +---@field map_sfixed32_sfixed32 table +---@field map_sfixed64_sfixed64 table +---@field map_int32_bool table +---@field map_int32_float table +---@field map_int32_double table +---@field map_int32_nested_message table +---@field map_bool_bool table +---@field map_string_string table +---@field map_string_bytes table +---@field map_string_nested_message table +---@field map_string_foreign_message table +---@field map_string_nested_enum table +---@field map_string_foreign_enum table +---@field oneof_uint32? integer +---@field oneof_nested_message? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field oneof_string? string +---@field oneof_bytes? string +---@field oneof_bool? boolean +---@field oneof_uint64? integer +---@field oneof_float? number +---@field oneof_double? number +---@field oneof_enum? protobuf_test_messages.proto2.TestAllTypesProto2.NestedEnum +---@field data? protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@field multiwordgroupfield? protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@field default_int32? integer @ default values +---@field default_int64? integer +---@field default_uint32? integer +---@field default_uint64? integer +---@field default_sint32? integer +---@field default_sint64? integer +---@field default_fixed32? integer +---@field default_fixed64? integer +---@field default_sfixed32? integer +---@field default_sfixed64? integer +---@field default_float? number +---@field default_double? number +---@field default_bool? boolean +---@field default_string? string +---@field default_bytes? string +---@field fieldname1? integer @ Test field-name-to-JSON-name convention. (protobuf says names can be any valid C/C++ identifier.) +---@field field_name2? integer +---@field _field_name3? integer +---@field field__name4_? integer +---@field field0name5? integer +---@field field_0_name6? integer +---@field fieldName7? integer +---@field FieldName8? integer +---@field field_Name9? integer +---@field Field_Name10? integer +---@field FIELD_NAME11? integer +---@field FIELD_name12? integer +---@field __field_name13? integer +---@field __Field_name14? integer +---@field field__name15? integer +---@field field__Name16? integer +---@field field_name17__? integer +---@field Field_name18__? integer + +---@class protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@field a? integer +---@field corecursive? protobuf_test_messages.proto2.TestAllTypesProto2 + +--- groups +---@class protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.ForeignMessageProto2 +---@field c? integer + +---@class protobuf_test_messages.proto2.GroupField +---@field group_int32? integer +---@field group_uint32? integer + +---@class protobuf_test_messages.proto2.UnknownToTestAllTypes +---@field optional_int32? integer +---@field optional_string? string +---@field nested_message? protobuf_test_messages.proto2.ForeignMessageProto2 +---@field optionalgroup? protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@field optional_bool? boolean +---@field repeated_int32 integer[] + +---@class protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@field a? integer + +---@class protobuf_test_messages.proto2.NullHypothesisProto2 + +---@class protobuf_test_messages.proto2.EnumOnlyProto2 + +---@class protobuf_test_messages.proto2.OneStringProto2 +---@field data? string + +---@class protobuf_test_messages.proto2.ProtoWithKeywords +---@field inline? integer +---@field concept? string +---@field requires string[] + +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field required_int32 integer @ Singular +---@field required_int64 integer +---@field required_uint32 integer +---@field required_uint64 integer +---@field required_sint32 integer +---@field required_sint64 integer +---@field required_fixed32 integer +---@field required_fixed64 integer +---@field required_sfixed32 integer +---@field required_sfixed64 integer +---@field required_float number +---@field required_double number +---@field required_bool boolean +---@field required_string string +---@field required_bytes string +---@field required_nested_message protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@field required_foreign_message protobuf_test_messages.proto2.ForeignMessageProto2 +---@field required_nested_enum protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedEnum +---@field required_foreign_enum protobuf_test_messages.proto2.ForeignEnumProto2 +---@field required_string_piece string +---@field required_cord string +---@field recursive_message protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field optional_recursive_message? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field data protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@field default_int32 integer @ default values +---@field default_int64 integer +---@field default_uint32 integer +---@field default_uint64 integer +---@field default_sint32 integer +---@field default_sint64 integer +---@field default_fixed32 integer +---@field default_fixed64 integer +---@field default_sfixed32 integer +---@field default_sfixed64 integer +---@field default_float number +---@field default_double number +---@field default_bool boolean +---@field default_string string +---@field default_bytes string + +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@field a integer +---@field corecursive protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@field optional_corecursive? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 + +--- groups +---@class protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@field group_int32 integer +---@field group_uint32 integer + +---@class protobuf_test_messages.proto2.TestLargeOneof +---@field a1? protobuf_test_messages.proto2.TestLargeOneof.A1 +---@field a2? protobuf_test_messages.proto2.TestLargeOneof.A2 +---@field a3? protobuf_test_messages.proto2.TestLargeOneof.A3 +---@field a4? protobuf_test_messages.proto2.TestLargeOneof.A4 +---@field a5? protobuf_test_messages.proto2.TestLargeOneof.A5 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A1 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A2 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A3 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A4 + +---@class protobuf_test_messages.proto2.TestLargeOneof.A5 + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2 +---@return protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return string +function M.TestAllTypesProto2_encode(t) return pb.encode(M.TestAllTypesProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_decode(b) return pb.decode(M.TestAllTypesProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_int32(t) return t.optional_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_int32(t) t.optional_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_int64(t) return t.optional_int64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_int64(t) t.optional_int64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_uint32(t) return t.optional_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_uint32(t) t.optional_uint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_uint64(t) return t.optional_uint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_uint64(t) t.optional_uint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sint32(t) return t.optional_sint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sint32(t) t.optional_sint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sint64(t) return t.optional_sint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sint64(t) t.optional_sint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_fixed32(t) return t.optional_fixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_fixed32(t) t.optional_fixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_fixed64(t) return t.optional_fixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_fixed64(t) t.optional_fixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sfixed32(t) return t.optional_sfixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sfixed32(t) t.optional_sfixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_sfixed64(t) return t.optional_sfixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_sfixed64(t) t.optional_sfixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_float(t) return t.optional_float ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_float(t) t.optional_float = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_double(t) return t.optional_double ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_double(t) t.optional_double = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_bool(t) return t.optional_bool ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_bool(t) t.optional_bool = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_string(t) return t.optional_string ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_string(t) t.optional_string = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_bytes(t) return t.optional_bytes ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_bytes(t) t.optional_bytes = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_nested_message(t) return t.optional_nested_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_nested_message(t) t.optional_nested_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_foreign_message(t) return t.optional_foreign_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_foreign_message(t) t.optional_foreign_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_nested_enum(t) return t.optional_nested_enum ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_nested_enum(t) t.optional_nested_enum = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_foreign_enum(t) return t.optional_foreign_enum ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_foreign_enum(t) t.optional_foreign_enum = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_string_piece(t) return t.optional_string_piece ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_string_piece(t) t.optional_string_piece = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_optional_cord(t) return t.optional_cord ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_optional_cord(t) t.optional_cord = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_recursive_message(t) return t.recursive_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_recursive_message(t) t.recursive_message = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_data(t) return t.data ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_data(t) t.data = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_multiwordgroupfield(t) return t.multiwordgroupfield ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_multiwordgroupfield(t) t.multiwordgroupfield = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_int32(t) return t.default_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_int32(t) t.default_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_int64(t) return t.default_int64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_int64(t) t.default_int64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_uint32(t) return t.default_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_uint32(t) t.default_uint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_uint64(t) return t.default_uint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_uint64(t) t.default_uint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sint32(t) return t.default_sint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sint32(t) t.default_sint32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sint64(t) return t.default_sint64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sint64(t) t.default_sint64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_fixed32(t) return t.default_fixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_fixed32(t) t.default_fixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_fixed64(t) return t.default_fixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_fixed64(t) t.default_fixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sfixed32(t) return t.default_sfixed32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sfixed32(t) t.default_sfixed32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_sfixed64(t) return t.default_sfixed64 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_sfixed64(t) t.default_sfixed64 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_float(t) return t.default_float ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_float(t) t.default_float = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_double(t) return t.default_double ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_double(t) t.default_double = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_bool(t) return t.default_bool ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_bool(t) t.default_bool = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_string(t) return t.default_string ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_string(t) t.default_string = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_default_bytes(t) return t.default_bytes ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_default_bytes(t) t.default_bytes = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_fieldname1(t) return t.fieldname1 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_fieldname1(t) t.fieldname1 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_name2(t) return t.field_name2 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_name2(t) t.field_name2 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has__field_name3(t) return t._field_name3 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear__field_name3(t) t._field_name3 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__name4_(t) return t.field__name4_ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__name4_(t) t.field__name4_ = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field0name5(t) return t.field0name5 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field0name5(t) t.field0name5 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_0_name6(t) return t.field_0_name6 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_0_name6(t) t.field_0_name6 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_fieldName7(t) return t.fieldName7 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_fieldName7(t) t.fieldName7 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FieldName8(t) return t.FieldName8 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FieldName8(t) t.FieldName8 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_Name9(t) return t.field_Name9 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_Name9(t) t.field_Name9 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_Field_Name10(t) return t.Field_Name10 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_Field_Name10(t) t.Field_Name10 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FIELD_NAME11(t) return t.FIELD_NAME11 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FIELD_NAME11(t) t.FIELD_NAME11 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_FIELD_name12(t) return t.FIELD_name12 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_FIELD_name12(t) t.FIELD_name12 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has___field_name13(t) return t.__field_name13 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear___field_name13(t) t.__field_name13 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has___Field_name14(t) return t.__Field_name14 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear___Field_name14(t) t.__Field_name14 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__name15(t) return t.field__name15 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__name15(t) t.field__name15 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field__Name16(t) return t.field__Name16 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field__Name16(t) t.field__Name16 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_field_name17__(t) return t.field_name17__ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_field_name17__(t) t.field_name17__ = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +---@return boolean +function M.TestAllTypesProto2_has_Field_name18__(t) return t.Field_name18__ ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2 +function M.TestAllTypesProto2_clear_Field_name18__(t) t.Field_name18__ = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return string +function M.TestAllTypesProto2_NestedMessage_encode(t) return pb.encode(M.TestAllTypesProto2_NestedMessage_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_decode(b) return pb.decode(M.TestAllTypesProto2_NestedMessage_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_NestedMessage_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_NestedMessage_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_NestedMessage_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_NestedMessage_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return boolean +function M.TestAllTypesProto2_NestedMessage_has_a(t) return t.a ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_clear_a(t) t.a = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +---@return boolean +function M.TestAllTypesProto2_NestedMessage_has_corecursive(t) return t.corecursive ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.NestedMessage +function M.TestAllTypesProto2_NestedMessage_clear_corecursive(t) t.corecursive = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return string +function M.TestAllTypesProto2_Data_encode(t) return pb.encode(M.TestAllTypesProto2_Data_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_decode(b) return pb.decode(M.TestAllTypesProto2_Data_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_Data_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_Data_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_Data_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_Data_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return boolean +function M.TestAllTypesProto2_Data_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +---@return boolean +function M.TestAllTypesProto2_Data_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.Data +function M.TestAllTypesProto2_Data_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return string +function M.TestAllTypesProto2_MultiWordGroupField_encode(t) return pb.encode(M.TestAllTypesProto2_MultiWordGroupField_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_decode(b) return pb.decode(M.TestAllTypesProto2_MultiWordGroupField_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllTypesProto2_MultiWordGroupField_decode_lazy(b) return pb.decode_lazy(M.TestAllTypesProto2_MultiWordGroupField_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllTypesProto2_MultiWordGroupField_text(t, opts) return pb.text.encode(M.TestAllTypesProto2_MultiWordGroupField_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return boolean +function M.TestAllTypesProto2_MultiWordGroupField_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +---@return boolean +function M.TestAllTypesProto2_MultiWordGroupField_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.TestAllTypesProto2.MultiWordGroupField +function M.TestAllTypesProto2_MultiWordGroupField_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.ForeignMessageProto2 +---@return protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@return string +function M.ForeignMessageProto2_encode(t) return pb.encode(M.ForeignMessageProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_decode(b) return pb.decode(M.ForeignMessageProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.ForeignMessageProto2_decode_lazy(b) return pb.decode_lazy(M.ForeignMessageProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.ForeignMessageProto2_text(t, opts) return pb.text.encode(M.ForeignMessageProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +---@return boolean +function M.ForeignMessageProto2_has_c(t) return t.c ~= nil end +---@param t protobuf_test_messages.proto2.ForeignMessageProto2 +function M.ForeignMessageProto2_clear_c(t) t.c = nil end + +---@param t? protobuf_test_messages.proto2.GroupField +---@return protobuf_test_messages.proto2.GroupField +function M.GroupField_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.GroupField +---@return string +function M.GroupField_encode(t) return pb.encode(M.GroupField_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.GroupField +function M.GroupField_decode(b) return pb.decode(M.GroupField_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.GroupField_decode_lazy(b) return pb.decode_lazy(M.GroupField_descriptor, b) end +---@param t protobuf_test_messages.proto2.GroupField +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.GroupField_text(t, opts) return pb.text.encode(M.GroupField_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.GroupField +---@return boolean +function M.GroupField_has_group_int32(t) return t.group_int32 ~= nil end +---@param t protobuf_test_messages.proto2.GroupField +function M.GroupField_clear_group_int32(t) t.group_int32 = nil end +---@param t protobuf_test_messages.proto2.GroupField +---@return boolean +function M.GroupField_has_group_uint32(t) return t.group_uint32 ~= nil end +---@param t protobuf_test_messages.proto2.GroupField +function M.GroupField_clear_group_uint32(t) t.group_uint32 = nil end + +---@param t? protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return string +function M.UnknownToTestAllTypes_encode(t) return pb.encode(M.UnknownToTestAllTypes_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_decode(b) return pb.decode(M.UnknownToTestAllTypes_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.UnknownToTestAllTypes_decode_lazy(b) return pb.decode_lazy(M.UnknownToTestAllTypes_descriptor, b) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.UnknownToTestAllTypes_text(t, opts) return pb.text.encode(M.UnknownToTestAllTypes_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_int32(t) return t.optional_int32 ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_int32(t) t.optional_int32 = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_string(t) return t.optional_string ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_string(t) t.optional_string = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_nested_message(t) return t.nested_message ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_nested_message(t) t.nested_message = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optionalgroup(t) return t.optionalgroup ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optionalgroup(t) t.optionalgroup = nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +---@return boolean +function M.UnknownToTestAllTypes_has_optional_bool(t) return t.optional_bool ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes +function M.UnknownToTestAllTypes_clear_optional_bool(t) t.optional_bool = nil end + +---@param t? protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return string +function M.UnknownToTestAllTypes_OptionalGroup_encode(t) return pb.encode(M.UnknownToTestAllTypes_OptionalGroup_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_decode(b) return pb.decode(M.UnknownToTestAllTypes_OptionalGroup_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.UnknownToTestAllTypes_OptionalGroup_decode_lazy(b) return pb.decode_lazy(M.UnknownToTestAllTypes_OptionalGroup_descriptor, b) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.UnknownToTestAllTypes_OptionalGroup_text(t, opts) return pb.text.encode(M.UnknownToTestAllTypes_OptionalGroup_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +---@return boolean +function M.UnknownToTestAllTypes_OptionalGroup_has_a(t) return t.a ~= nil end +---@param t protobuf_test_messages.proto2.UnknownToTestAllTypes.OptionalGroup +function M.UnknownToTestAllTypes_OptionalGroup_clear_a(t) t.a = nil end + +---@param t? protobuf_test_messages.proto2.NullHypothesisProto2 +---@return protobuf_test_messages.proto2.NullHypothesisProto2 +function M.NullHypothesisProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.NullHypothesisProto2 +---@return string +function M.NullHypothesisProto2_encode(t) return pb.encode(M.NullHypothesisProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.NullHypothesisProto2 +function M.NullHypothesisProto2_decode(b) return pb.decode(M.NullHypothesisProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.NullHypothesisProto2_decode_lazy(b) return pb.decode_lazy(M.NullHypothesisProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.NullHypothesisProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.NullHypothesisProto2_text(t, opts) return pb.text.encode(M.NullHypothesisProto2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.EnumOnlyProto2 +---@return protobuf_test_messages.proto2.EnumOnlyProto2 +function M.EnumOnlyProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.EnumOnlyProto2 +---@return string +function M.EnumOnlyProto2_encode(t) return pb.encode(M.EnumOnlyProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.EnumOnlyProto2 +function M.EnumOnlyProto2_decode(b) return pb.decode(M.EnumOnlyProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.EnumOnlyProto2_decode_lazy(b) return pb.decode_lazy(M.EnumOnlyProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.EnumOnlyProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.EnumOnlyProto2_text(t, opts) return pb.text.encode(M.EnumOnlyProto2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.OneStringProto2 +---@return protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@return string +function M.OneStringProto2_encode(t) return pb.encode(M.OneStringProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_decode(b) return pb.decode(M.OneStringProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.OneStringProto2_decode_lazy(b) return pb.decode_lazy(M.OneStringProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.OneStringProto2_text(t, opts) return pb.text.encode(M.OneStringProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.OneStringProto2 +---@return boolean +function M.OneStringProto2_has_data(t) return t.data ~= nil end +---@param t protobuf_test_messages.proto2.OneStringProto2 +function M.OneStringProto2_clear_data(t) t.data = nil end + +---@param t? protobuf_test_messages.proto2.ProtoWithKeywords +---@return protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return string +function M.ProtoWithKeywords_encode(t) return pb.encode(M.ProtoWithKeywords_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_decode(b) return pb.decode(M.ProtoWithKeywords_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.ProtoWithKeywords_decode_lazy(b) return pb.decode_lazy(M.ProtoWithKeywords_descriptor, b) end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.ProtoWithKeywords_text(t, opts) return pb.text.encode(M.ProtoWithKeywords_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return boolean +function M.ProtoWithKeywords_has_inline(t) return t.inline ~= nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_clear_inline(t) t.inline = nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +---@return boolean +function M.ProtoWithKeywords_has_concept(t) return t.concept ~= nil end +---@param t protobuf_test_messages.proto2.ProtoWithKeywords +function M.ProtoWithKeywords_clear_concept(t) t.concept = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return string +function M.TestAllRequiredTypesProto2_encode(t) return pb.encode(M.TestAllRequiredTypesProto2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_decode(b) return pb.decode(M.TestAllRequiredTypesProto2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +---@return boolean +function M.TestAllRequiredTypesProto2_has_optional_recursive_message(t) return t.optional_recursive_message ~= nil end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2 +function M.TestAllRequiredTypesProto2_clear_optional_recursive_message(t) t.optional_recursive_message = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return string +function M.TestAllRequiredTypesProto2_NestedMessage_encode(t) return pb.encode(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_decode(b) return pb.decode(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_NestedMessage_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_NestedMessage_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_NestedMessage_descriptor, t, opts) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +---@return boolean +function M.TestAllRequiredTypesProto2_NestedMessage_has_optional_corecursive(t) return t.optional_corecursive ~= nil end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.NestedMessage +function M.TestAllRequiredTypesProto2_NestedMessage_clear_optional_corecursive(t) t.optional_corecursive = nil end + +---@param t? protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +function M.TestAllRequiredTypesProto2_Data_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@return string +function M.TestAllRequiredTypesProto2_Data_encode(t) return pb.encode(M.TestAllRequiredTypesProto2_Data_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +function M.TestAllRequiredTypesProto2_Data_decode(b) return pb.decode(M.TestAllRequiredTypesProto2_Data_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestAllRequiredTypesProto2_Data_decode_lazy(b) return pb.decode_lazy(M.TestAllRequiredTypesProto2_Data_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestAllRequiredTypesProto2.Data +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestAllRequiredTypesProto2_Data_text(t, opts) return pb.text.encode(M.TestAllRequiredTypesProto2_Data_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof +---@return protobuf_test_messages.proto2.TestLargeOneof +function M.TestLargeOneof_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof +---@return string +function M.TestLargeOneof_encode(t) return pb.encode(M.TestLargeOneof_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof +function M.TestLargeOneof_decode(b) return pb.decode(M.TestLargeOneof_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_text(t, opts) return pb.text.encode(M.TestLargeOneof_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A1 +---@return protobuf_test_messages.proto2.TestLargeOneof.A1 +function M.TestLargeOneof_A1_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A1 +---@return string +function M.TestLargeOneof_A1_encode(t) return pb.encode(M.TestLargeOneof_A1_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A1 +function M.TestLargeOneof_A1_decode(b) return pb.decode(M.TestLargeOneof_A1_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A1_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A1_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A1 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A1_text(t, opts) return pb.text.encode(M.TestLargeOneof_A1_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A2 +---@return protobuf_test_messages.proto2.TestLargeOneof.A2 +function M.TestLargeOneof_A2_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A2 +---@return string +function M.TestLargeOneof_A2_encode(t) return pb.encode(M.TestLargeOneof_A2_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A2 +function M.TestLargeOneof_A2_decode(b) return pb.decode(M.TestLargeOneof_A2_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A2_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A2_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A2 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A2_text(t, opts) return pb.text.encode(M.TestLargeOneof_A2_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A3 +---@return protobuf_test_messages.proto2.TestLargeOneof.A3 +function M.TestLargeOneof_A3_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A3 +---@return string +function M.TestLargeOneof_A3_encode(t) return pb.encode(M.TestLargeOneof_A3_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A3 +function M.TestLargeOneof_A3_decode(b) return pb.decode(M.TestLargeOneof_A3_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A3_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A3_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A3 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A3_text(t, opts) return pb.text.encode(M.TestLargeOneof_A3_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A4 +---@return protobuf_test_messages.proto2.TestLargeOneof.A4 +function M.TestLargeOneof_A4_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A4 +---@return string +function M.TestLargeOneof_A4_encode(t) return pb.encode(M.TestLargeOneof_A4_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A4 +function M.TestLargeOneof_A4_decode(b) return pb.decode(M.TestLargeOneof_A4_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A4_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A4_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A4 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A4_text(t, opts) return pb.text.encode(M.TestLargeOneof_A4_descriptor, t, opts) end + +---@param t? protobuf_test_messages.proto2.TestLargeOneof.A5 +---@return protobuf_test_messages.proto2.TestLargeOneof.A5 +function M.TestLargeOneof_A5_new(t) return t or {} end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A5 +---@return string +function M.TestLargeOneof_A5_encode(t) return pb.encode(M.TestLargeOneof_A5_descriptor, t) end +---@param b string +---@return protobuf_test_messages.proto2.TestLargeOneof.A5 +function M.TestLargeOneof_A5_decode(b) return pb.decode(M.TestLargeOneof_A5_descriptor, b) end +---@param b string +---@return pb.MessageView +function M.TestLargeOneof_A5_decode_lazy(b) return pb.decode_lazy(M.TestLargeOneof_A5_descriptor, b) end +---@param t protobuf_test_messages.proto2.TestLargeOneof.A5 +---@param opts? {single_line: boolean?, indent: string?} +---@return string +function M.TestLargeOneof_A5_text(t, opts) return pb.text.encode(M.TestLargeOneof_A5_descriptor, t, opts) end + +return M diff --git a/runtime/pb/codec.lua b/runtime/pb/codec.lua index 775efb9b5cc8fe5643f5d70475ac4573f7106c5f..b16cf46be7ea47e8fbd2fd0301c719cadfba9bd7 100644 --- a/runtime/pb/codec.lua +++ b/runtime/pb/codec.lua @@ -66,8 +66,11 @@ end -- Forward declarations: encode_field/build_writer/build_reader need to -- close over encode_message and decode_msg before those are assigned -- further down (writers/readers built by compile_* at finalize-time). +-- decode_group is for proto2 groups; its assignment is deferred because +-- the per-tag dispatch shares fast-path knowledge with decode_message. local encode_message local decode_msg +local decode_group -- merge_message(desc, prev, decoded): recursively merge `decoded` into -- `prev` per proto3 spec semantics: @@ -222,6 +225,16 @@ local function encode_field(field, value, out, force) out[#out + 1] = tag out[#out + 1] = wire.encode_len(encode_msg(field.message, value[i])) end + elseif kind == 'group' then + -- Proto2 repeated group: each element brackets its own + -- SGROUP/EGROUP tag pair around the encoded body. + local stag = wire.encode_tag(id, wire.WIRE_SGROUP) + local etag = wire.encode_tag(id, wire.WIRE_EGROUP) + for i = 1, #value do + out[#out + 1] = stag + out[#out + 1] = encode_msg(field.message, value[i]) + out[#out + 1] = etag + end else error("unknown field kind " .. tostring(kind), 0) end @@ -245,6 +258,10 @@ local function encode_field(field, value, out, force) elseif kind == 'message' then out[#out + 1] = wire.encode_tag(id, wire.WIRE_LEN) out[#out + 1] = wire.encode_len(encode_msg(field.message, value)) + elseif kind == 'group' then + out[#out + 1] = wire.encode_tag(id, wire.WIRE_SGROUP) + out[#out + 1] = encode_msg(field.message, value) + out[#out + 1] = wire.encode_tag(id, wire.WIRE_EGROUP) else error("unknown field kind " .. tostring(kind), 0) end @@ -351,6 +368,24 @@ local function build_repeated_writer(f) end end + if kind == 'group' then + local sub_desc = f.message + local stag = wire.encode_tag(f.id, wire.WIRE_SGROUP) + local etag = wire.encode_tag(f.id, wire.WIRE_EGROUP) + return function(data, out) + local v = data[fname] + if v == nil then return end + local nv = #v + if nv == 0 then return end + local n = #out + for i = 1, nv do + n = n + 1; out[n] = stag + n = n + 1; out[n] = encode_msg(sub_desc, v[i]) + n = n + 1; out[n] = etag + end + end + end + if kind == 'enum' then local enum_desc = f.enum -- proto3 default: repeated enums are packed unless explicitly disabled. @@ -569,6 +604,20 @@ local function build_writer(f, owner_name) end end + if kind == 'group' then + local sub_desc = f.message + local stag = wire.encode_tag(f.id, wire.WIRE_SGROUP) + local etag = wire.encode_tag(f.id, wire.WIRE_EGROUP) + return function(data, out) + local v = data[fname] + if v == nil and type(v) ~= 'cdata' then return end + local n = #out + out[n + 1] = stag + out[n + 2] = encode_msg(sub_desc, v) + out[n + 3] = etag + end + end + return nil end @@ -669,6 +718,18 @@ local function build_repeated_reader(f) end end + if kind == 'group' then + local sub_desc = f.message + local stop_id = f.id + return function(buf, pos, wt, result) + local list = result[fname] + if list == nil then list = {}; result[fname] = list end + local decoded, np = decode_group(sub_desc, buf, pos, stop_id) + list[#list + 1] = decoded + return np + end + end + return nil end @@ -771,6 +832,34 @@ local function build_reader(f) end end + if kind == 'group' then + local sub_desc = f.message + local stop_id = f.id + if siblings then + return function(buf, pos, wt, result) + local decoded, np = decode_group(sub_desc, buf, pos, stop_id) + local prev = result[fname] + if prev == nil then + result[fname] = decoded + else + M.merge_message(sub_desc, prev, decoded) + end + for i = 1, #siblings do result[siblings[i]] = nil end + return np + end + end + return function(buf, pos, wt, result) + local decoded, np = decode_group(sub_desc, buf, pos, stop_id) + local prev = result[fname] + if prev == nil then + result[fname] = decoded + else + M.merge_message(sub_desc, prev, decoded) + end + return np + end + end + return nil end @@ -885,6 +974,52 @@ local function decode_packed(field, payload) return out end +-- decode_group: proto2 group body decoder. Reads tags out of `buf` starting +-- at `pos` until it finds an EGROUP tag whose field id matches `stop_id`. +-- Returns the decoded table and the position immediately past the EGROUP. +-- Mirrors decode_message's per-tag dispatch but stops on EGROUP instead of +-- end-of-buffer. Forward-declared near the top of the file so reader +-- closures built by compile_readers can capture it before this assignment. +decode_group = function(desc, buf, pos, stop_id) + local result = {} + local fbi = desc.field_by_id + local len = #buf + local WIRE_EG = wire.WIRE_EGROUP + local unknown + while pos <= len do + local tag_start = pos + local id, wt + id, wt, pos = wire.decode_tag(buf, pos) + if wt == WIRE_EG then + if id ~= stop_id then + error(("EGROUP id %d does not match SGROUP id %d"): + format(id, stop_id), 0) + end + if unknown ~= nil then + result._unknown_fields = table.concat(unknown) + end + return result, pos + end + local f = fbi[id] + if f == nil then + pos = wire.skip_field(buf, pos, wt, id) + if unknown == nil then unknown = {} end + unknown[#unknown + 1] = buf:sub(tag_start, pos - 1) + else + local reader = f._reader + if reader ~= nil then + pos = reader(buf, pos, wt, result) + else + -- Slow-path map decode mirrors decode_message; groups + -- containing maps are exotic but we handle them. + pos = wire.skip_field(buf, pos, wt, id) + end + end + end + error("group not terminated by EGROUP id " .. tostring(stop_id), 0) +end +M.decode_group = decode_group + decode_message = function(desc, buf) if type(buf) ~= 'string' then error(("expected string for decode of %s, got %s"):format(desc.name, type(buf)), 0) diff --git a/runtime/pb/dynamic.lua b/runtime/pb/dynamic.lua index b0055afa49a2e343117593d793954622512f9ac9..9d0bbbca7ce4bef2bd34c4b70a28199bc0049a80 100644 --- a/runtime/pb/dynamic.lua +++ b/runtime/pb/dynamic.lua @@ -110,13 +110,22 @@ end local function build_field(field_ast, index, is_proto2) local entry = {name = field_ast.name, id = field_ast.id} local kind, ref = resolve_type(field_ast.type, index) - entry.kind = kind - if kind == 'scalar' then - entry.proto_type = ref - elseif kind == 'message' then + -- Group fields parse as `kind='group'` in the AST; the parser's + -- type lookup resolves to the nested message it desugared. Carry + -- the group flag through so the codec emits SGROUP/EGROUP rather + -- than a length-prefixed message body. + if field_ast.kind == 'group' then + entry.kind = 'group' entry.message = ref - elseif kind == 'enum' then - entry.enum = ref + else + entry.kind = kind + if kind == 'scalar' then + entry.proto_type = ref + elseif kind == 'message' then + entry.message = ref + elseif kind == 'enum' then + entry.enum = ref + end end if field_ast.repeated then entry.repeated = true diff --git a/runtime/pb/parser.lua b/runtime/pb/parser.lua index 0c81a8670c2bdeac0df92539614f807e1cd4f836..349d4a026ac02836e8c3cddef5a6cbaeeb427ecb 100644 --- a/runtime/pb/parser.lua +++ b/runtime/pb/parser.lua @@ -155,9 +155,20 @@ local function parse(tokens) return enum end - local function parse_message() - consume('ident', 'message') - local name = consume('ident').value + -- parse_message(preconsumed_name?) — consumes `message Name { … }` from + -- the head of the token stream. When called with a non-nil name argument + -- (the proto2 group desugaring path), the `message Name` part has + -- already been recognized by the caller and only the `{ … }` body + -- remains. + local parse_message + parse_message = function(preconsumed_name) + local name + if preconsumed_name then + name = preconsumed_name + else + consume('ident', 'message') + name = consume('ident').value + end consume('punct', '{') local message = { name = name, @@ -171,6 +182,30 @@ local function parse(tokens) message.fields[#message.fields + 1] = field end + -- Proto2 group syntax desugars into (a) a nested message named + -- after the group's capitalized identifier and (b) a field of + -- kind=group referencing that submessage. The field's user- + -- visible name is the lowercased group identifier (mainline + -- proto behavior). + local function emit_group_field(cardinality) + -- `group` keyword already consumed by caller. Group field + -- syntax: `group Name = id { body }` — no terminating `;`. + local group_name = consume('ident').value + consume('punct', '=') + local fid = tonumber(consume('number').value) + parse_field_options() + local nested = parse_message(group_name) + message.nested_messages[#message.nested_messages + 1] = nested + local entry = { + name = group_name:lower(), type = group_name, id = fid, + kind = 'group', + } + if cardinality == 'optional' then entry.optional = true end + if cardinality == 'required' then entry.required = true end + if cardinality == 'repeated' then entry.repeated = true end + emit_field(entry) + end + while not match('punct', '}') do local tok = peek() @@ -208,41 +243,53 @@ local function parse(tokens) elseif tok.type == 'ident' and tok.value == 'optional' then -- proto3 explicit optional / every proto2 optional field consume() - local ft = consume('ident').value - local fn = consume('ident').value - consume('punct', '=') - local fid = tonumber(consume('number').value) - local opts = parse_field_options() - consume('punct', ';') - emit_field({ - name = fn, type = ft, id = fid, optional = true, - default_value = opts.default, - }) + if match('ident', 'group') then + emit_group_field('optional', message) + else + local ft = consume('ident').value + local fn = consume('ident').value + consume('punct', '=') + local fid = tonumber(consume('number').value) + local opts = parse_field_options() + consume('punct', ';') + emit_field({ + name = fn, type = ft, id = fid, optional = true, + default_value = opts.default, + }) + end elseif tok.type == 'ident' and tok.value == 'required' then -- Proto2 `required`. The codec enforces presence on encode. consume() - local ft = consume('ident').value - local fn = consume('ident').value - consume('punct', '=') - local fid = tonumber(consume('number').value) - local opts = parse_field_options() - consume('punct', ';') - emit_field({ - name = fn, type = ft, id = fid, required = true, - default_value = opts.default, - }) + if match('ident', 'group') then + emit_group_field('required', message) + else + local ft = consume('ident').value + local fn = consume('ident').value + consume('punct', '=') + local fid = tonumber(consume('number').value) + local opts = parse_field_options() + consume('punct', ';') + emit_field({ + name = fn, type = ft, id = fid, required = true, + default_value = opts.default, + }) + end elseif tok.type == 'ident' and tok.value == 'repeated' then consume() - local ft = consume('ident').value - local fn = consume('ident').value - consume('punct', '=') - local fid = tonumber(consume('number').value) - local opts = parse_field_options() - consume('punct', ';') - emit_field({ - name = fn, type = ft, id = fid, repeated = true, - packed = opts.packed, - }) + if match('ident', 'group') then + emit_group_field('repeated', message) + else + local ft = consume('ident').value + local fn = consume('ident').value + consume('punct', '=') + local fid = tonumber(consume('number').value) + local opts = parse_field_options() + consume('punct', ';') + emit_field({ + name = fn, type = ft, id = fid, repeated = true, + packed = opts.packed, + }) + end elseif tok.type == 'ident' and tok.value == 'map' then consume() consume('punct', '<') diff --git a/runtime/pb/text.lua b/runtime/pb/text.lua index 279295f05b82b0c46b1f8aefc0f604d0b9ab3fee..275448d12db0c26517e5f600d5ee78908ca7a18b 100644 --- a/runtime/pb/text.lua +++ b/runtime/pb/text.lua @@ -175,6 +175,14 @@ end -- Field emission -- --------------------------------------------------------------------------- +-- Group fields print under the capitalized submessage name rather than +-- the lowercased field name (proto2 legacy convention; mainline protoc's +-- text encoder does the same). +local function group_label(f) + local n = f.message and f.message.name or f.name + return n:match('[^%.]+$') or n +end + local function emit_one(buf, f, v, depth) local kind = f.kind if kind == 'scalar' then @@ -187,6 +195,10 @@ local function emit_one(buf, f, v, depth) emit_block(buf, f.name, depth, function(b, d) emit_message(b, f.message, v, d) end) + elseif kind == 'group' then + emit_block(buf, group_label(f), depth, function(b, d) + emit_message(b, f.message, v, d) + end) else error('text.encode: unknown field kind ' .. tostring(kind), 0) end diff --git a/test/conformance/proto/test_messages_proto2.proto b/test/conformance/proto/test_messages_proto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..1b06c99fd13a4b83d8fa5ce7c287a68ae0993777 --- /dev/null +++ b/test/conformance/proto/test_messages_proto2.proto @@ -0,0 +1,387 @@ +// Vendored from protobuf v34.1 +// (src/google/protobuf/test_messages_proto2.proto) with one surgical edit: +// every `message MessageSet*` nested message and the `message_set_correct` +// field on TestAllTypesProto2 / TestAllRequiredTypesProto2 have been +// removed. protobuf-go's protoreflect refuses to load a FileDescriptor +// declaring `option message_set_wire_format = true;`, calling MessageSet +// "a legacy proto1 feature that is no longer supported" — that rejection +// blocks plugin codegen for the entire file. The MessageSet wire format +// is a separate slice; the proto2 conformance tests that target it (the +// `MessageSetCorrect*` payload categories) will appear as known failures +// until we add support or skip them. +// +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests +// + +// LINT: ALLOW_GROUPS + +syntax = "proto2"; + +package protobuf_test_messages.proto2; + +option java_package = "com.google.protobuf_test_messages.proto2"; +option objc_class_prefix = "Proto2"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; + +option cc_enable_arenas = true; + + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto2 { + message NestedMessage { + optional int32 a = 1; + optional TestAllTypesProto2 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + optional int32 optional_int32 = 1; + optional int64 optional_int64 = 2; + optional uint32 optional_uint32 = 3; + optional uint64 optional_uint64 = 4; + optional sint32 optional_sint32 = 5; + optional sint64 optional_sint64 = 6; + optional fixed32 optional_fixed32 = 7; + optional fixed64 optional_fixed64 = 8; + optional sfixed32 optional_sfixed32 = 9; + optional sfixed64 optional_sfixed64 = 10; + optional float optional_float = 11; + optional double optional_double = 12; + optional bool optional_bool = 13; + optional string optional_string = 14; + optional bytes optional_bytes = 15; + + optional NestedMessage optional_nested_message = 18; + optional ForeignMessageProto2 optional_foreign_message = 19; + + optional NestedEnum optional_nested_enum = 21; + optional ForeignEnumProto2 optional_foreign_enum = 22; + + optional string optional_string_piece = 24 [ctype = STRING_PIECE]; + optional string optional_cord = 25 [ctype = CORD]; + + optional TestAllTypesProto2 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageProto2 repeated_foreign_message = 49; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumProto2 repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [packed = true]; + repeated int64 packed_int64 = 76 [packed = true]; + repeated uint32 packed_uint32 = 77 [packed = true]; + repeated uint64 packed_uint64 = 78 [packed = true]; + repeated sint32 packed_sint32 = 79 [packed = true]; + repeated sint64 packed_sint64 = 80 [packed = true]; + repeated fixed32 packed_fixed32 = 81 [packed = true]; + repeated fixed64 packed_fixed64 = 82 [packed = true]; + repeated sfixed32 packed_sfixed32 = 83 [packed = true]; + repeated sfixed64 packed_sfixed64 = 84 [packed = true]; + repeated float packed_float = 85 [packed = true]; + repeated double packed_double = 86 [packed = true]; + repeated bool packed_bool = 87 [packed = true]; + repeated NestedEnum packed_nested_enum = 88 [packed = true]; + + // Unpacked + repeated int32 unpacked_int32 = 89 [packed = false]; + repeated int64 unpacked_int64 = 90 [packed = false]; + repeated uint32 unpacked_uint32 = 91 [packed = false]; + repeated uint64 unpacked_uint64 = 92 [packed = false]; + repeated sint32 unpacked_sint32 = 93 [packed = false]; + repeated sint64 unpacked_sint64 = 94 [packed = false]; + repeated fixed32 unpacked_fixed32 = 95 [packed = false]; + repeated fixed64 unpacked_fixed64 = 96 [packed = false]; + repeated sfixed32 unpacked_sfixed32 = 97 [packed = false]; + repeated sfixed64 unpacked_sfixed64 = 98 [packed = false]; + repeated float unpacked_float = 99 [packed = false]; + repeated double unpacked_double = 100 [packed = false]; + repeated bool unpacked_bool = 101 [packed = false]; + repeated NestedEnum unpacked_nested_enum = 102 [packed = false]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_bool = 104; + map map_int32_float = 66; + map map_int32_double = 67; + map map_int32_nested_message = 103; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + optional group Data = 201 { + optional int32 group_int32 = 202; + optional uint32 group_uint32 = 203; + } + + optional group MultiWordGroupField = 204 { + optional int32 group_int32 = 205; + optional uint32 group_uint32 = 206; + } + + // default values + optional int32 default_int32 = 241 [default = -123456789]; + optional int64 default_int64 = 242 [default = -9123456789123456789]; + optional uint32 default_uint32 = 243 [default = 2123456789]; + optional uint64 default_uint64 = 244 [default = 10123456789123456789]; + optional sint32 default_sint32 = 245 [default = -123456789]; + optional sint64 default_sint64 = 246 [default = -9123456789123456789]; + optional fixed32 default_fixed32 = 247 [default = 2123456789]; + optional fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + optional sfixed32 default_sfixed32 = 249 [default = -123456789]; + optional sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + optional float default_float = 251 [default = 9e9]; + optional double default_double = 252 [default = 7e22]; + optional bool default_bool = 253 [default = true]; + optional string default_string = 254 [default = "Rosebud"]; + optional bytes default_bytes = 255 [default = "joshua"]; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + optional int32 fieldname1 = 401; + optional int32 field_name2 = 402; + optional int32 _field_name3 = 403; + optional int32 field__name4_ = 404; + optional int32 field0name5 = 405; + optional int32 field_0_name6 = 406; + optional int32 fieldName7 = 407; + optional int32 FieldName8 = 408; + optional int32 field_Name9 = 409; + optional int32 Field_Name10 = 410; + optional int32 FIELD_NAME11 = 411; + optional int32 FIELD_name12 = 412; + optional int32 __field_name13 = 413; + optional int32 __Field_name14 = 414; + optional int32 field__name15 = 415; + optional int32 field__Name16 = 416; + optional int32 field_name17__ = 417; + optional int32 Field_name18__ = 418; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + + + + + + reserved "reserved_field"; + reserved 999999; +} + +message ForeignMessageProto2 { + optional int32 c = 1; +} + +enum ForeignEnumProto2 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesProto2 { + optional int32 extension_int32 = 120; + optional string extension_string = 133; + optional bytes extension_bytes = 134; +} + +extend TestAllTypesProto2 { + optional group GroupField = 121 { + optional int32 group_int32 = 122; + optional uint32 group_uint32 = 123; + } +} + +message UnknownToTestAllTypes { + optional int32 optional_int32 = 1001; + optional string optional_string = 1002; + optional ForeignMessageProto2 nested_message = 1003; + optional group OptionalGroup = 1004 { + optional int32 a = 1; + } + optional bool optional_bool = 1006; + repeated int32 repeated_int32 = 1011; +} + +message NullHypothesisProto2 {} + +message EnumOnlyProto2 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} + +message OneStringProto2 { + optional string data = 1; +} + +message ProtoWithKeywords { + optional int32 inline = 1; + optional string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesProto2 { + message NestedMessage { + required int32 a = 1; + required TestAllRequiredTypesProto2 corecursive = 2; + optional TestAllRequiredTypesProto2 optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + required int32 required_int32 = 1; + required int64 required_int64 = 2; + required uint32 required_uint32 = 3; + required uint64 required_uint64 = 4; + required sint32 required_sint32 = 5; + required sint64 required_sint64 = 6; + required fixed32 required_fixed32 = 7; + required fixed64 required_fixed64 = 8; + required sfixed32 required_sfixed32 = 9; + required sfixed64 required_sfixed64 = 10; + required float required_float = 11; + required double required_double = 12; + required bool required_bool = 13; + required string required_string = 14; + required bytes required_bytes = 15; + + required NestedMessage required_nested_message = 18; + required ForeignMessageProto2 required_foreign_message = 19; + + required NestedEnum required_nested_enum = 21; + required ForeignEnumProto2 required_foreign_enum = 22; + + required string required_string_piece = 24 [ctype = STRING_PIECE]; + required string required_cord = 25 [ctype = CORD]; + + required TestAllRequiredTypesProto2 recursive_message = 27; + optional TestAllRequiredTypesProto2 optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + required group Data = 201 { + required int32 group_int32 = 202; + required uint32 group_uint32 = 203; + } + + // default values + required int32 default_int32 = 241 [default = -123456789]; + required int64 default_int64 = 242 [default = -9123456789123456789]; + required uint32 default_uint32 = 243 [default = 2123456789]; + required uint64 default_uint64 = 244 [default = 10123456789123456789]; + required sint32 default_sint32 = 245 [default = -123456789]; + required sint64 default_sint64 = 246 [default = -9123456789123456789]; + required fixed32 default_fixed32 = 247 [default = 2123456789]; + required fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + required sfixed32 default_sfixed32 = 249 [default = -123456789]; + required sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + required float default_float = 251 [default = 9e9]; + required double default_double = 252 [default = 7e22]; + required bool default_bool = 253 [default = true]; + required string default_string = 254 [default = "Rosebud"]; + required bytes default_bytes = 255 [default = "joshua"]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + + +} + +message TestLargeOneof { + message A1 {} + message A2 {} + message A3 {} + message A4 {} + message A5 {} + oneof large_oneof { + A1 a1 = 1; + A2 a2 = 2; + A3 a3 = 3; + A4 a4 = 4; + A5 a5 = 5; + } +} diff --git a/test/proto/proto2_basic.proto b/test/proto/proto2_basic.proto index 60780345697c58de059327c42ce658551865cab5..98f2b6ff7b0f632ba29468db8b969d549ce8e172 100644 --- a/test/proto/proto2_basic.proto +++ b/test/proto/proto2_basic.proto @@ -36,3 +36,15 @@ message Nested { required int32 x = 1; } } + +// Proto2 legacy groups. Wire format uses SGROUP (3) / EGROUP (4) tag +// pairs instead of a length-prefixed message body. +message WithGroup { + optional group SingleGroup = 1 { + optional int32 a = 2; + optional string s = 3; + } + repeated group RepGroup = 4 { + optional int32 n = 5; + } +} diff --git a/test/proto2_test.lua b/test/proto2_test.lua index f02255b365f5029e99eff5ed5df03aae1042883e..c1f0a9158add19606445deda9e9eafdf54286a0a 100644 --- a/test/proto2_test.lua +++ b/test/proto2_test.lua @@ -146,6 +146,48 @@ for _, mode in ipairs(MODES) do -- The enum descriptor itself round-trips the symbolic name. t.assert_equals(pb.Defaults_Color_descriptor.by_name['GREEN'], 1) end + + -- ----- Proto2 legacy groups: SGROUP/EGROUP wire format ----- + + g.test_group_singular_wire_bytes = function() + -- Field 1 SGROUP (tag 0x0b) opens, body uses regular field tags + -- (a is field 2 VARINT -> 0x10 0x07; s is field 3 LEN -> 0x1a 0x02 'ok'), + -- EGROUP (tag 0x0c) closes. No length prefix anywhere. + local enc = pb.WithGroup_encode({singlegroup = {a = 7, s = 'ok'}}) + t.assert_equals(hex(enc), '0b' .. '10' .. '07' .. '1a' .. '02' .. '6f' .. '6b' .. '0c') + end + + g.test_group_round_trip = function() + local dec = pb.WithGroup_decode(pb.WithGroup_encode( + {singlegroup = {a = 7, s = 'ok'}})) + t.assert_equals(dec.singlegroup.a, 7) + t.assert_equals(dec.singlegroup.s, 'ok') + end + + g.test_group_descriptor_kind = function() + local f = pb.WithGroup_descriptor.field_by_name.singlegroup + t.assert_equals(f.kind, 'group') + t.assert_equals(pb.WithGroup_descriptor.field_by_name.repgroup.kind, 'group') + end + + g.test_repeated_group = function() + local enc = pb.WithGroup_encode({repgroup = {{n = 1}, {n = 2}}}) + -- Each repetition wraps its own SGROUP/EGROUP pair. + t.assert_equals(hex(enc), '23' .. '28' .. '01' .. '24' .. + '23' .. '28' .. '02' .. '24') + local dec = pb.WithGroup_decode(enc) + t.assert_equals(#dec.repgroup, 2) + t.assert_equals(dec.repgroup[1].n, 1) + t.assert_equals(dec.repgroup[2].n, 2) + end + + g.test_group_text_render_uses_message_name = function() + -- Proto2 convention: groups render under the capitalized submessage + -- name (here `SingleGroup`), not the lowercase field name. + local s = pb.WithGroup_text({singlegroup = {a = 7}}) + t.assert(s:find('SingleGroup'), 'expected SingleGroup label in: ' .. s) + t.assert_not(s:find('singlegroup'), 'lowercase field name must not appear') + end end -- Dynamic (source-parsed) proto2: load test/proto/proto2_basic.proto at