404 lines
12 KiB
JavaScript
404 lines
12 KiB
JavaScript
/**
|
|
* @fileoverview Protobufs Int64 representation.
|
|
*/
|
|
goog.module('protobuf.Int64');
|
|
|
|
const Long = goog.require('goog.math.Long');
|
|
const {assert} = goog.require('goog.asserts');
|
|
|
|
/**
|
|
* A container for protobufs Int64/Uint64 data type.
|
|
* @final
|
|
*/
|
|
class Int64 {
|
|
/** @return {!Int64} */
|
|
static getZero() {
|
|
return ZERO;
|
|
}
|
|
|
|
/** @return {!Int64} */
|
|
static getMinValue() {
|
|
return MIN_VALUE;
|
|
}
|
|
|
|
/** @return {!Int64} */
|
|
static getMaxValue() {
|
|
return MAX_VALUE;
|
|
}
|
|
|
|
/**
|
|
* Constructs a Int64 given two 32 bit numbers
|
|
* @param {number} lowBits
|
|
* @param {number} highBits
|
|
* @return {!Int64}
|
|
*/
|
|
static fromBits(lowBits, highBits) {
|
|
return new Int64(lowBits, highBits);
|
|
}
|
|
|
|
/**
|
|
* Constructs an Int64 from a signed 32 bit number.
|
|
* @param {number} value
|
|
* @return {!Int64}
|
|
*/
|
|
static fromInt(value) {
|
|
// TODO: Use our own checking system here.
|
|
assert(value === (value | 0), 'value should be a 32-bit integer');
|
|
// Right shift 31 bits so all high bits are equal to the sign bit.
|
|
// Note: cannot use >> 32, because (1 >> 32) = 1 (!).
|
|
const signExtendedHighBits = value >> 31;
|
|
return new Int64(value, signExtendedHighBits);
|
|
}
|
|
|
|
/**
|
|
* Constructs an Int64 from a number (over 32 bits).
|
|
* @param {number} value
|
|
* @return {!Int64}
|
|
*/
|
|
static fromNumber(value) {
|
|
if (value > 0) {
|
|
return new Int64(value, value / TWO_PWR_32_DBL);
|
|
} else if (value < 0) {
|
|
return negate(-value, -value / TWO_PWR_32_DBL);
|
|
}
|
|
return ZERO;
|
|
}
|
|
|
|
/**
|
|
* Construct an Int64 from a signed decimal string.
|
|
* @param {string} value
|
|
* @return {!Int64}
|
|
*/
|
|
static fromDecimalString(value) {
|
|
// TODO: Use our own checking system here.
|
|
assert(value.length > 0);
|
|
// The basic Number conversion loses precision, but we can use it for
|
|
// a quick validation that the format is correct and it is an integer.
|
|
assert(Math.floor(Number(value)).toString().length == value.length);
|
|
return decimalStringToInt64(value);
|
|
}
|
|
|
|
/**
|
|
* Construct an Int64 from a signed hexadecimal string.
|
|
* @param {string} value
|
|
* @return {!Int64}
|
|
*/
|
|
static fromHexString(value) {
|
|
// TODO: Use our own checking system here.
|
|
assert(value.length > 0);
|
|
assert(value.slice(0, 2) == '0x' || value.slice(0, 3) == '-0x');
|
|
const minus = value[0] === '-';
|
|
// Strip the 0x or -0x prefix.
|
|
value = value.slice(minus ? 3 : 2);
|
|
const lowBits = parseInt(value.slice(-8), 16);
|
|
const highBits = parseInt(value.slice(-16, -8) || '', 16);
|
|
return (minus ? negate : Int64.fromBits)(lowBits, highBits);
|
|
}
|
|
|
|
// Note to the reader:
|
|
// goog.math.Long suffers from a code size issue. JsCompiler almost always
|
|
// considers toString methods to be alive in a program. So if you are
|
|
// constructing a Long instance the toString method is assumed to be live.
|
|
// Unfortunately Long's toString method makes a large chunk of code alive
|
|
// of the entire class adding 1.3kB (gzip) of extra code size.
|
|
// Callers that are sensitive to code size and are not using Long already
|
|
// should avoid calling this method.
|
|
/**
|
|
* Creates an Int64 instance from a Long value.
|
|
* @param {!Long} value
|
|
* @return {!Int64}
|
|
*/
|
|
static fromLong(value) {
|
|
return new Int64(value.getLowBits(), value.getHighBits());
|
|
}
|
|
|
|
/**
|
|
* @param {number} lowBits
|
|
* @param {number} highBits
|
|
* @private
|
|
*/
|
|
constructor(lowBits, highBits) {
|
|
/** @const @private {number} */
|
|
this.lowBits_ = lowBits | 0;
|
|
/** @const @private {number} */
|
|
this.highBits_ = highBits | 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the int64 value as a JavaScript number. This will lose precision
|
|
* if the number is outside of the safe range for JavaScript of 53 bits
|
|
* precision.
|
|
* @return {number}
|
|
*/
|
|
asNumber() {
|
|
const result = this.highBits_ * TWO_PWR_32_DBL + this.getLowBitsUnsigned();
|
|
// TODO: Use our own checking system here.
|
|
assert(
|
|
Number.isSafeInteger(result), 'conversion to number loses precision.');
|
|
return result;
|
|
}
|
|
|
|
// Note to the reader:
|
|
// goog.math.Long suffers from a code size issue. JsCompiler almost always
|
|
// considers toString methods to be alive in a program. So if you are
|
|
// constructing a Long instance the toString method is assumed to be live.
|
|
// Unfortunately Long's toString method makes a large chunk of code alive
|
|
// of the entire class adding 1.3kB (gzip) of extra code size.
|
|
// Callers that are sensitive to code size and are not using Long already
|
|
// should avoid calling this method.
|
|
/** @return {!Long} */
|
|
asLong() {
|
|
return Long.fromBits(this.lowBits_, this.highBits_);
|
|
}
|
|
|
|
/** @return {number} Signed 32-bit integer value. */
|
|
getLowBits() {
|
|
return this.lowBits_;
|
|
}
|
|
|
|
/** @return {number} Signed 32-bit integer value. */
|
|
getHighBits() {
|
|
return this.highBits_;
|
|
}
|
|
|
|
/** @return {number} Unsigned 32-bit integer. */
|
|
getLowBitsUnsigned() {
|
|
return this.lowBits_ >>> 0;
|
|
}
|
|
|
|
/** @return {number} Unsigned 32-bit integer. */
|
|
getHighBitsUnsigned() {
|
|
return this.highBits_ >>> 0;
|
|
}
|
|
|
|
/** @return {string} */
|
|
toSignedDecimalString() {
|
|
return joinSignedDecimalString(this);
|
|
}
|
|
|
|
/** @return {string} */
|
|
toUnsignedDecimalString() {
|
|
return joinUnsignedDecimalString(this);
|
|
}
|
|
|
|
/**
|
|
* Returns an unsigned hexadecimal string representation of the Int64.
|
|
* @return {string}
|
|
*/
|
|
toHexString() {
|
|
let nibbles = new Array(16);
|
|
let lowBits = this.lowBits_;
|
|
let highBits = this.highBits_;
|
|
for (let highIndex = 7, lowIndex = 15; lowIndex > 7;
|
|
highIndex--, lowIndex--) {
|
|
nibbles[highIndex] = HEX_DIGITS[highBits & 0xF];
|
|
nibbles[lowIndex] = HEX_DIGITS[lowBits & 0xF];
|
|
highBits = highBits >>> 4;
|
|
lowBits = lowBits >>> 4;
|
|
}
|
|
// Always leave the least significant hex digit.
|
|
while (nibbles.length > 1 && nibbles[0] == '0') {
|
|
nibbles.shift();
|
|
}
|
|
return `0x${nibbles.join('')}`;
|
|
}
|
|
|
|
/**
|
|
* @param {*} other object to compare against.
|
|
* @return {boolean} Whether this Int64 equals the other.
|
|
*/
|
|
equals(other) {
|
|
if (this === other) {
|
|
return true;
|
|
}
|
|
if (!(other instanceof Int64)) {
|
|
return false;
|
|
}
|
|
// Compare low parts first as there is higher chance they are different.
|
|
const otherInt64 = /** @type{!Int64} */ (other);
|
|
return (this.lowBits_ === otherInt64.lowBits_) &&
|
|
(this.highBits_ === otherInt64.highBits_);
|
|
}
|
|
|
|
/**
|
|
* Returns a number (int32) that is suitable for using in hashed structures.
|
|
* @return {number}
|
|
*/
|
|
hashCode() {
|
|
return (31 * this.lowBits_ + 17 * this.highBits_) | 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Losslessly converts a 64-bit unsigned integer in 32:32 split representation
|
|
* into a decimal string.
|
|
* @param {!Int64} int64
|
|
* @return {string} The binary number represented as a string.
|
|
*/
|
|
const joinUnsignedDecimalString = (int64) => {
|
|
const lowBits = int64.getLowBitsUnsigned();
|
|
const highBits = int64.getHighBitsUnsigned();
|
|
// Skip the expensive conversion if the number is small enough to use the
|
|
// built-in conversions.
|
|
// Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
|
|
// highBits <= 0x1FFFFF can be safely expressed with a double and retain
|
|
// integer precision.
|
|
// Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
|
|
if (highBits <= 0x1FFFFF) {
|
|
return String(TWO_PWR_32_DBL * highBits + lowBits);
|
|
}
|
|
|
|
// 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.
|
|
const low = lowBits & LOW_24_BITS;
|
|
const mid = ((lowBits >>> 24) | (highBits << 8)) & LOW_24_BITS;
|
|
const high = (highBits >> 16) & LOW_16_BITS;
|
|
|
|
// 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.
|
|
let digitA = low + (mid * 6777216) + (high * 6710656);
|
|
let digitB = mid + (high * 8147497);
|
|
let digitC = (high * 2);
|
|
|
|
// Apply carries from A to B and from B to C.
|
|
const base = 10000000;
|
|
if (digitA >= base) {
|
|
digitB += Math.floor(digitA / base);
|
|
digitA %= base;
|
|
}
|
|
|
|
if (digitB >= base) {
|
|
digitC += Math.floor(digitB / base);
|
|
digitB %= base;
|
|
}
|
|
|
|
// If digitC is 0, then we should have returned in the trivial code path
|
|
// at the top for non-safe integers. Given this, we can assume both digitB
|
|
// and digitA need leading zeros.
|
|
// TODO: Use our own checking system here.
|
|
assert(digitC);
|
|
return digitC + decimalFrom1e7WithLeadingZeros(digitB) +
|
|
decimalFrom1e7WithLeadingZeros(digitA);
|
|
};
|
|
|
|
/**
|
|
* @param {number} digit1e7 Number < 1e7
|
|
* @return {string} Decimal representation of digit1e7 with leading zeros.
|
|
*/
|
|
const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
|
|
const partial = String(digit1e7);
|
|
return '0000000'.slice(partial.length) + partial;
|
|
};
|
|
|
|
/**
|
|
* Losslessly converts a 64-bit signed integer in 32:32 split representation
|
|
* into a decimal string.
|
|
* @param {!Int64} int64
|
|
* @return {string} The binary number represented as a string.
|
|
*/
|
|
const joinSignedDecimalString = (int64) => {
|
|
// 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.
|
|
const negative = (int64.getHighBits() & 0x80000000);
|
|
if (negative) {
|
|
int64 = negate(int64.getLowBits(), int64.getHighBits());
|
|
}
|
|
|
|
const result = joinUnsignedDecimalString(int64);
|
|
return negative ? '-' + result : result;
|
|
};
|
|
|
|
/**
|
|
* @param {string} dec
|
|
* @return {!Int64}
|
|
*/
|
|
const decimalStringToInt64 = (dec) => {
|
|
// Check for minus sign.
|
|
const minus = dec[0] === '-';
|
|
if (minus) {
|
|
dec = dec.slice(1);
|
|
}
|
|
|
|
// Work 6 decimal digits at a time, acting like we're converting base 1e6
|
|
// digits to binary. This is safe to do with floating point math because
|
|
// Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
|
|
const base = 1e6;
|
|
let lowBits = 0;
|
|
let highBits = 0;
|
|
function add1e6digit(begin, end = undefined) {
|
|
// Note: Number('') is 0.
|
|
const digit1e6 = Number(dec.slice(begin, end));
|
|
highBits *= base;
|
|
lowBits = lowBits * base + digit1e6;
|
|
// Carry bits from lowBits to
|
|
if (lowBits >= TWO_PWR_32_DBL) {
|
|
highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
|
|
lowBits = lowBits % TWO_PWR_32_DBL;
|
|
}
|
|
}
|
|
add1e6digit(-24, -18);
|
|
add1e6digit(-18, -12);
|
|
add1e6digit(-12, -6);
|
|
add1e6digit(-6);
|
|
|
|
return (minus ? negate : Int64.fromBits)(lowBits, highBits);
|
|
};
|
|
|
|
/**
|
|
* @param {number} lowBits
|
|
* @param {number} highBits
|
|
* @return {!Int64} Two's compliment negation of input.
|
|
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
|
|
*/
|
|
const negate = (lowBits, highBits) => {
|
|
highBits = ~highBits;
|
|
if (lowBits) {
|
|
lowBits = ~lowBits + 1;
|
|
} else {
|
|
// If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
|
|
// adding 1 to that, results in 0x100000000, which leaves
|
|
// the low bits 0x0 and simply adds one to the high bits.
|
|
highBits += 1;
|
|
}
|
|
return Int64.fromBits(lowBits, highBits);
|
|
};
|
|
|
|
/** @const {!Int64} */
|
|
const ZERO = new Int64(0, 0);
|
|
|
|
/** @const @private {number} */
|
|
const LOW_16_BITS = 0xFFFF;
|
|
|
|
/** @const @private {number} */
|
|
const LOW_24_BITS = 0xFFFFFF;
|
|
|
|
/** @const @private {number} */
|
|
const LOW_31_BITS = 0x7FFFFFFF;
|
|
|
|
/** @const @private {number} */
|
|
const ALL_32_BITS = 0xFFFFFFFF;
|
|
|
|
/** @const {!Int64} */
|
|
const MAX_VALUE = Int64.fromBits(ALL_32_BITS, LOW_31_BITS);
|
|
|
|
/** @const {!Int64} */
|
|
const MIN_VALUE = Int64.fromBits(0, 0x80000000);
|
|
|
|
/** @const {number} */
|
|
const TWO_PWR_32_DBL = 0x100000000;
|
|
|
|
/** @const {string} */
|
|
const HEX_DIGITS = '0123456789abcdef';
|
|
|
|
exports = Int64;
|