123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185
import { log2 } from "./utilities.ts";import type {  ComplexView,  ContainerView,  PrimitiveView,  ViewConstructor,  ViewInstance,  ViewSchema,} from "./view-types.ts";import type { View } from "./view.ts";
export class ArrayView<T> extends DataView implements ContainerView<T> {  static View: ViewConstructor<    unknown,    PrimitiveView<unknown> | ContainerView<unknown> | ComplexView<unknown>  >;  static viewLength = 0;  static itemLength: number;
  get size() {    return (this.constructor as typeof ArrayView).getSize(this.byteLength);  }
  static decode<T>(    view: DataView,    start = 0,    length = view.byteLength,  ): Array<T> {    const { View, itemLength } = this;    const size = this.getSize(length);    const array = new Array(size);    for (let i = 0; i < size; i++) {      const offset = this.getOffset(i);      array[i] = View.decode(view, start + offset, itemLength);    }    return array;  }
  static encode<T>(    value: Array<T>,    view: DataView,    start = 0,    length = view.byteLength,  ): number {    const { View, itemLength } = this;    const size = this.getSize(length);    const max = size < value.length ? size : value.length;    for (let i = 0; i < max; i++) {      const offset = this.getOffset(i);      View.encode(value[i], view, start + offset, itemLength);    }    const written = max * itemLength;    // zero-out remaining bytes    let caret = written;    while (caret < length) view.setUint8(start + caret++, 0);    return written;  }
  static from<T, U extends ArrayView<T>>(value: Array<T>): U {    const view = new this<T>(new ArrayBuffer(this.getOffset(value.length)));    this.encode<T>(value, view, 0, view.byteLength);    return view as U;  }
  static getLength(size: number): number {    return this.getOffset(size);  }
  static getOffset(index: number): number {    return (index * this.itemLength) | 0;  }
  static getSize(length: number): number {    return (length / this.itemLength) | 0;  }
  static indexOf<T>(    value: T,    view: DataView,    startIndex = 0,    startOffset = 0,    length = view.byteLength,  ): number {    const size = this.getSize(length);    const valueView = this.View.from(value);    outer:    for (let i = startIndex; i < size; i++) {      const offset = startOffset + this.getOffset(i);      for (let j = 0; j < valueView.byteLength; j++) {        if (valueView.getUint8(j) !== view.getUint8(offset + j)) continue outer;      }      return i;    }    return -1;  }
  *[Symbol.iterator](): Generator<ViewInstance<T>> {    const { size } = this;    for (let i = 0; i < size; i++) {      yield this.getView(i);    }  }
  at(index: number): T {    if (index < 0) return this.get(this.size + index);    return this.get(index);  }
  get(index: number): T {    const constructor = this.constructor as typeof ArrayView;    const View = constructor.View as ViewConstructor<T>;    return View.decode(this, constructor.getOffset(index));  }
  getLength(_: number): number {    return (this.constructor as typeof ArrayView).itemLength;  }
  getView(index: number): ViewInstance<T> {    const constructor = this.constructor as typeof ArrayView;    const View = constructor.View as ViewConstructor<T>;    return new View(      this.buffer,      this.byteOffset + constructor.getOffset(index),      constructor.itemLength,    );  }
  indexOf(value: T, start = 0): number {    return (this.constructor as typeof ArrayView).indexOf(      value,      this,      start,      0,      this.byteLength,    );  }
  set(index: number, value: T): void {    const constructor = this.constructor as typeof ArrayView;    const View = constructor.View as ViewConstructor<T>;    View.encode(      value,      this,      this.byteOffset + constructor.getOffset(index),      constructor.itemLength,    );  }
  setView(index: number, value: DataView): void {    const constructor = this.constructor as typeof ArrayView;    new Uint8Array(      this.buffer,      this.byteOffset + constructor.getOffset(index),      constructor.itemLength,    ).set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));  }
  toJSON(): Array<T> {    return (this.constructor as typeof ArrayView).decode<T>(      this,      0,      this.byteLength,    );  }
  static initialize<T>(    schema: ViewSchema<T>,    Factory: View,    SchemaView?: ViewConstructor<T>,    length?: number,  ): ViewConstructor<Array<T>> {    const ItemView = SchemaView ?? Factory.getExistingView(schema);    const itemLength = length ?? ItemView.viewLength;    if (itemLength === undefined || itemLength <= 0 || itemLength >= Infinity) {      throw TypeError("ArrayView should have fixed sized items.");    }    return class extends this<T> {      static View = ItemView;      static itemLength = itemLength;      static offset = log2[itemLength];    };  }}