runtime/kernel/buffer_decoder.js

/**
 * @fileoverview A buffer implementation that can decode data for protobufs.
 */

goog.module('protobuf.binary.BufferDecoder');

const ByteString = goog.require('protobuf.ByteString');
const functions = goog.require('goog.functions');
const {POLYFILL_TEXT_ENCODING, checkCriticalPositionIndex, checkCriticalState, checkState} = goog.require('protobuf.internal.checks');
const {byteStringFromUint8ArrayUnsafe} = goog.require('protobuf.byteStringInternal');
const {concatenateByteArrays} = goog.require('protobuf.binary.uint8arrays');
const {decode} = goog.require('protobuf.binary.textencoding');

/**
 * Returns a valid utf-8 decoder function based on TextDecoder if available or
 * a polyfill.
 * Some of the environments we run in do not have TextDecoder defined.
 * TextDecoder is faster than our polyfill so we prefer it over the polyfill.
 * @return {function(!DataView): string}
 */
function getStringDecoderFunction() {
  if (goog.global['TextDecoder']) {
    const textDecoder = new goog.global['TextDecoder']('utf-8', {fatal: true});
    return bytes => textDecoder.decode(bytes);
  }
  if (POLYFILL_TEXT_ENCODING) {
    return decode;
  } else {
    throw new Error(
        'TextDecoder is missing. ' +
        'Enable protobuf.defines.POLYFILL_TEXT_ENCODING.');
  }
}

/** @type {function(): function(!DataView): string} */
const stringDecoderFunction =
    functions.cacheReturnValue(() => getStringDecoderFunction());

/** @type {function(): !DataView} */
const emptyDataView =
    functions.cacheReturnValue(() => new DataView(new ArrayBuffer(0)));

class BufferDecoder {
  /**
   * @param {!Array<!BufferDecoder>} bufferDecoders
   * @return {!BufferDecoder}
   */
  static merge(bufferDecoders) {
    const uint8Arrays = bufferDecoders.map(b => b.asUint8Array());
    const bytesArray = concatenateByteArrays(uint8Arrays);
    return BufferDecoder.fromArrayBuffer(bytesArray.buffer);
  }

  /**
   * @param {!ArrayBuffer} arrayBuffer
   * @return {!BufferDecoder}
   */
  static fromArrayBuffer(arrayBuffer) {
    return new BufferDecoder(
        new DataView(arrayBuffer), 0, arrayBuffer.byteLength);
  }

  /**
   * @param {!DataView} dataView
   * @param {number} startIndex
   * @param {number} length
   * @private
   */
  constructor(dataView, startIndex, length) {
    /** @private @const {!DataView} */
    this.dataView_ = dataView;
    /** @private @const {number} */
    this.startIndex_ = startIndex;
    /** @private @const {number} */
    this.endIndex_ = startIndex + length;
    /** @private {number} */
    this.cursor_ = startIndex;
  }

  /**
   * Returns the start index of the underlying buffer.
   * @return {number}
   */
  startIndex() {
    return this.startIndex_;
  }

  /**
   * Returns the end index of the underlying buffer.
   * @return {number}
   */
  endIndex() {
    return this.endIndex_;
  }

  /**
   * Returns the length of the underlying buffer.
   * @return {number}
   */
  length() {
    return this.endIndex_ - this.startIndex_;
  }

  /**
   * Returns the start position of the next data, i.e. end position of the last
   * read data + 1.
   * @return {number}
   */
  cursor() {
    return this.cursor_;
  }

  /**
   * Sets the cursor to the specified position.
   * @param {number} position
   */
  setCursor(position) {
    this.cursor_ = position;
  }

  /**
   * Returns if there is more data to read after the current cursor position.
   * @return {boolean}
   */
  hasNext() {
    return this.cursor_ < this.endIndex_;
  }

  /**
   * Returns a float32 from a given index
   * @param {number} index
   * @return {number}
   */
  getFloat32(index) {
    this.cursor_ = index + 4;
    return this.dataView_.getFloat32(index, true);
  }

  /**
   * Returns a float64 from a given index
   * @param {number} index
   * @return {number}
   */
  getFloat64(index) {
    this.cursor_ = index + 8;
    return this.dataView_.getFloat64(index, true);
  }

  /**
   * Returns an int32 from a given index
   * @param {number} index
   * @return {number}
   */
  getInt32(index) {
    this.cursor_ = index + 4;
    return this.dataView_.getInt32(index, true);
  }

  /**
   * Returns a uint32 from a given index
   * @param {number} index
   * @return {number}
   */
  getUint32(index) {
    this.cursor_ = index + 4;
    return this.dataView_.getUint32(index, true);
  }

