pbjs
Version:
A minimal implementation of Google Protocol Buffers for JavaScript
1,384 lines (1,383 loc) • 76.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.encodeEnum = {
A: 0,
B: 1,
};
exports.decodeEnum = {
0: "A" /* A */,
1: "B" /* B */,
};
function encodeNested(message) {
let bb = popByteBuffer();
_encodeNested(message, bb);
return toUint8Array(bb);
}
exports.encodeNested = encodeNested;
function _encodeNested(message, bb) {
// optional float x = 1;
let $x = message.x;
if ($x !== undefined) {
writeVarint32(bb, 13);
writeFloat(bb, $x);
}
// optional float y = 2;
let $y = message.y;
if ($y !== undefined) {
writeVarint32(bb, 21);
writeFloat(bb, $y);
}
}
function decodeNested(binary) {
return _decodeNested(wrapByteBuffer(binary));
}
exports.decodeNested = decodeNested;
function _decodeNested(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// optional float x = 1;
case 1: {
message.x = readFloat(bb);
break;
}
// optional float y = 2;
case 2: {
message.y = readFloat(bb);
break;
}
default:
skipUnknownField(bb, tag & 7);
}
}
return message;
}
function encodeOptional(message) {
let bb = popByteBuffer();
_encodeOptional(message, bb);
return toUint8Array(bb);
}
exports.encodeOptional = encodeOptional;
function _encodeOptional(message, bb) {
// optional int32 field_int32 = 1;
let $field_int32 = message.field_int32;
if ($field_int32 !== undefined) {
writeVarint32(bb, 8);
writeVarint64(bb, intToLong($field_int32));
}
// optional int64 field_int64 = 2;
let $field_int64 = message.field_int64;
if ($field_int64 !== undefined) {
writeVarint32(bb, 16);
writeVarint64(bb, $field_int64);
}
// optional uint32 field_uint32 = 3;
let $field_uint32 = message.field_uint32;
if ($field_uint32 !== undefined) {
writeVarint32(bb, 24);
writeVarint32(bb, $field_uint32);
}
// optional uint64 field_uint64 = 4;
let $field_uint64 = message.field_uint64;
if ($field_uint64 !== undefined) {
writeVarint32(bb, 32);
writeVarint64(bb, $field_uint64);
}
// optional sint32 field_sint32 = 5;
let $field_sint32 = message.field_sint32;
if ($field_sint32 !== undefined) {
writeVarint32(bb, 40);
writeVarint32ZigZag(bb, $field_sint32);
}
// optional sint64 field_sint64 = 6;
let $field_sint64 = message.field_sint64;
if ($field_sint64 !== undefined) {
writeVarint32(bb, 48);
writeVarint64ZigZag(bb, $field_sint64);
}
// optional bool field_bool = 7;
let $field_bool = message.field_bool;
if ($field_bool !== undefined) {
writeVarint32(bb, 56);
writeByte(bb, $field_bool ? 1 : 0);
}
// optional fixed64 field_fixed64 = 8;
let $field_fixed64 = message.field_fixed64;
if ($field_fixed64 !== undefined) {
writeVarint32(bb, 65);
writeInt64(bb, $field_fixed64);
}
// optional sfixed64 field_sfixed64 = 9;
let $field_sfixed64 = message.field_sfixed64;
if ($field_sfixed64 !== undefined) {
writeVarint32(bb, 73);
writeInt64(bb, $field_sfixed64);
}
// optional double field_double = 10;
let $field_double = message.field_double;
if ($field_double !== undefined) {
writeVarint32(bb, 81);
writeDouble(bb, $field_double);
}
// optional string field_string = 11;
let $field_string = message.field_string;
if ($field_string !== undefined) {
writeVarint32(bb, 90);
writeString(bb, $field_string);
}
// optional bytes field_bytes = 12;
let $field_bytes = message.field_bytes;
if ($field_bytes !== undefined) {
writeVarint32(bb, 98);
writeVarint32(bb, $field_bytes.length), writeBytes(bb, $field_bytes);
}
// optional fixed32 field_fixed32 = 13;
let $field_fixed32 = message.field_fixed32;
if ($field_fixed32 !== undefined) {
writeVarint32(bb, 109);
writeInt32(bb, $field_fixed32);
}
// optional sfixed32 field_sfixed32 = 14;
let $field_sfixed32 = message.field_sfixed32;
if ($field_sfixed32 !== undefined) {
writeVarint32(bb, 117);
writeInt32(bb, $field_sfixed32);
}
// optional float field_float = 15;
let $field_float = message.field_float;
if ($field_float !== undefined) {
writeVarint32(bb, 125);
writeFloat(bb, $field_float);
}
// optional Nested field_nested = 16;
let $field_nested = message.field_nested;
if ($field_nested !== undefined) {
writeVarint32(bb, 130);
let nested = popByteBuffer();
_encodeNested($field_nested, nested);
writeVarint32(bb, nested.limit);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
function decodeOptional(binary) {
return _decodeOptional(wrapByteBuffer(binary));
}
exports.decodeOptional = decodeOptional;
function _decodeOptional(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// optional int32 field_int32 = 1;
case 1: {
message.field_int32 = readVarint32(bb);
break;
}
// optional int64 field_int64 = 2;
case 2: {
message.field_int64 = readVarint64(bb, /* unsigned */ false);
break;
}
// optional uint32 field_uint32 = 3;
case 3: {
message.field_uint32 = readVarint32(bb) >>> 0;
break;
}
// optional uint64 field_uint64 = 4;
case 4: {
message.field_uint64 = readVarint64(bb, /* unsigned */ true);
break;
}
// optional sint32 field_sint32 = 5;
case 5: {
message.field_sint32 = readVarint32ZigZag(bb);
break;
}
// optional sint64 field_sint64 = 6;
case 6: {
message.field_sint64 = readVarint64ZigZag(bb);
break;
}
// optional bool field_bool = 7;
case 7: {
message.field_bool = !!readByte(bb);
break;
}
// optional fixed64 field_fixed64 = 8;
case 8: {
message.field_fixed64 = readInt64(bb, /* unsigned */ true);
break;
}
// optional sfixed64 field_sfixed64 = 9;
case 9: {
message.field_sfixed64 = readInt64(bb, /* unsigned */ false);
break;
}
// optional double field_double = 10;
case 10: {
message.field_double = readDouble(bb);
break;
}
// optional string field_string = 11;
case 11: {
message.field_string = readString(bb, readVarint32(bb));
break;
}
// optional bytes field_bytes = 12;
case 12: {
message.field_bytes = readBytes(bb, readVarint32(bb));
break;
}
// optional fixed32 field_fixed32 = 13;
case 13: {
message.field_fixed32 = readInt32(bb) >>> 0;
break;
}
// optional sfixed32 field_sfixed32 = 14;
case 14: {
message.field_sfixed32 = readInt32(bb);
break;
}
// optional float field_float = 15;
case 15: {
message.field_float = readFloat(bb);
break;
}
// optional Nested field_nested = 16;
case 16: {
let limit = pushTemporaryLength(bb);
message.field_nested = _decodeNested(bb);
bb.limit = limit;
break;
}
default:
skipUnknownField(bb, tag & 7);
}
}
return message;
}
function encodeRepeatedUnpacked(message) {
let bb = popByteBuffer();
_encodeRepeatedUnpacked(message, bb);
return toUint8Array(bb);
}
exports.encodeRepeatedUnpacked = encodeRepeatedUnpacked;
function _encodeRepeatedUnpacked(message, bb) {
// repeated int32 field_int32 = 1;
let array$field_int32 = message.field_int32;
if (array$field_int32 !== undefined) {
for (let value of array$field_int32) {
writeVarint32(bb, 8);
writeVarint64(bb, intToLong(value));
}
}
// repeated int64 field_int64 = 2;
let array$field_int64 = message.field_int64;
if (array$field_int64 !== undefined) {
for (let value of array$field_int64) {
writeVarint32(bb, 16);
writeVarint64(bb, value);
}
}
// repeated uint32 field_uint32 = 3;
let array$field_uint32 = message.field_uint32;
if (array$field_uint32 !== undefined) {
for (let value of array$field_uint32) {
writeVarint32(bb, 24);
writeVarint32(bb, value);
}
}
// repeated uint64 field_uint64 = 4;
let array$field_uint64 = message.field_uint64;
if (array$field_uint64 !== undefined) {
for (let value of array$field_uint64) {
writeVarint32(bb, 32);
writeVarint64(bb, value);
}
}
// repeated sint32 field_sint32 = 5;
let array$field_sint32 = message.field_sint32;
if (array$field_sint32 !== undefined) {
for (let value of array$field_sint32) {
writeVarint32(bb, 40);
writeVarint32ZigZag(bb, value);
}
}
// repeated sint64 field_sint64 = 6;
let array$field_sint64 = message.field_sint64;
if (array$field_sint64 !== undefined) {
for (let value of array$field_sint64) {
writeVarint32(bb, 48);
writeVarint64ZigZag(bb, value);
}
}
// repeated bool field_bool = 7;
let array$field_bool = message.field_bool;
if (array$field_bool !== undefined) {
for (let value of array$field_bool) {
writeVarint32(bb, 56);
writeByte(bb, value ? 1 : 0);
}
}
// repeated fixed64 field_fixed64 = 8;
let array$field_fixed64 = message.field_fixed64;
if (array$field_fixed64 !== undefined) {
for (let value of array$field_fixed64) {
writeVarint32(bb, 65);
writeInt64(bb, value);
}
}
// repeated sfixed64 field_sfixed64 = 9;
let array$field_sfixed64 = message.field_sfixed64;
if (array$field_sfixed64 !== undefined) {
for (let value of array$field_sfixed64) {
writeVarint32(bb, 73);
writeInt64(bb, value);
}
}
// repeated double field_double = 10;
let array$field_double = message.field_double;
if (array$field_double !== undefined) {
for (let value of array$field_double) {
writeVarint32(bb, 81);
writeDouble(bb, value);
}
}
// repeated string field_string = 11;
let array$field_string = message.field_string;
if (array$field_string !== undefined) {
for (let value of array$field_string) {
writeVarint32(bb, 90);
writeString(bb, value);
}
}
// repeated bytes field_bytes = 12;
let array$field_bytes = message.field_bytes;
if (array$field_bytes !== undefined) {
for (let value of array$field_bytes) {
writeVarint32(bb, 98);
writeVarint32(bb, value.length), writeBytes(bb, value);
}
}
// repeated fixed32 field_fixed32 = 13;
let array$field_fixed32 = message.field_fixed32;
if (array$field_fixed32 !== undefined) {
for (let value of array$field_fixed32) {
writeVarint32(bb, 109);
writeInt32(bb, value);
}
}
// repeated sfixed32 field_sfixed32 = 14;
let array$field_sfixed32 = message.field_sfixed32;
if (array$field_sfixed32 !== undefined) {
for (let value of array$field_sfixed32) {
writeVarint32(bb, 117);
writeInt32(bb, value);
}
}
// repeated float field_float = 15;
let array$field_float = message.field_float;
if (array$field_float !== undefined) {
for (let value of array$field_float) {
writeVarint32(bb, 125);
writeFloat(bb, value);
}
}
// repeated Nested field_nested = 16;
let array$field_nested = message.field_nested;
if (array$field_nested !== undefined) {
for (let value of array$field_nested) {
writeVarint32(bb, 130);
let nested = popByteBuffer();
_encodeNested(value, nested);
writeVarint32(bb, nested.limit);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
}
function decodeRepeatedUnpacked(binary) {
return _decodeRepeatedUnpacked(wrapByteBuffer(binary));
}
exports.decodeRepeatedUnpacked = decodeRepeatedUnpacked;
function _decodeRepeatedUnpacked(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// repeated int32 field_int32 = 1;
case 1: {
let values = message.field_int32 || (message.field_int32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32(bb));
}
break;
}
// repeated int64 field_int64 = 2;
case 2: {
let values = message.field_int64 || (message.field_int64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64(bb, /* unsigned */ false));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64(bb, /* unsigned */ false));
}
break;
}
// repeated uint32 field_uint32 = 3;
case 3: {
let values = message.field_uint32 || (message.field_uint32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32(bb) >>> 0);
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32(bb) >>> 0);
}
break;
}
// repeated uint64 field_uint64 = 4;
case 4: {
let values = message.field_uint64 || (message.field_uint64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64(bb, /* unsigned */ true));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64(bb, /* unsigned */ true));
}
break;
}
// repeated sint32 field_sint32 = 5;
case 5: {
let values = message.field_sint32 || (message.field_sint32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32ZigZag(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32ZigZag(bb));
}
break;
}
// repeated sint64 field_sint64 = 6;
case 6: {
let values = message.field_sint64 || (message.field_sint64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64ZigZag(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64ZigZag(bb));
}
break;
}
// repeated bool field_bool = 7;
case 7: {
let values = message.field_bool || (message.field_bool = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(!!readByte(bb));
}
bb.limit = outerLimit;
}
else {
values.push(!!readByte(bb));
}
break;
}
// repeated fixed64 field_fixed64 = 8;
case 8: {
let values = message.field_fixed64 || (message.field_fixed64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt64(bb, /* unsigned */ true));
}
bb.limit = outerLimit;
}
else {
values.push(readInt64(bb, /* unsigned */ true));
}
break;
}
// repeated sfixed64 field_sfixed64 = 9;
case 9: {
let values = message.field_sfixed64 || (message.field_sfixed64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt64(bb, /* unsigned */ false));
}
bb.limit = outerLimit;
}
else {
values.push(readInt64(bb, /* unsigned */ false));
}
break;
}
// repeated double field_double = 10;
case 10: {
let values = message.field_double || (message.field_double = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readDouble(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readDouble(bb));
}
break;
}
// repeated string field_string = 11;
case 11: {
let values = message.field_string || (message.field_string = []);
values.push(readString(bb, readVarint32(bb)));
break;
}
// repeated bytes field_bytes = 12;
case 12: {
let values = message.field_bytes || (message.field_bytes = []);
values.push(readBytes(bb, readVarint32(bb)));
break;
}
// repeated fixed32 field_fixed32 = 13;
case 13: {
let values = message.field_fixed32 || (message.field_fixed32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt32(bb) >>> 0);
}
bb.limit = outerLimit;
}
else {
values.push(readInt32(bb) >>> 0);
}
break;
}
// repeated sfixed32 field_sfixed32 = 14;
case 14: {
let values = message.field_sfixed32 || (message.field_sfixed32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt32(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readInt32(bb));
}
break;
}
// repeated float field_float = 15;
case 15: {
let values = message.field_float || (message.field_float = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readFloat(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readFloat(bb));
}
break;
}
// repeated Nested field_nested = 16;
case 16: {
let limit = pushTemporaryLength(bb);
let values = message.field_nested || (message.field_nested = []);
values.push(_decodeNested(bb));
bb.limit = limit;
break;
}
default:
skipUnknownField(bb, tag & 7);
}
}
return message;
}
function encodeRepeatedPacked(message) {
let bb = popByteBuffer();
_encodeRepeatedPacked(message, bb);
return toUint8Array(bb);
}
exports.encodeRepeatedPacked = encodeRepeatedPacked;
function _encodeRepeatedPacked(message, bb) {
// repeated int32 field_int32 = 1;
let array$field_int32 = message.field_int32;
if (array$field_int32 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_int32) {
writeVarint64(packed, intToLong(value));
}
writeVarint32(bb, 10);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated int64 field_int64 = 2;
let array$field_int64 = message.field_int64;
if (array$field_int64 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_int64) {
writeVarint64(packed, value);
}
writeVarint32(bb, 18);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated uint32 field_uint32 = 3;
let array$field_uint32 = message.field_uint32;
if (array$field_uint32 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_uint32) {
writeVarint32(packed, value);
}
writeVarint32(bb, 26);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated uint64 field_uint64 = 4;
let array$field_uint64 = message.field_uint64;
if (array$field_uint64 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_uint64) {
writeVarint64(packed, value);
}
writeVarint32(bb, 34);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated sint32 field_sint32 = 5;
let array$field_sint32 = message.field_sint32;
if (array$field_sint32 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_sint32) {
writeVarint32ZigZag(packed, value);
}
writeVarint32(bb, 42);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated sint64 field_sint64 = 6;
let array$field_sint64 = message.field_sint64;
if (array$field_sint64 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_sint64) {
writeVarint64ZigZag(packed, value);
}
writeVarint32(bb, 50);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated bool field_bool = 7;
let array$field_bool = message.field_bool;
if (array$field_bool !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_bool) {
writeByte(packed, value ? 1 : 0);
}
writeVarint32(bb, 58);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated fixed64 field_fixed64 = 8;
let array$field_fixed64 = message.field_fixed64;
if (array$field_fixed64 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_fixed64) {
writeInt64(packed, value);
}
writeVarint32(bb, 66);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated sfixed64 field_sfixed64 = 9;
let array$field_sfixed64 = message.field_sfixed64;
if (array$field_sfixed64 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_sfixed64) {
writeInt64(packed, value);
}
writeVarint32(bb, 74);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated double field_double = 10;
let array$field_double = message.field_double;
if (array$field_double !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_double) {
writeDouble(packed, value);
}
writeVarint32(bb, 82);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated string field_string = 11;
let array$field_string = message.field_string;
if (array$field_string !== undefined) {
for (let value of array$field_string) {
writeVarint32(bb, 90);
writeString(bb, value);
}
}
// repeated bytes field_bytes = 12;
let array$field_bytes = message.field_bytes;
if (array$field_bytes !== undefined) {
for (let value of array$field_bytes) {
writeVarint32(bb, 98);
writeVarint32(bb, value.length), writeBytes(bb, value);
}
}
// repeated fixed32 field_fixed32 = 13;
let array$field_fixed32 = message.field_fixed32;
if (array$field_fixed32 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_fixed32) {
writeInt32(packed, value);
}
writeVarint32(bb, 106);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated sfixed32 field_sfixed32 = 14;
let array$field_sfixed32 = message.field_sfixed32;
if (array$field_sfixed32 !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_sfixed32) {
writeInt32(packed, value);
}
writeVarint32(bb, 114);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated float field_float = 15;
let array$field_float = message.field_float;
if (array$field_float !== undefined) {
let packed = popByteBuffer();
for (let value of array$field_float) {
writeFloat(packed, value);
}
writeVarint32(bb, 122);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
// repeated Nested field_nested = 16;
let array$field_nested = message.field_nested;
if (array$field_nested !== undefined) {
for (let value of array$field_nested) {
writeVarint32(bb, 130);
let nested = popByteBuffer();
_encodeNested(value, nested);
writeVarint32(bb, nested.limit);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
}
function decodeRepeatedPacked(binary) {
return _decodeRepeatedPacked(wrapByteBuffer(binary));
}
exports.decodeRepeatedPacked = decodeRepeatedPacked;
function _decodeRepeatedPacked(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// repeated int32 field_int32 = 1;
case 1: {
let values = message.field_int32 || (message.field_int32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32(bb));
}
break;
}
// repeated int64 field_int64 = 2;
case 2: {
let values = message.field_int64 || (message.field_int64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64(bb, /* unsigned */ false));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64(bb, /* unsigned */ false));
}
break;
}
// repeated uint32 field_uint32 = 3;
case 3: {
let values = message.field_uint32 || (message.field_uint32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32(bb) >>> 0);
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32(bb) >>> 0);
}
break;
}
// repeated uint64 field_uint64 = 4;
case 4: {
let values = message.field_uint64 || (message.field_uint64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64(bb, /* unsigned */ true));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64(bb, /* unsigned */ true));
}
break;
}
// repeated sint32 field_sint32 = 5;
case 5: {
let values = message.field_sint32 || (message.field_sint32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint32ZigZag(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint32ZigZag(bb));
}
break;
}
// repeated sint64 field_sint64 = 6;
case 6: {
let values = message.field_sint64 || (message.field_sint64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readVarint64ZigZag(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readVarint64ZigZag(bb));
}
break;
}
// repeated bool field_bool = 7;
case 7: {
let values = message.field_bool || (message.field_bool = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(!!readByte(bb));
}
bb.limit = outerLimit;
}
else {
values.push(!!readByte(bb));
}
break;
}
// repeated fixed64 field_fixed64 = 8;
case 8: {
let values = message.field_fixed64 || (message.field_fixed64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt64(bb, /* unsigned */ true));
}
bb.limit = outerLimit;
}
else {
values.push(readInt64(bb, /* unsigned */ true));
}
break;
}
// repeated sfixed64 field_sfixed64 = 9;
case 9: {
let values = message.field_sfixed64 || (message.field_sfixed64 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt64(bb, /* unsigned */ false));
}
bb.limit = outerLimit;
}
else {
values.push(readInt64(bb, /* unsigned */ false));
}
break;
}
// repeated double field_double = 10;
case 10: {
let values = message.field_double || (message.field_double = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readDouble(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readDouble(bb));
}
break;
}
// repeated string field_string = 11;
case 11: {
let values = message.field_string || (message.field_string = []);
values.push(readString(bb, readVarint32(bb)));
break;
}
// repeated bytes field_bytes = 12;
case 12: {
let values = message.field_bytes || (message.field_bytes = []);
values.push(readBytes(bb, readVarint32(bb)));
break;
}
// repeated fixed32 field_fixed32 = 13;
case 13: {
let values = message.field_fixed32 || (message.field_fixed32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt32(bb) >>> 0);
}
bb.limit = outerLimit;
}
else {
values.push(readInt32(bb) >>> 0);
}
break;
}
// repeated sfixed32 field_sfixed32 = 14;
case 14: {
let values = message.field_sfixed32 || (message.field_sfixed32 = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readInt32(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readInt32(bb));
}
break;
}
// repeated float field_float = 15;
case 15: {
let values = message.field_float || (message.field_float = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(readFloat(bb));
}
bb.limit = outerLimit;
}
else {
values.push(readFloat(bb));
}
break;
}
// repeated Nested field_nested = 16;
case 16: {
let limit = pushTemporaryLength(bb);
let values = message.field_nested || (message.field_nested = []);
values.push(_decodeNested(bb));
bb.limit = limit;
break;
}
default:
skipUnknownField(bb, tag & 7);
}
}
return message;
}
function encodeEnumTest(message) {
let bb = popByteBuffer();
_encodeEnumTest(message, bb);
return toUint8Array(bb);
}
exports.encodeEnumTest = encodeEnumTest;
function _encodeEnumTest(message, bb) {
// optional Enum a = 1;
let $a = message.a;
if ($a !== undefined) {
writeVarint32(bb, 8);
writeVarint32(bb, exports.encodeEnum[$a]);
}
// required Enum b = 2;
let $b = message.b;
if ($b !== undefined) {
writeVarint32(bb, 16);
writeVarint32(bb, exports.encodeEnum[$b]);
}
// repeated Enum c = 3;
let array$c = message.c;
if (array$c !== undefined) {
let packed = popByteBuffer();
for (let value of array$c) {
writeVarint32(packed, exports.encodeEnum[value]);
}
writeVarint32(bb, 26);
writeVarint32(bb, packed.offset);
writeByteBuffer(bb, packed);
pushByteBuffer(packed);
}
}
function decodeEnumTest(binary) {
return _decodeEnumTest(wrapByteBuffer(binary));
}
exports.decodeEnumTest = decodeEnumTest;
function _decodeEnumTest(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// optional Enum a = 1;
case 1: {
message.a = exports.decodeEnum[readVarint32(bb)];
break;
}
// required Enum b = 2;
case 2: {
message.b = exports.decodeEnum[readVarint32(bb)];
break;
}
// repeated Enum c = 3;
case 3: {
let values = message.c || (message.c = []);
if ((tag & 7) === 2) {
let outerLimit = pushTemporaryLength(bb);
while (!isAtEnd(bb)) {
values.push(exports.decodeEnum[readVarint32(bb)]);
}
bb.limit = outerLimit;
}
else {
values.push(exports.decodeEnum[readVarint32(bb)]);
}
break;
}
default:
skipUnknownField(bb, tag & 7);
}
}
if (message.b === undefined)
throw new Error("Missing required field: b");
return message;
}
function encodeMapTestIntAndString(message) {
let bb = popByteBuffer();
_encodeMapTestIntAndString(message, bb);
return toUint8Array(bb);
}
exports.encodeMapTestIntAndString = encodeMapTestIntAndString;
function _encodeMapTestIntAndString(message, bb) {
// optional map<int32, bool> field_int32 = 1;
let map$field_int32 = message.field_int32;
if (map$field_int32 !== undefined) {
for (let key in map$field_int32) {
let nested = popByteBuffer();
let value = map$field_int32[key];
writeVarint32(nested, 8);
writeVarint64(nested, intToLong(+key));
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 10);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
// optional map<uint32, bool> field_uint32 = 2;
let map$field_uint32 = message.field_uint32;
if (map$field_uint32 !== undefined) {
for (let key in map$field_uint32) {
let nested = popByteBuffer();
let value = map$field_uint32[key];
writeVarint32(nested, 8);
writeVarint32(nested, +key);
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 18);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
// optional map<sint32, bool> field_sint32 = 3;
let map$field_sint32 = message.field_sint32;
if (map$field_sint32 !== undefined) {
for (let key in map$field_sint32) {
let nested = popByteBuffer();
let value = map$field_sint32[key];
writeVarint32(nested, 8);
writeVarint32ZigZag(nested, +key);
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 26);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
// optional map<string, bool> field_string = 5;
let map$field_string = message.field_string;
if (map$field_string !== undefined) {
for (let key in map$field_string) {
let nested = popByteBuffer();
let value = map$field_string[key];
writeVarint32(nested, 10);
writeString(nested, key);
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 42);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
// optional map<fixed32, bool> field_fixed32 = 6;
let map$field_fixed32 = message.field_fixed32;
if (map$field_fixed32 !== undefined) {
for (let key in map$field_fixed32) {
let nested = popByteBuffer();
let value = map$field_fixed32[key];
writeVarint32(nested, 13);
writeInt32(nested, +key);
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 50);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
// optional map<sfixed32, bool> field_sfixed32 = 7;
let map$field_sfixed32 = message.field_sfixed32;
if (map$field_sfixed32 !== undefined) {
for (let key in map$field_sfixed32) {
let nested = popByteBuffer();
let value = map$field_sfixed32[key];
writeVarint32(nested, 13);
writeInt32(nested, +key);
writeVarint32(nested, 16);
writeByte(nested, value ? 1 : 0);
writeVarint32(bb, 58);
writeVarint32(bb, nested.offset);
writeByteBuffer(bb, nested);
pushByteBuffer(nested);
}
}
}
function decodeMapTestIntAndString(binary) {
return _decodeMapTestIntAndString(wrapByteBuffer(binary));
}
exports.decodeMapTestIntAndString = decodeMapTestIntAndString;
function _decodeMapTestIntAndString(bb) {
let message = {};
end_of_message: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_message;
// optional map<int32, bool> field_int32 = 1;
case 1: {
let values = message.field_int32 || (message.field_int32 = {});
let outerLimit = pushTemporaryLength(bb);
let key;
let value;
end_of_entry: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_entry;
case 1:
key = readVarint32(bb);
break;
case 2:
value = !!readByte(bb);
break;
default:
skipUnknownField(bb, tag & 7);
}
}
if (key === undefined || value === undefined)
throw new Error("Invalid data for map: field_int32");
values[key] = value;
bb.limit = outerLimit;
break;
}
// optional map<uint32, bool> field_uint32 = 2;
case 2: {
let values = message.field_uint32 || (message.field_uint32 = {});
let outerLimit = pushTemporaryLength(bb);
let key;
let value;
end_of_entry: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_entry;
case 1:
key = readVarint32(bb) >>> 0;
break;
case 2:
value = !!readByte(bb);
break;
default:
skipUnknownField(bb, tag & 7);
}
}
if (key === undefined || value === undefined)
throw new Error("Invalid data for map: field_uint32");
values[key] = value;
bb.limit = outerLimit;
break;
}
// optional map<sint32, bool> field_sint32 = 3;
case 3: {
let values = message.field_sint32 || (message.field_sint32 = {});
let outerLimit = pushTemporaryLength(bb);
let key;
let value;
end_of_entry: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_entry;
case 1:
key = readVarint32ZigZag(bb);
break;
case 2:
value = !!readByte(bb);
break;
default:
skipUnknownField(bb, tag & 7);
}
}
if (key === undefined || value === undefined)
throw new Error("Invalid data for map: field_sint32");
values[key] = value;
bb.limit = outerLimit;
break;
}
// optional map<string, bool> field_string = 5;
case 5: {
let values = message.field_string || (message.field_string = {});
let outerLimit = pushTemporaryLength(bb);
let key;
let value;
end_of_entry: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_entry;
case 1:
key = readString(bb, readVarint32(bb));
break;
case 2:
value = !!readByte(bb);
break;
default:
skipUnknownField(bb, tag & 7);
}
}
if (key === undefined || value === undefined)
throw new Error("Invalid data for map: field_string");
values[key] = value;
bb.limit = outerLimit;
break;
}
// optional map<fixed32, bool> field_fixed32 = 6;
case 6: {
let values = message.field_fixed32 || (message.field_fixed32 = {});
let outerLimit = pushTemporaryLength(bb);
let key;
let value;
end_of_entry: while (!isAtEnd(bb)) {
let tag = readVarint32(bb);
switch (tag >>> 3) {
case 0:
break end_of_entry;
case 1:
key = readInt32(bb) >>> 0;
break;
case 2:
value = !!readByte(bb);
break;
default:
skipUnknownField(bb, tag & 7);
}
}
if (key === undefined || value === undefined)
throw new Error("Invalid data for map: field_fixed32");
values[key] = value;