Lines Matching refs:value
288 * @param {jspb.AnyFieldType} value
290 jspb.BinaryWriter.prototype.writeAny = function(fieldType, field, value) {
294 this.writeDouble(field, /** @type {number} */(value));
297 this.writeFloat(field, /** @type {number} */(value));
300 this.writeInt64(field, /** @type {number} */(value));
303 this.writeUint64(field, /** @type {number} */(value));
306 this.writeInt32(field, /** @type {number} */(value));
309 this.writeFixed64(field, /** @type {number} */(value));
312 this.writeFixed32(field, /** @type {number} */(value));
315 this.writeBool(field, /** @type {boolean} */(value));
318 this.writeString(field, /** @type {string} */(value));
327 this.writeBytes(field, /** @type {?Uint8Array} */(value));
330 this.writeUint32(field, /** @type {number} */(value));
333 this.writeEnum(field, /** @type {number} */(value));
336 this.writeSfixed32(field, /** @type {number} */(value));
339 this.writeSfixed64(field, /** @type {number} */(value));
342 this.writeSint32(field, /** @type {number} */(value));
345 this.writeSint64(field, /** @type {number} */(value));
348 this.writeFixedHash64(field, /** @type {string} */(value));
351 this.writeVarintHash64(field, /** @type {string} */(value));
363 * @param {number?} value The value to write.
366 jspb.BinaryWriter.prototype.writeUnsignedVarint32_ = function(field, value) {
367 if (value == null) return;
369 this.encoder_.writeUnsignedVarint32(value);
376 * @param {number?} value The value to write.
379 jspb.BinaryWriter.prototype.writeSignedVarint32_ = function(field, value) {
380 if (value == null) return;
382 this.encoder_.writeSignedVarint32(value);
389 * @param {number?} value The value to write.
392 jspb.BinaryWriter.prototype.writeUnsignedVarint64_ = function(field, value) {
393 if (value == null) return;
395 this.encoder_.writeUnsignedVarint64(value);
402 * @param {number?} value The value to write.
405 jspb.BinaryWriter.prototype.writeSignedVarint64_ = function(field, value) {
406 if (value == null) return;
408 this.encoder_.writeSignedVarint64(value);
415 * @param {number?} value The value to write.
418 jspb.BinaryWriter.prototype.writeZigzagVarint32_ = function(field, value) {
419 if (value == null) return;
421 this.encoder_.writeZigzagVarint32(value);
428 * @param {number?} value The value to write.
431 jspb.BinaryWriter.prototype.writeZigzagVarint64_ = function(field, value) {
432 if (value == null) return;
434 this.encoder_.writeZigzagVarint64(value);
441 * @param {string?} value The value to write.
445 field, value) {
446 if (value == null) return;
448 this.encoder_.writeZigzagVarint64String(value);
455 * @param {string?} value The value to write.
458 jspb.BinaryWriter.prototype.writeZigzagVarintHash64_ = function(field, value) {
459 if (value == null) return;
461 this.encoder_.writeZigzagVarintHash64(value);
469 * @param {number?} value The value to write.
471 jspb.BinaryWriter.prototype.writeInt32 = function(field, value) {
472 if (value == null) return;
473 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_31) &&
474 (value < jspb.BinaryConstants.TWO_TO_31));
475 this.writeSignedVarint32_(field, value);
483 * @param {string?} value The value to write.
485 jspb.BinaryWriter.prototype.writeInt32String = function(field, value) {
486 if (value == null) return;
487 var intValue = /** {number} */ parseInt(value, 10);
498 * @param {number?} value The value to write.
500 jspb.BinaryWriter.prototype.writeInt64 = function(field, value) {
501 if (value == null) return;
502 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_63) &&
503 (value < jspb.BinaryConstants.TWO_TO_63));
504 this.writeSignedVarint64_(field, value);
509 * Writes a int64 field (with value as a string) to the buffer.
511 * @param {string?} value The value to write.
513 jspb.BinaryWriter.prototype.writeInt64String = function(field, value) {
514 if (value == null) return;
515 var num = jspb.arith.Int64.fromString(value);
525 * @param {number?} value The value to write.
527 jspb.BinaryWriter.prototype.writeUint32 = function(field, value) {
528 if (value == null) return;
529 goog.asserts.assert((value >= 0) &&
530 (value < jspb.BinaryConstants.TWO_TO_32));
531 this.writeUnsignedVarint32_(field, value);
539 * @param {string?} value The value to write.
541 jspb.BinaryWriter.prototype.writeUint32String = function(field, value) {
542 if (value == null) return;
543 var intValue = /** {number} */ parseInt(value, 10);
554 * @param {number?} value The value to write.
556 jspb.BinaryWriter.prototype.writeUint64 = function(field, value) {
557 if (value == null) return;
558 goog.asserts.assert((value >= 0) &&
559 (value < jspb.BinaryConstants.TWO_TO_64));
560 this.writeUnsignedVarint64_(field, value);
565 * Writes a uint64 field (with value as a string) to the buffer.
567 * @param {string?} value The value to write.
569 jspb.BinaryWriter.prototype.writeUint64String = function(field, value) {
570 if (value == null) return;
571 var num = jspb.arith.UInt64.fromString(value);
581 * @param {number?} value The value to write.
583 jspb.BinaryWriter.prototype.writeSint32 = function(field, value) {
584 if (value == null) return;
585 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_31) &&
586 (value < jspb.BinaryConstants.TWO_TO_31));
587 this.writeZigzagVarint32_(field, value);
595 * @param {number?} value The value to write.
597 jspb.BinaryWriter.prototype.writeSint64 = function(field, value) {
598 if (value == null) return;
599 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_63) &&
600 (value < jspb.BinaryConstants.TWO_TO_63));
601 this.writeZigzagVarint64_(field, value);
606 * Writes an sint64 field to the buffer from a hash64 encoded value. Numbers
609 * @param {string?} value The hash64 string to write.
611 jspb.BinaryWriter.prototype.writeSintHash64 = function(field, value) {
612 if (value == null) return;
613 this.writeZigzagVarintHash64_(field, value);
621 * @param {string?} value The decimal string to write.
623 jspb.BinaryWriter.prototype.writeSint64String = function(field, value) {
624 if (value == null) return;
625 this.writeZigzagVarint64String_(field, value);
633 * @param {number?} value The value to write.
635 jspb.BinaryWriter.prototype.writeFixed32 = function(field, value) {
636 if (value == null) return;
637 goog.asserts.assert((value >= 0) &&
638 (value < jspb.BinaryConstants.TWO_TO_32));
640 this.encoder_.writeUint32(value);
648 * @param {number?} value The value to write.
650 jspb.BinaryWriter.prototype.writeFixed64 = function(field, value) {
651 if (value == null) return;
652 goog.asserts.assert((value >= 0) &&
653 (value < jspb.BinaryConstants.TWO_TO_64));
655 this.encoder_.writeUint64(value);
660 * Writes a fixed64 field (with value as a string) to the buffer.
662 * @param {string?} value The value to write.
664 jspb.BinaryWriter.prototype.writeFixed64String = function(field, value) {
665 if (value == null) return;
666 var num = jspb.arith.UInt64.fromString(value);
676 * @param {number?} value The value to write.
678 jspb.BinaryWriter.prototype.writeSfixed32 = function(field, value) {
679 if (value == null) return;
680 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_31) &&
681 (value < jspb.BinaryConstants.TWO_TO_31));
683 this.encoder_.writeInt32(value);
691 * @param {number?} value The value to write.
693 jspb.BinaryWriter.prototype.writeSfixed64 = function(field, value) {
694 if (value == null) return;
695 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_63) &&
696 (value < jspb.BinaryConstants.TWO_TO_63));
698 this.encoder_.writeInt64(value);
706 * @param {string?} value The value to write.
708 jspb.BinaryWriter.prototype.writeSfixed64String = function(field, value) {
709 if (value == null) return;
710 var num = jspb.arith.Int64.fromString(value);
720 * @param {number?} value The value to write.
722 jspb.BinaryWriter.prototype.writeFloat = function(field, value) {
723 if (value == null) return;
725 this.encoder_.writeFloat(value);
733 * @param {number?} value The value to write.
735 jspb.BinaryWriter.prototype.writeDouble = function(field, value) {
736 if (value == null) return;
738 this.encoder_.writeDouble(value);
747 * @param {boolean?|number?} value The value to write.
749 jspb.BinaryWriter.prototype.writeBool = function(field, value) {
750 if (value == null) return;
751 goog.asserts.assert(typeof value === 'boolean' || typeof value === 'number');
753 this.encoder_.writeBool(value);
760 * @param {number?} value The value to write.
762 jspb.BinaryWriter.prototype.writeEnum = function(field, value) {
763 if (value == null) return;
764 goog.asserts.assert((value >= -jspb.BinaryConstants.TWO_TO_31) &&
765 (value < jspb.BinaryConstants.TWO_TO_31));
767 this.encoder_.writeSignedVarint32(value);
774 * @param {string?} value The string to write.
776 jspb.BinaryWriter.prototype.writeString = function(field, value) {
777 if (value == null) return;
779 this.encoder_.writeString(value);
788 * @param {?jspb.ByteSource} value The array of bytes to write.
790 jspb.BinaryWriter.prototype.writeBytes = function(field, value) {
791 if (value == null) return;
792 var bytes = jspb.utils.byteSourceToUint8Array(value);
802 * @param {?MessageType} value The message to write.
804 * Will be invoked with the value to write and the writer to write it with.
808 * infer MessageType to be nullable if the value parameter is nullable.
816 field, value, writerCallback) {
817 if (value == null) return;
819 writerCallback(value, this);
827 * @param {?MessageType} value The extension message object to write. Note that
830 * Will be invoked with the value to write and the writer to write it with.
834 * infer MessageType to be nullable if the value parameter is nullable.
842 field, value, writerCallback) {
843 if (value == null) return;
850 writerCallback(value, this);
860 * @param {?MessageType} value The message to write, wrapped with START_GROUP /
861 * END_GROUP tags. Will be a no-op if 'value' is null.
863 * Will be invoked with the value to write and the writer to write it with.
867 * infer MessageType to be nullable if the value parameter is nullable.
875 field, value, writerCallback) {
876 if (value == null) return;
878 writerCallback(value, this);
887 * @param {string?} value The hash string.
889 jspb.BinaryWriter.prototype.writeFixedHash64 = function(field, value) {
890 if (value == null) return;
891 goog.asserts.assert(value.length == 8);
893 this.encoder_.writeFixedHash64(value);
901 * @param {string?} value The hash string.
903 jspb.BinaryWriter.prototype.writeVarintHash64 = function(field, value) {
904 if (value == null) return;
905 goog.asserts.assert(value.length == 8);
907 this.encoder_.writeVarintHash64(value);
956 * @param {?Array<number>} value The array of ints to write.
958 jspb.BinaryWriter.prototype.writeRepeatedInt32 = function(field, value) {
959 if (value == null) return;
960 for (var i = 0; i < value.length; i++) {
961 this.writeSignedVarint32_(field, value[i]);
970 * @param {?Array<string>} value The array of ints to write.
972 jspb.BinaryWriter.prototype.writeRepeatedInt32String = function(field, value) {
973 if (value == null) return;
974 for (var i = 0; i < value.length; i++) {
975 this.writeInt32String(field, value[i]);
983 * @param {?Array<number>} value The array of ints to write.
985 jspb.BinaryWriter.prototype.writeRepeatedInt64 = function(field, value) {
986 if (value == null) return;
987 for (var i = 0; i < value.length; i++) {
988 this.writeSignedVarint64_(field, value[i]);
996 * @param {?Array<T>} value The value.
1002 field, value, lo, hi) {
1003 if (value == null) return;
1004 for (var i = 0; i < value.length; i++) {
1005 this.writeSplitFixed64(field, lo(value[i]), hi(value[i]));
1013 * @param {?Array<T>} value The value.
1019 field, value, lo, hi) {
1020 if (value == null) return;
1021 for (var i = 0; i < value.length; i++) {
1022 this.writeSplitVarint64(field, lo(value[i]), hi(value[i]));
1030 * @param {?Array<T>} value The value.
1036 field, value, lo, hi) {
1037 if (value == null) return;
1038 for (var i = 0; i < value.length; i++) {
1039 this.writeSplitZigzagVarint64(field, lo(value[i]), hi(value[i]));
1048 * @param {?Array<string>} value The array of ints to write.
1050 jspb.BinaryWriter.prototype.writeRepeatedInt64String = function(field, value) {
1051 if (value == null) return;
1052 for (var i = 0; i < value.length; i++) {
1053 this.writeInt64String(field, value[i]);
1062 * @param {?Array<number>} value The array of ints to write.
1064 jspb.BinaryWriter.prototype.writeRepeatedUint32 = function(field, value) {
1065 if (value == null) return;
1066 for (var i = 0; i < value.length; i++) {
1067 this.writeUnsignedVarint32_(field, value[i]);
1076 * @param {?Array<string>} value The array of ints to write.
1078 jspb.BinaryWriter.prototype.writeRepeatedUint32String = function(field, value) {
1079 if (value == null) return;
1080 for (var i = 0; i < value.length; i++) {
1081 this.writeUint32String(field, value[i]);
1090 * @param {?Array<number>} value The array of ints to write.
1092 jspb.BinaryWriter.prototype.writeRepeatedUint64 = function(field, value) {
1093 if (value == null) return;
1094 for (var i = 0; i < value.length; i++) {
1095 this.writeUnsignedVarint64_(field, value[i]);
1104 * @param {?Array<string>} value The array of ints to write.
1106 jspb.BinaryWriter.prototype.writeRepeatedUint64String = function(field, value) {
1107 if (value == null) return;
1108 for (var i = 0; i < value.length; i++) {
1109 this.writeUint64String(field, value[i]);
1117 * @param {?Array<number>} value The array of ints to write.
1119 jspb.BinaryWriter.prototype.writeRepeatedSint32 = function(field, value) {
1120 if (value == null) return;
1121 for (var i = 0; i < value.length; i++) {
1122 this.writeZigzagVarint32_(field, value[i]);
1130 * @param {?Array<number>} value The array of ints to write.
1132 jspb.BinaryWriter.prototype.writeRepeatedSint64 = function(field, value) {
1133 if (value == null) return;
1134 for (var i = 0; i < value.length; i++) {
1135 this.writeZigzagVarint64_(field, value[i]);
1143 * @param {?Array<string>} value The array of ints to write.
1145 jspb.BinaryWriter.prototype.writeRepeatedSint64String = function(field, value) {
1146 if (value == null) return;
1147 for (var i = 0; i < value.length; i++) {
1148 this.writeZigzagVarint64String_(field, value[i]);
1157 * @param {?Array<string>} value The array of ints to write.
1159 jspb.BinaryWriter.prototype.writeRepeatedSintHash64 = function(field, value) {
1160 if (value == null) return;
1161 for (var i = 0; i < value.length; i++) {
1162 this.writeZigzagVarintHash64_(field, value[i]);
1171 * @param {?Array<number>} value The array of ints to write.
1173 jspb.BinaryWriter.prototype.writeRepeatedFixed32 = function(field, value) {
1174 if (value == null) return;
1175 for (var i = 0; i < value.length; i++) {
1176 this.writeFixed32(field, value[i]);
1185 * @param {?Array<number>} value The array of ints to write.
1187 jspb.BinaryWriter.prototype.writeRepeatedFixed64 = function(field, value) {
1188 if (value == null) return;
1189 for (var i = 0; i < value.length; i++) {
1190 this.writeFixed64(field, value[i]);
1199 * @param {?Array<string>} value The array of decimal strings to write.
1202 field, value) {
1203 if (value == null) return;
1204 for (var i = 0; i < value.length; i++) {
1205 this.writeFixed64String(field, value[i]);
1213 * @param {?Array<number>} value The array of ints to write.
1215 jspb.BinaryWriter.prototype.writeRepeatedSfixed32 = function(field, value) {
1216 if (value == null) return;
1217 for (var i = 0; i < value.length; i++) {
1218 this.writeSfixed32(field, value[i]);
1226 * @param {?Array<number>} value The array of ints to write.
1228 jspb.BinaryWriter.prototype.writeRepeatedSfixed64 = function(field, value) {
1229 if (value == null) return;
1230 for (var i = 0; i < value.length; i++) {
1231 this.writeSfixed64(field, value[i]);
1240 * @param {?Array<string>} value The array of decimal strings to write.
1242 jspb.BinaryWriter.prototype.writeRepeatedSfixed64String = function(field, value) {
1243 if (value == null) return;
1244 for (var i = 0; i < value.length; i++) {
1245 this.writeSfixed64String(field, value[i]);
1253 * @param {?Array<number>} value The array of ints to write.
1255 jspb.BinaryWriter.prototype.writeRepeatedFloat = function(field, value) {
1256 if (value == null) return;
1257 for (var i = 0; i < value.length; i++) {
1258 this.writeFloat(field, value[i]);
1266 * @param {?Array<number>} value The array of ints to write.
1268 jspb.BinaryWriter.prototype.writeRepeatedDouble = function(field, value) {
1269 if (value == null) return;
1270 for (var i = 0; i < value.length; i++) {
1271 this.writeDouble(field, value[i]);
1279 * @param {?Array<boolean>} value The array of ints to write.
1281 jspb.BinaryWriter.prototype.writeRepeatedBool = function(field, value) {
1282 if (value == null) return;
1283 for (var i = 0; i < value.length; i++) {
1284 this.writeBool(field, value[i]);
1292 * @param {?Array<number>} value The array of ints to write.
1294 jspb.BinaryWriter.prototype.writeRepeatedEnum = function(field, value) {
1295 if (value == null) return;
1296 for (var i = 0; i < value.length; i++) {
1297 this.writeEnum(field, value[i]);
1305 * @param {?Array<string>} value The array of strings to write.
1307 jspb.BinaryWriter.prototype.writeRepeatedString = function(field, value) {
1308 if (value == null) return;
1309 for (var i = 0; i < value.length; i++) {
1310 this.writeString(field, value[i]);
1318 * @param {?Array<!jspb.ByteSource>} value The arrays of arrays of bytes to
1321 jspb.BinaryWriter.prototype.writeRepeatedBytes = function(field, value) {
1322 if (value == null) return;
1323 for (var i = 0; i < value.length; i++) {
1324 this.writeBytes(field, value[i]);
1333 * @param {?Array<MessageType>} value The array of messages to
1336 * Will be invoked with the value to write and the writer to write it with.
1339 field, value, writerCallback) {
1340 if (value == null) return;
1341 for (var i = 0; i < value.length; i++) {
1343 writerCallback(value[i], this);
1353 * @param {?Array<MessageType>} value The array of messages to
1356 * Will be invoked with the value to write and the writer to write it with.
1359 field, value, writerCallback) {
1360 if (value == null) return;
1361 for (var i = 0; i < value.length; i++) {
1363 writerCallback(value[i], this);
1373 * @param {?Array<string>} value The array of hashes to write.
1376 function(field, value) {
1377 if (value == null) return;
1378 for (var i = 0; i < value.length; i++) {
1379 this.writeFixedHash64(field, value[i]);
1388 * @param {?Array<string>} value The array of hashes to write.
1391 function(field, value) {
1392 if (value == null) return;
1393 for (var i = 0; i < value.length; i++) {
1394 this.writeVarintHash64(field, value[i]);
1402 * @param {?Array<number>} value The array of ints to write.
1404 jspb.BinaryWriter.prototype.writePackedInt32 = function(field, value) {
1405 if (value == null || !value.length) return;
1407 for (var i = 0; i < value.length; i++) {
1408 this.encoder_.writeSignedVarint32(value[i]);
1418 * @param {?Array<string>} value
1420 jspb.BinaryWriter.prototype.writePackedInt32String = function(field, value) {
1421 if (value == null || !value.length) return;
1423 for (var i = 0; i < value.length; i++) {
1424 this.encoder_.writeSignedVarint32(parseInt(value[i], 10));
1433 * @param {?Array<number>} value The array of ints to write.
1435 jspb.BinaryWriter.prototype.writePackedInt64 = function(field, value) {
1436 if (value == null || !value.length) return;
1438 for (var i = 0; i < value.length; i++) {
1439 this.encoder_.writeSignedVarint64(value[i]);
1448 * @param {?Array<T>} value The value.
1454 field, value, lo, hi) {
1455 if (value == null) return;
1457 for (var i = 0; i < value.length; i++) {
1458 this.encoder_.writeSplitFixed64(lo(value[i]), hi(value[i]));
1467 * @param {?Array<T>} value The value.
1473 field, value, lo, hi) {
1474 if (value == null) return;
1476 for (var i = 0; i < value.length; i++) {
1477 this.encoder_.writeSplitVarint64(lo(value[i]), hi(value[i]));
1486 * @param {?Array<T>} value The value.
1492 field, value, lo, hi) {
1493 if (value == null) return;
1496 for (var i = 0; i < value.length; i++) {
1498 lo(value[i]), hi(value[i]), function(bitsLow, bitsHigh) {
1510 * @param {?Array<string>} value
1512 jspb.BinaryWriter.prototype.writePackedInt64String = function(field, value) {
1513 if (value == null || !value.length) return;
1515 for (var i = 0; i < value.length; i++) {
1516 var num = jspb.arith.Int64.fromString(value[i]);
1526 * @param {?Array<number>} value The array of ints to write.
1528 jspb.BinaryWriter.prototype.writePackedUint32 = function(field, value) {
1529 if (value == null || !value.length) return;
1531 for (var i = 0; i < value.length; i++) {
1532 this.encoder_.writeUnsignedVarint32(value[i]);
1542 * @param {?Array<string>} value
1545 function(field, value) {
1546 if (value == null || !value.length) return;
1548 for (var i = 0; i < value.length; i++) {
1549 this.encoder_.writeUnsignedVarint32(parseInt(value[i], 10));
1558 * @param {?Array<number>} value The array of ints to write.
1560 jspb.BinaryWriter.prototype.writePackedUint64 = function(field, value) {
1561 if (value == null || !value.length) return;
1563 for (var i = 0; i < value.length; i++) {
1564 this.encoder_.writeUnsignedVarint64(value[i]);
1574 * @param {?Array<string>} value
1577 function(field, value) {
1578 if (value == null || !value.length) return;
1580 for (var i = 0; i < value.length; i++) {
1581 var num = jspb.arith.UInt64.fromString(value[i]);
1591 * @param {?Array<number>} value The array of ints to write.
1593 jspb.BinaryWriter.prototype.writePackedSint32 = function(field, value) {
1594 if (value == null || !value.length) return;
1596 for (var i = 0; i < value.length; i++) {
1597 this.encoder_.writeZigzagVarint32(value[i]);
1606 * @param {?Array<number>} value The array of ints to write.
1608 jspb.BinaryWriter.prototype.writePackedSint64 = function(field, value) {
1609 if (value == null || !value.length) return;
1611 for (var i = 0; i < value.length; i++) {
1612 this.encoder_.writeZigzagVarint64(value[i]);
1622 * @param {?Array<string>} value The array of decimal strings to write.
1624 jspb.BinaryWriter.prototype.writePackedSint64String = function(field, value) {
1625 if (value == null || !value.length) return;
1627 for (var i = 0; i < value.length; i++) {
1629 jspb.utils.decimalStringToHash64(value[i]));
1639 * @param {?Array<string>} value The array of decimal strings to write.
1641 jspb.BinaryWriter.prototype.writePackedSintHash64 = function(field, value) {
1642 if (value == null || !value.length) return;
1644 for (var i = 0; i < value.length; i++) {
1645 this.encoder_.writeZigzagVarintHash64(value[i]);
1654 * @param {?Array<number>} value The array of ints to write.
1656 jspb.BinaryWriter.prototype.writePackedFixed32 = function(field, value) {
1657 if (value == null || !value.length) return;
1659 this.encoder_.writeUnsignedVarint32(value.length * 4);
1660 for (var i = 0; i < value.length; i++) {
1661 this.encoder_.writeUint32(value[i]);
1669 * @param {?Array<number>} value The array of ints to write.
1671 jspb.BinaryWriter.prototype.writePackedFixed64 = function(field, value) {
1672 if (value == null || !value.length) return;
1674 this.encoder_.writeUnsignedVarint32(value.length * 8);
1675 for (var i = 0; i < value.length; i++) {
1676 this.encoder_.writeUint64(value[i]);
1685 * @param {?Array<string>} value The array of strings to write.
1687 jspb.BinaryWriter.prototype.writePackedFixed64String = function(field, value) {
1688 if (value == null || !value.length) return;
1690 this.encoder_.writeUnsignedVarint32(value.length * 8);
1691 for (var i = 0; i < value.length; i++) {
1692 var num = jspb.arith.UInt64.fromString(value[i]);
1701 * @param {?Array<number>} value The array of ints to write.
1703 jspb.BinaryWriter.prototype.writePackedSfixed32 = function(field, value) {
1704 if (value == null || !value.length) return;
1706 this.encoder_.writeUnsignedVarint32(value.length * 4);
1707 for (var i = 0; i < value.length; i++) {
1708 this.encoder_.writeInt32(value[i]);
1716 * @param {?Array<number>} value The array of ints to write.
1718 jspb.BinaryWriter.prototype.writePackedSfixed64 = function(field, value) {
1719 if (value == null || !value.length) return;
1721 this.encoder_.writeUnsignedVarint32(value.length * 8);
1722 for (var i = 0; i < value.length; i++) {
1723 this.encoder_.writeInt64(value[i]);
1731 * @param {?Array<string>} value The array of decimal strings to write.
1733 jspb.BinaryWriter.prototype.writePackedSfixed64String = function(field, value) {
1734 if (value == null || !value.length) return;
1736 this.encoder_.writeUnsignedVarint32(value.length * 8);
1737 for (var i = 0; i < value.length; i++) {
1738 this.encoder_.writeInt64String(value[i]);
1746 * @param {?Array<number>} value The array of ints to write.
1748 jspb.BinaryWriter.prototype.writePackedFloat = function(field, value) {
1749 if (value == null || !value.length) return;
1751 this.encoder_.writeUnsignedVarint32(value.length * 4);
1752 for (var i = 0; i < value.length; i++) {
1753 this.encoder_.writeFloat(value[i]);
1761 * @param {?Array<number>} value The array of ints to write.
1763 jspb.BinaryWriter.prototype.writePackedDouble = function(field, value) {
1764 if (value == null || !value.length) return;
1766 this.encoder_.writeUnsignedVarint32(value.length * 8);
1767 for (var i = 0; i < value.length; i++) {
1768 this.encoder_.writeDouble(value[i]);
1776 * @param {?Array<boolean>} value The array of ints to write.
1778 jspb.BinaryWriter.prototype.writePackedBool = function(field, value) {
1779 if (value == null || !value.length) return;
1781 this.encoder_.writeUnsignedVarint32(value.length);
1782 for (var i = 0; i < value.length; i++) {
1783 this.encoder_.writeBool(value[i]);
1791 * @param {?Array<number>} value The array of ints to write.
1793 jspb.BinaryWriter.prototype.writePackedEnum = function(field, value) {
1794 if (value == null || !value.length) return;
1796 for (var i = 0; i < value.length; i++) {
1797 this.encoder_.writeEnum(value[i]);
1807 * @param {?Array<string>} value The array of hashes to write.
1809 jspb.BinaryWriter.prototype.writePackedFixedHash64 = function(field, value) {
1810 if (value == null || !value.length) return;
1812 this.encoder_.writeUnsignedVarint32(value.length * 8);
1813 for (var i = 0; i < value.length; i++) {
1814 this.encoder_.writeFixedHash64(value[i]);
1823 * @param {?Array<string>} value The array of hashes to write.
1825 jspb.BinaryWriter.prototype.writePackedVarintHash64 = function(field, value) {
1826 if (value == null || !value.length) return;
1828 for (var i = 0; i < value.length; i++) {
1829 this.encoder_.writeVarintHash64(value[i]);