// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/**
* @fileoverview This file contains helper code used by jspb.BinaryReader
* and BinaryWriter.
*
* @author aappleby@google.com (Austin Appleby)
*/
goog.provide('jspb.utils');
goog.require('goog.asserts');
goog.require('goog.crypt.base64');
goog.require('goog.string');
goog.require('jspb.BinaryConstants');
/**
* Javascript can't natively handle 64-bit data types, so to manipulate them we
* have to split them into two 32-bit halves and do the math manually.
*
* Instead of instantiating and passing small structures around to do this, we
* instead just use two global temporary values. This one stores the low 32
* bits of a split value - for example, if the original value was a 64-bit
* integer, this temporary value will contain the low 32 bits of that integer.
* If the original value was a double, this temporary value will contain the
* low 32 bits of the binary representation of that double, etcetera.
* @type {number}
*/
jspb.utils.split64Low = 0;
/**
* And correspondingly, this temporary variable will contain the high 32 bits
* of whatever value was split.
* @type {number}
*/
jspb.utils.split64High = 0;
/**
* Splits an unsigned Javascript integer into two 32-bit halves and stores it
* in the temp values above.
* @param {number} value The number to split.
*/
jspb.utils.splitUint64 = function(value) {
// Extract low 32 bits and high 32 bits as unsigned integers.
var lowBits = value >>> 0;
var highBits = Math.floor((value - lowBits) /
jspb.BinaryConstants.TWO_TO_32) >>> 0;
jspb.utils.split64Low = lowBits;
jspb.utils.split64High = highBits;
};
/**
* Splits a signed Javascript integer into two 32-bit halves and stores it in
* the temp values above.
* @param {number} value The number to split.
*/
jspb.utils.splitInt64 = function(value) {
// Convert to sign-magnitude representation.
var sign = (value < 0);
value = Math.abs(value);
// Extract low 32 bits and high 32 bits as unsigned integers.
var lowBits = value >>> 0;
var highBits = Math.floor((value - lowBits) /
jspb.BinaryConstants.TWO_TO_32);
highBits = highBits >>> 0;
// Perform two's complement conversion if the sign bit was set.
if (sign) {
highBits = ~highBits >>> 0;
lowBits = ~lowBits >>> 0;
lowBits += 1;
if (lowBits > 0xFFFFFFFF) {
lowBits = 0;
highBits++;
if (highBits > 0xFFFFFFFF) highBits = 0;
}
}
jspb.utils.split64Low = lowBits;
jspb.utils.split64High = highBits;
};
/**
* Convers a signed Javascript integer into zigzag format, splits it into two
* 32-bit halves, and stores it in the temp values above.
* @param {number} value The number to split.
*/
jspb.utils.splitZigzag64 = function(value) {
// Convert to sign-magnitude and scale by 2 before we split the value.
var sign = (value < 0);
value = Math.abs(value) * 2;
jspb.utils.splitUint64(value);
var lowBits = jspb.utils.split64Low;
var highBits = jspb.utils.split64High;
// If the value is negative, subtract 1 from the split representation so we
// don't lose the sign bit due to precision issues.
if (sign) {
if (lowBits == 0) {
if (highBits == 0) {
lowBits = 0xFFFFFFFF;
highBits = 0xFFFFFFFF;
} else {
highBits--;
lowBits = 0xFFFFFFFF;
}
} else {
lowBits--;
}
}
jspb.utils.split64Low = lowBits;
jspb.utils.split64High = highBits;
};
/**
* Converts a floating-point number into 32-bit IEEE representation and stores
* it in the temp values above.
* @param {number} value
*/
jspb.utils.splitFloat32 = function(value) {
var sign = (value < 0) ? 1 : 0;
value = sign ? -value : value;
var exp;
var mant;
// Handle zeros.
if (value === 0) {
if ((1 / value) > 0) {
// Positive zero.
jspb.utils.split64High = 0;
jspb.utils.split64Low = 0x00000000;
} else {
// Negative zero.
jspb.utils.split64High = 0;
jspb.utils.split64Low = 0x80000000;
}
return;
}
// Handle nans.
if (isNaN(value)) {
jspb.utils.split64High = 0;
jspb.utils.split64Low = 0x7FFFFFFF;
return;
}
// Handle infinities.
if (value > jspb.BinaryConstants.FLOAT32_MAX) {
jspb.utils.split64High = 0;
jspb.utils.split64Low = ((sign << 31) | (0x7F800000)) >>> 0;
return;
}
// Handle denormals.
if (value < jspb.BinaryConstants.FLOAT32_MIN) {
// Number is a denormal.
mant = Math.round(value / Math.pow(2, -149));
jspb.utils.split64High = 0;
jspb.utils.split64Low = ((sign << 31) | mant) >>> 0;
return;
}
exp = Math.floor(Math.log(value) / Math.LN2);
mant = value * Math.pow(2, -exp);
mant = Math.round(mant * jspb.BinaryConstants.TWO_TO_23) & 0x7FFFFF;
jspb.utils.split64High = 0;
jspb.utils.split64Low = ((sign << 31) | ((exp + 127) << 23) | mant) >>> 0;
};
/**
* Converts a floating-point number into 64-bit IEEE representation and stores
* it in the temp values above.
* @param {number} value
*/
jspb.utils.splitFloat64 = function(value) {
var sign = (value < 0) ? 1 : 0;
value = sign ? -value : value;
// Handle zeros.
if (value === 0) {
if ((1 / value) > 0) {
// Positive zero.
jspb.utils.split64High = 0x00000000;
jspb.utils.split64Low = 0x00000000;
} else {
// Negative zero.
jspb.utils.split64High = 0x80000000;
jspb.utils.split64Low = 0x00000000;
}
return;
}
// Handle nans.
if (isNaN(value)) {
jspb.utils.split64High = 0x7FFFFFFF;
jspb.utils.split64Low = 0xFFFFFFFF;
return;
}
// Handle infinities.
if (value > jspb.BinaryConstants.FLOAT64_MAX) {
jspb.utils.split64High = ((sign << 31) | (0x7FF00000)) >>> 0;
jspb.utils.split64Low = 0;
return;
}
// Handle denormals.
if (value < jspb.BinaryConstants.FLOAT64_MIN) {
// Number is a denormal.
var mant = value / Math.pow(2, -1074);
var mantHigh = (mant / jspb.BinaryConstants.TWO_TO_32);
jspb.utils.split64High = ((sign << 31) | mantHigh) >>> 0;
jspb.utils.split64Low = (mant >>> 0);
return;
}
var exp = Math.floor(Math.log(value) / Math.LN2);
if (exp == 1024) exp = 1023;
var mant = value * Math.pow(2, -exp);
var mantHigh = (mant * jspb.BinaryConstants.TWO_TO_20) & 0xFFFFF;
var mantLow = (mant * jspb.BinaryConstants.TWO_TO_52) >>> 0;
jspb.utils.split64High =
((sign << 31) | ((exp + 1023) << 20) | mantHigh) >>> 0;
jspb.utils.split64Low = mantLow;
};
/**
* Converts an 8-character hash string into two 32-bit numbers and stores them
* in the temp values above.
* @param {string} hash
*/
jspb.utils.splitHash64 = function(hash) {
var a = hash.charCodeAt(0);
var b = hash.charCodeAt(1);
var c = hash.charCodeAt(2);
var d = hash.charCodeAt(3);
var e = hash.charCodeAt(4);
var f = hash.charCodeAt(5);
var g = hash.charCodeAt(6);
var h = hash.charCodeAt(7);
jspb.utils.split64Low = (a + (b << 8) + (c << 16) + (d << 24)) >>> 0;
jspb.utils.split64High = (e + (f << 8) + (g << 16) + (h << 24)) >>> 0;
};
/**
* Joins two 32-bit values into a 64-bit unsigned integer. Precision will be
* lost if the result is greater than 2^52.
* @param {number} bitsLow
* @param {number} bitsHigh
* @return {number}
*/
jspb.utils.joinUint64 = function(bitsLow, bitsHigh) {
return bitsHigh * jspb.BinaryConstants.TWO_TO_32 + bitsLow;
};
/**
* Joins two 32-bit values into a 64-bit signed integer. Precision will be lost
* if the result is greater than 2^52.
* @param {number} bitsLow
* @param {number} bitsHigh
* @return {number}
*/
jspb.utils.joinInt64 = function(bitsLow, bitsHigh) {
// If the high bit is set, do a manual two's complement conversion.
var sign = (bitsHigh & 0x80000000);
if (sign) {
bitsLow = (~bitsLow + 1) >>> 0;
bitsHigh = ~bitsHigh >>> 0;
if (bitsLow == 0) {
bitsHigh = (bitsHigh + 1) >>> 0;
}
}
var result = jspb.utils.joinUint64(bitsLow, bitsHigh);
return sign ? -result : result;
};
/**
* Joins two 32-bit values into a 64-bit unsigned integer and applies zigzag
* decoding. Precision will be lost if the result is greater than 2^52.
* @param {number} bitsLow
* @param {number} bitsHigh
* @return {number}
*/
jspb.utils.joinZigzag64 = function(bitsLow, bitsHigh) {
// Extract the sign bit and shift right by one.
var sign = bitsLow & 1;
bitsLow = ((bitsLow >>> 1) | (bitsHigh << 31)) >>> 0;
bitsHigh = bitsHigh >>> 1;
// Increment the split value if the sign bit was set.
if (sign) {
bitsLow = (bitsLow + 1) >>> 0;
if (bitsLow == 0) {
bitsHigh = (bitsHigh + 1) >>> 0;
}
}
var result = jspb.utils.joinUint64(bitsLow, bitsHigh);
return sign ? -result : result;
};
/**
* Joins two 32-bit values into a 32-bit IEEE floating point number and
* converts it back into a Javascript number.
* @param {number} bitsLow The low 32 bits of the binary number;
* @param {number} bitsHigh The high 32 bits of the binary number.
* @return {number}
*/
jspb.utils.joinFloat32 = function(bitsLow, bitsHigh) {
var sign = ((bitsLow >> 31) * 2 + 1);
var exp = (bitsLow >>> 23) & 0xFF;
var mant = bitsLow & 0x7FFFFF;
if (exp == 0xFF) {
if (mant) {
return NaN;
} else {
return sign * Infinity;
}
}
if (exp == 0) {
// Denormal.
return sign * Math.pow(2, -149) * mant;
} else {
return sign * Math.pow(2, exp - 150) *
(mant + Math.pow(2, 23));
}
};
/**
* Joins two 32-bit values into a 64-bit IEEE floating point number and
* converts it back into a Javascript number.
* @param {number} bitsLow The low 32 bits of the binary number;
* @param {number} bitsHigh The high 32 bits of the binary number.
* @return {number}
*/
jspb.utils.joinFloat64 = function(bitsLow, bitsHigh) {
var sign = ((bitsHigh >> 31) * 2 + 1);
var exp = (bitsHigh >>> 20) & 0x7FF;
var mant = jspb.BinaryConstants.TWO_TO_32 * (bitsHigh & 0xFFFFF) + bitsLow;
if (exp == 0x7FF) {
if (mant) {
return NaN;
} else {
return sign * Infinity;
}
}
if (exp == 0) {
// Denormal.
return sign * Math.pow(2, -1074) * mant;
} else {
return sign * Math.pow(2, exp - 1075) *
(mant + jspb.BinaryConstants.TWO_TO_52);
}
};
/**
* Joins two 32-bit values into an 8-character hash string.
* @param {number} bitsLow
* @param {number} bitsHigh
* @return {string}
*/
jspb.utils.joinHash64 = function(bitsLow, bitsHigh) {
var a = (bitsLow >>> 0) & 0xFF;
var b = (bitsLow >>> 8) & 0xFF;
var c = (bitsLow >>> 16) & 0xFF;
var d = (bitsLow >>> 24) & 0xFF;
var e = (bitsHigh >>> 0) & 0xFF;
var f = (bitsHigh >>> 8) & 0xFF;
var g = (bitsHigh >>> 16) & 0xFF;
var h = (bitsHigh >>> 24) & 0xFF;
return String.fromCharCode(a, b, c, d, e, f, g, h);
};
/**
* Individual digits for number->string conversion.
* @const {!Array.<number>}
*/
jspb.utils.DIGITS = [
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
];
/**
* Losslessly converts a 64-bit unsigned integer in 32:32 split representation
* into a decimal string.
* @param {number} bitsLow The low 32 bits of the binary number;
* @param {number} bitsHigh The high 32 bits of the binary number.
* @return {string} The binary number represented as a string.
*/
jspb.utils.joinUnsignedDecimalString = function(bitsLow, bitsHigh) {
// Skip the expensive conversion if the number is small enough to use the
// built-in conversions.
if (bitsHigh <= 0x1FFFFF) {
return '' + (jspb.BinaryConstants.TWO_TO_32 * bitsHigh + bitsLow);
}
// What this code is doing is essentially converting the input number from
// base-2 to base-1e7, which allows us to represent the 64-bit range with
// only 3 (very large) digits. Those digits are then trivial to convert to
// a base-10 string.
// The magic numbers used here are -
// 2^24 = 16777216 = (1,6777216) in base-1e7.
// 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
// Split 32:32 representation into 16:24:24 representation so our
// intermediate digits don't overflow.
var low = bitsLow & 0xFFFFFF;
var mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xFFFFFF;
var high = (bitsHigh >> 16) & 0xFFFF;
// Assemble our three base-1e7 digits, ignoring carries. The maximum
// value in a digit at this step is representable as a 48-bit integer, which
// can be stored in a 64-bit floating point number.
var digitA = low + (mid * 6777216) + (high * 6710656);
var digitB = mid + (high * 8147497);
var digitC = (high * 2);
// Apply carries from A to B and from B to C.
var base = 10000000;
if (digitA >= base) {
digitB += Math.floor(digitA / base);
digitA %= base;
}
if (digitB >= base) {
digitC += Math.floor(digitB / base);
digitB %= base;
}
// Convert base-1e7 digits to base-10, omitting leading zeroes.
var table = jspb.utils.DIGITS;
var start = false;
var result = '';
function emit(digit) {
var temp = base;
for (var i = 0; i < 7; i++) {
temp /= 10;
var decimalDigit = ((digit / temp) % 10) >>> 0;
if ((decimalDigit == 0) && !start) continue;
start = true;
result += table[decimalDigit];
}
}
if (digitC || start) emit(digitC);
if (digitB || start) emit(digitB);
if (digitA || start) emit(digitA);
return result;
};
/**
* Losslessly converts a 64-bit signed integer in 32:32 split representation
* into a decimal string.
* @param {number} bitsLow The low 32 bits of the binary number;
* @param {number} bitsHigh The high 32 bits of the binary number.
* @return {string} The binary number represented as a string.
*/
jspb.utils.joinSignedDecimalString = function(bitsLow, bitsHigh) {
// If we're treating the input as a signed value and the high bit is set, do
// a manual two's complement conversion before the decimal conversion.
var negative = (bitsHigh & 0x80000000);
if (negative) {
bitsLow = (~bitsLow + 1) >>> 0;
var carry = (bitsLow == 0) ? 1 : 0;
bitsHigh = (~bitsHigh + carry) >>> 0;
}
var result = jspb.utils.joinUnsignedDecimalString(bitsLow, bitsHigh);
return negative ? '-' + result : result;
};
/**
* Convert an 8-character hash string representing either a signed or unsigned
* 64-bit integer into its decimal representation without losing accuracy.
* @param {string} hash The hash string to convert.
* @param {boolean} signed True if we should treat the hash string as encoding
* a signed integer.
* @return {string}
*/
jspb.utils.hash64ToDecimalString = function(hash, signed) {
jspb.utils.splitHash64(hash);
var bitsLow = jspb.utils.split64Low;
var bitsHigh = jspb.utils.split64High;
return signed ?
jspb.utils.joinSignedDecimalString(bitsLow, bitsHigh) :
jspb.utils.joinUnsignedDecimalString(bitsLow, bitsHigh);
};
/**
* Converts an array of 8-character hash strings into their decimal
* representations.
* @param {!Array.<string>} hashes The array of hash strings to convert.
* @param {boolean} signed True if we should treat the hash string as encoding
* a signed integer.
* @return {!Array.<string>}
*/
jspb.utils.hash64ArrayToDecimalStrings = function(hashes, signed) {
var result = new Array(hashes.length);
for (var i = 0; i < hashes.length; i++) {
result[i] = jspb.utils.hash64ToDecimalString(hashes[i], signed);
}
return result;
};
/**
* Converts a signed or unsigned decimal string into its hash string
* representation.
* @param {string} dec
* @return {string}
*/
jspb.utils.decimalStringToHash64 = function(dec) {
goog.asserts.assert(dec.length > 0);
// Check for minus sign.
var minus = false;
if (dec[0] === '-') {
minus = true;
dec = dec.slice(1);
}
// Store result as a byte array.
var resultBytes = [0, 0, 0, 0, 0, 0, 0, 0];
// Set result to m*result + c.
function muladd(m, c) {
for (var i = 0; i < 8 && (m !== 1 || c > 0); i++) {
var r = m * resultBytes[i] + c;
resultBytes[i] = r & 0xFF;
c = r >>> 8;
}
}
// Negate the result bits.
function neg() {
for (var i = 0; i < 8; i++) {
resultBytes[i] = (~resultBytes[i]) & 0xFF;
}
}
// For each decimal digit, set result to 10*result + digit.
for (var i = 0; i < dec.length; i++) {
muladd(10, jspb.utils.DIGITS.indexOf(dec[i]));
}
// If there's a minus sign, convert into two's complement.
if (minus) {
neg();
muladd(1, 1);
}
return String.fromCharCode.apply(null, resultBytes);
};
/**
* Converts an 8-character hash string into its hexadecimal representation.
* @param {string} hash
* @return {string}
*/
jspb.utils.hash64ToHexString = function(hash) {
var temp = new Array(18);
temp[0] = '0';
temp[1] = 'x';
for (var i = 0; i < 8; i++) {
var c = hash.charCodeAt(7 - i);
temp[i * 2 + 2] = jspb.utils.DIGITS[c >> 4];
temp[i * 2 + 3] = jspb.utils.DIGITS[c & 0xF];
}
var result = temp.join('');
return result;
};
/**
* Converts a '0x<16 digits>' hex string into its hash string representation.
* @param {string} hex
* @return {string}
*/
jspb.utils.hexStringToHash64 = function(hex) {
hex = hex.toLowerCase();
goog.asserts.assert(hex.length == 18);
goog.asserts.assert(hex[0] == '0');
goog.asserts.assert(hex[1] == 'x');
var result = '';
for (var i = 0; i < 8; i++) {
var hi = jspb.utils.DIGITS.indexOf(hex[i * 2 + 2]);
var lo = jspb.utils.DIGITS.indexOf(hex[i * 2 + 3]);
result = String.fromCharCode(hi * 16 + lo) + result;
}
return result;
};
/**
* Convert an 8-character hash string representing either a signed or unsigned
* 64-bit integer into a Javascript number. Will lose accuracy if the result is
* larger than 2^52.
* @param {string} hash The hash string to convert.
* @param {boolean} signed True if the has should be interpreted as a signed
* number.
* @return {number}
*/
jspb.utils.hash64ToNumber = function(hash, signed) {
jspb.utils.splitHash64(hash);
var bitsLow = jspb.utils.split64Low;
var bitsHigh = jspb.utils.split64High;
return signed ? jspb.utils.joinInt64(bitsLow, bitsHigh) :
jspb.utils.joinUint64(bitsLow, bitsHigh);
};
/**
* Convert a Javascript number into an 8-character hash string. Will lose
* precision if the value is non-integral or greater than 2^64.
* @param {number} value The integer to convert.
* @return {string}
*/
jspb.utils.numberToHash64 = function(value) {
jspb.utils.splitInt64(value);
return jspb.utils.joinHash64(jspb.utils.split64Low,
jspb.utils.split64High);
};
/**
* Counts the number of contiguous varints in a buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @return {number} The number of varints in the buffer.
*/
jspb.utils.countVarints = function(buffer, start, end) {
// Count how many high bits of each byte were set in the buffer.
var count = 0;
for (var i = start; i < end; i++) {
count += buffer[i] >> 7;
}
// The number of varints in the buffer equals the size of the buffer minus
// the number of non-terminal bytes in the buffer (those with the high bit
// set).
return (end - start) - count;
};
/**
* Counts the number of contiguous varint fields with the given field number in
* the buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @param {number} field The field number to count.
* @return {number} The number of matching fields in the buffer.
*/
jspb.utils.countVarintFields = function(buffer, start, end, field) {
var count = 0;
var cursor = start;
var tag = field * 8 + jspb.BinaryConstants.WireType.VARINT;
if (tag < 128) {
// Single-byte field tag, we can use a slightly quicker count.
while (cursor < end) {
// Skip the field tag, or exit if we find a non-matching tag.
if (buffer[cursor++] != tag) return count;
// Field tag matches, we've found a valid field.
count++;
// Skip the varint.
while (1) {
var x = buffer[cursor++];
if ((x & 0x80) == 0) break;
}
}
} else {
while (cursor < end) {
// Skip the field tag, or exit if we find a non-matching tag.
var temp = tag;
while (temp > 128) {
if (buffer[cursor] != ((temp & 0x7F) | 0x80)) return count;
cursor++;
temp >>= 7;
}
if (buffer[cursor++] != temp) return count;
// Field tag matches, we've found a valid field.
count++;
// Skip the varint.
while (1) {
var x = buffer[cursor++];
if ((x & 0x80) == 0) break;
}
}
}
return count;
};
/**
* Counts the number of contiguous fixed32 fields with the given tag in the
* buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @param {number} tag The tag value to count.
* @param {number} stride The number of bytes to skip per field.
* @return {number} The number of fields with a matching tag in the buffer.
* @private
*/
jspb.utils.countFixedFields_ =
function(buffer, start, end, tag, stride) {
var count = 0;
var cursor = start;
if (tag < 128) {
// Single-byte field tag, we can use a slightly quicker count.
while (cursor < end) {
// Skip the field tag, or exit if we find a non-matching tag.
if (buffer[cursor++] != tag) return count;
// Field tag matches, we've found a valid field.
count++;
// Skip the value.
cursor += stride;
}
} else {
while (cursor < end) {
// Skip the field tag, or exit if we find a non-matching tag.
var temp = tag;
while (temp > 128) {
if (buffer[cursor++] != ((temp & 0x7F) | 0x80)) return count;
temp >>= 7;
}
if (buffer[cursor++] != temp) return count;
// Field tag matches, we've found a valid field.
count++;
// Skip the value.
cursor += stride;
}
}
return count;
};
/**
* Counts the number of contiguous fixed32 fields with the given field number
* in the buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @param {number} field The field number to count.
* @return {number} The number of matching fields in the buffer.
*/
jspb.utils.countFixed32Fields = function(buffer, start, end, field) {
var tag = field * 8 + jspb.BinaryConstants.WireType.FIXED32;
return jspb.utils.countFixedFields_(buffer, start, end, tag, 4);
};
/**
* Counts the number of contiguous fixed64 fields with the given field number
* in the buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @param {number} field The field number to count
* @return {number} The number of matching fields in the buffer.
*/
jspb.utils.countFixed64Fields = function(buffer, start, end, field) {
var tag = field * 8 + jspb.BinaryConstants.WireType.FIXED64;
return jspb.utils.countFixedFields_(buffer, start, end, tag, 8);
};
/**
* Counts the number of contiguous delimited fields with the given field number
* in the buffer.
* @param {!Uint8Array} buffer The buffer to scan.
* @param {number} start The starting point in the buffer to scan.
* @param {number} end The end point in the buffer to scan.
* @param {number} field The field number to count.
* @return {number} The number of matching fields in the buffer.
*/
jspb.utils.countDelimitedFields = function(buffer, start, end, field) {
var count = 0;
var cursor = start;
var tag = field * 8 + jspb.BinaryConstants.WireType.DELIMITED;
while (cursor < end) {
// Skip the field tag, or exit if we find a non-matching tag.
var temp = tag;
while (temp > 128) {
if (buffer[cursor++] != ((temp & 0x7F) | 0x80)) return count;
temp >>= 7;
}
if (buffer[cursor++] != temp) return count;
// Field tag matches, we've found a valid field.
count++;
// Decode the length prefix.
var length = 0;
var shift = 1;
while (1) {
temp = buffer[cursor++];
length += (temp & 0x7f) * shift;
shift *= 128;
if ((temp & 0x80) == 0) break;
}
// Advance the cursor past the blob.
cursor += length;
}
return count;
};
/**
* String-ify bytes for text format. Should be optimized away in non-debug.
* The returned string uses \xXX escapes for all values and is itself quoted.
* [1, 31] serializes to '"\x01\x1f"'.
* @param {jspb.ByteSource} byteSource The bytes to serialize.
* @return {string} Stringified bytes for text format.
*/
jspb.utils.debugBytesToTextFormat = function(byteSource) {
var s = '"';
if (byteSource) {
var bytes = jspb.utils.byteSourceToUint8Array(byteSource);
for (var i = 0; i < bytes.length; i++) {
s += '\\x';
if (bytes[i] < 16) s += '0';
s += bytes[i].toString(16);
}
}
return s + '"';
};
/**
* String-ify a scalar for text format. Should be optimized away in non-debug.
* @param {string|number|boolean} scalar The scalar to stringify.
* @return {string} Stringified scalar for text format.
*/
jspb.utils.debugScalarToTextFormat = function(scalar) {
if (goog.isString(scalar)) {
return goog.string.quote(scalar);
} else {
return scalar.toString();
}
};
/**
* Utility function: convert a string with codepoints 0--255 inclusive to a
* Uint8Array. If any codepoints greater than 255 exist in the string, throws an
* exception.
* @param {string} str
* @return {!Uint8Array}
*/
jspb.utils.stringToByteArray = function(str) {
var arr = new Uint8Array(str.length);
for (var i = 0; i < str.length; i++) {
var codepoint = str.charCodeAt(i);
if (codepoint > 255) {
throw new Error('Conversion error: string contains codepoint ' +
'outside of byte range');
}
arr[i] = codepoint;
}
return arr;
};
/**
* Converts any type defined in jspb.ByteSource into a Uint8Array.
* @param {!jspb.ByteSource} data
* @return {!Uint8Array}
* @suppress {invalidCasts}
*/
jspb.utils.byteSourceToUint8Array = function(data) {
if (data.constructor === Uint8Array) {
return /** @type {!Uint8Array} */(data);
}
if (data.constructor === ArrayBuffer) {
data = /** @type {!ArrayBuffer} */(data);
return /** @type {!Uint8Array} */(new Uint8Array(data));
}
if (data.constructor === Array) {
data = /** @type {!Array.<number>} */(data);
return /** @type {!Uint8Array} */(new Uint8Array(data));
}
if (data.constructor === String) {
data = /** @type {string} */(data);
return goog.crypt.base64.decodeStringToUint8Array(data);
}
goog.asserts.fail('Type not convertible to Uint8Array.');
return /** @type {!Uint8Array} */(new Uint8Array(0));
};