Method slice

tfjs-core/src/io/composite_array_buffer.ts:101–150

(start = 0, end = this.byteLength)

  }

  slice(start = 0, end = this.byteLength): ArrayBuffer {
    // If there are no shards, then the CompositeArrayBuffer was initialized
    // with no data.
    if (this.shards.length === 0) {
      return new ArrayBuffer(0);
    }

    // NaN is treated as zero for slicing. This matches ArrayBuffer's behavior.
    start = isNaN(Number(start)) ? 0 : start;
    end = isNaN(Number(end)) ? 0 : end;

    // Fix the bounds to within the array.
    start = Math.max(0, start);
    end = Math.min(this.byteLength, end);
    if (end <= start) {
      return new ArrayBuffer(0);
    }

    const startShardIndex = this.findShardForByte(start);
    if (startShardIndex === -1) {
      // This should not happen since the start and end indices are always
      // within 0 and the composite array's length.
      throw new Error(`Could not find start shard for byte ${start}`);
    }

    const size = end - start;
    const outputBuffer = new ArrayBuffer(size);
    const outputArray = new Uint8Array(outputBuffer);
    let sliced = 0;
    for (let i = startShardIndex; i < this.shards.length; i++) {
      const shard = this.shards[i];

      const globalStart = start + sliced;
      const localStart = globalStart - shard.start;
      const outputStart = sliced;

      const globalEnd = Math.min(end, shard.end);
      const localEnd = globalEnd - shard.start;

      const outputSlice = new Uint8Array(shard.buffer, localStart,
                                         localEnd - localStart);
      outputArray.set(outputSlice, outputStart);
      sliced += outputSlice.length;

      if (end < shard.end) {
        break;
      }
    }
    return outputBuffer;
  }

  /**
   * Get the index of the shard that contains the byte at `byteIndex`.