  /**
   * Returns two JS numbers each representing 32 bits of a 64 bit number. Also
   * sets the cursor to the start of the next block of data.
   * @param {number} index
   * @return {{lowBits: number, highBits: number}}
   */
  getVarint(index) {
    this.cursor_ = index;
    let lowBits = 0;
    let highBits = 0;

    for (let shift = 0; shift < 28; shift += 7) {
      const b = this.dataView_.getUint8(this.cursor_++);
      lowBits |= (b & 0x7F) << shift;
      if ((b & 0x80) === 0) {
        return {lowBits, highBits};
      }
    }

    const middleByte = this.dataView_.getUint8(this.cursor_++);

    // last four bits of the first 32 bit number
    lowBits |= (middleByte & 0x0F) << 28;

    // 3 upper bits are part of the next 32 bit number
    highBits = (middleByte & 0x70) >> 4;

    if ((middleByte & 0x80) === 0) {
      return {lowBits, highBits};
    }


    for (let shift = 3; shift <= 31; shift += 7) {
      const b = this.dataView_.getUint8(this.cursor_++);
      highBits |= (b & 0x7F) << shift;
      if ((b & 0x80) === 0) {
        return {lowBits, highBits};
      }
    }

    checkCriticalState(false, 'Data is longer than 10 bytes');

    return {lowBits, highBits};
  }

  /**
   * Returns an unsigned int32 number at the current cursor position. The upper
   * bits are discarded if the varint is longer than 32 bits. Also sets the
   * cursor to the start of the next block of data.
   * @return {number}
   */
  getUnsignedVarint32() {
    let b = this.dataView_.getUint8(this.cursor_++);
    let result = b & 0x7F;
    if ((b & 0x80) === 0) {
      return result;
    }

    b = this.dataView_.getUint8(this.cursor_++);
    result |= (b & 0x7F) << 7;
    if ((b & 0x80) === 0) {
      return result;
    }

    b = this.dataView_.getUint8(this.cursor_++);
    result |= (b & 0x7F) << 14;
    if ((b & 0x80) === 0) {
      return result;
    }

    b = this.dataView_.getUint8(this.cursor_++);
    result |= (b & 0x7F) << 21;
    if ((b & 0x80) === 0) {
      return result;
    }

    // Extract only last 4 bits
    b = this.dataView_.getUint8(this.cursor_++);
    result |= (b & 0x0F) << 28;

    for (let readBytes = 5; ((b & 0x80) !== 0) && readBytes < 10; readBytes++) {
      b = this.dataView_.getUint8(this.cursor_++);
    }

    checkCriticalState((b & 0x80) === 0, 'Data is longer than 10 bytes');

    // Result can be have 32 bits, convert it to unsigned
    return result >>> 0;
  }

  /**
   * Returns an unsigned int32 number at the specified index. The upper bits are
   * discarded if the varint is longer than 32 bits. Also sets the cursor to the
   * start of the next block of data.
   * @param {number} index
   * @return {number}
   */
  getUnsignedVarint32At(index) {
    this.cursor_ = index;
    return this.getUnsignedVarint32();
  }

  /**
   * Seeks forward by the given amount.
   * @param {number} skipAmount
   * @package
   */
  skip(skipAmount) {
    this.cursor_ += skipAmount;
    checkCriticalPositionIndex(this.cursor_, this.endIndex_);
  }

  /**
   * Skips over a varint from the current cursor position.
   * @package
   */
  skipVarint() {
    const startIndex = this.cursor_;
    while (this.dataView_.getUint8(this.cursor_++) & 0x80) {
    }
    checkCriticalPositionIndex(this.cursor_, startIndex + 10);
  }

  /**
   * @param {number} startIndex
   * @param {number} length
   * @return {!BufferDecoder}
   */
  subBufferDecoder(startIndex, length) {
    checkState(
        startIndex >= this.startIndex(),
        `Current start: ${this.startIndex()}, subBufferDecoder start: ${
            startIndex}`);
    checkState(length >= 0, `Length: ${length}`);
    checkState(
        startIndex + length <= this.endIndex(),
        `Current end: ${this.endIndex()}, subBufferDecoder start: ${
            startIndex}, subBufferDecoder length: ${length}`);
    return new BufferDecoder(this.dataView_, startIndex, length);
  }

  /**
   * Returns the buffer as a string.
   * @return {string}
   */
  asString() {
    // TODO: Remove this check when we no longer need to support IE
    const stringDataView = this.length() === 0 ?
        emptyDataView() :
        new DataView(this.dataView_.buffer, this.startIndex_, this.length());
    return stringDecoderFunction()(stringDataView);
  }

  /**
   * Returns the buffer as a ByteString.
   * @return {!ByteString}
   */
  asByteString() {
    return byteStringFromUint8ArrayUnsafe(this.asUint8Array());
  }

  /**
   * Returns the DataView as an Uint8Array. DO NOT MODIFY or expose the
   * underlying buffer.
   *
   * @package
   * @return {!Uint8Array}
   */
  asUint8Array() {
    return new Uint8Array(
        this.dataView_.buffer, this.startIndex_, this.length());
  }
}

exports = BufferDecoder;