@blackglory/structures 0.14.14 → 0.15.0

package/src/sparse-map/resizable-typed-sparse-map-lite.ts

@@ -0,0 +1,122 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+import { ResizableTypedArray } from '@src/resizable-typed-array.js'
+
+export class ResizableTypedSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: ResizableTypedArray<K>
+  private denseValues: ResizableTypedArray<V>
+  private sparse: Array<number | undefined> = []
+
+  readonly internalKeyArray: TypedArrayOfConstructor<K>
+  readonly internalValueArray: TypedArrayOfConstructor<V>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  constructor(
+    keys: ResizableTypedArray<K>
+  , values: ResizableTypedArray<V>
+  ) {
+    assert(keys.length === 0, 'values must be empty')
+
+    this.denseKeys = keys
+    this.denseValues = values
+
+    this.internalKeyArray = keys.internalTypedArray
+    this.internalValueArray = values.internalTypedArray
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [
+        this.denseKeys.internalTypedArray[i]
+      , this.denseValues.internalTypedArray[i]
+      ]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<number> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      return index
+    }
+  }
+
+  has(key: number): boolean {
+    const index = this.sparse[key]
+    return index !== undefined
+        && this.denseKeys.get(index) === key
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      return this.denseValues.internalTypedArray[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      this.denseValues.internalTypedArray[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      this.denseKeys.get(index) === key
+    ) {
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys.internalTypedArray[index] = lastKey
+        this.denseValues.internalTypedArray[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.clear()
+    this.denseValues.clear()
+    // 无需清空sparse数组.
+  }
+}

package/src/sparse-map/sparse-map.ts

@@ -0,0 +1,104 @@
+export class SparseMap<T> {
+  private denseKeys: number[] = []
+  private denseValues: T[] = []
+  private sparse: Array<number | undefined> = []
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.denseKeys.length
+  }
+
+  readonly internalKeyArray: readonly number[] = this.denseKeys
+  readonly internalValueArray: T[] = this.denseValues
+
+  ;* entries(): IterableIterator<[key: number, value: T]> {
+    for (let i = 0; i < this.denseKeys.length; i++) {
+      yield [this.denseKeys[i], this.denseValues[i]]
+    }
+  }
+
+  keys(): IterableIterator<number> {
+    return this.denseKeys.values()
+  }
+
+  values(): IterableIterator<T> {
+    return this.denseValues.values()
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      return index
+    }
+  }
+
+  has(key: number): boolean {
+    const index = this.sparse[key]
+    return index !== undefined
+        && index < this.denseKeys.length // 用于改善JIT优化.
+        && this.denseKeys[index] === key
+  }
+
+  get(key: number): T | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      return this.denseValues[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: T): void {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      this.denseValues[index] = value
+    } else {
+      const index = this.denseKeys.length
+      this.denseKeys.push(key)
+      this.denseValues.push(value)
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      const lastKey = this.denseKeys.pop()!
+      const lastValue = this.denseValues.pop()!
+      if (key !== lastKey) {
+        this.denseKeys[index] = lastKey
+        this.denseValues[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.denseKeys.length = 0
+    this.denseValues.length = 0
+    // 无需清空sparse数组.
+  }
+}

package/src/sparse-map/typed-clean-sparse-map-lite.ts

@@ -0,0 +1,116 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+
+export class TypedCleanSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: TypedArrayOfConstructor<K>
+  private denseValues: TypedArrayOfConstructor<V>
+  private sparse: Array<number | undefined> = []
+  #length = 0
+
+  readonly internalKeyArray: TypedArrayOfConstructor<K, ArrayBuffer>
+  readonly internalValueArray: TypedArrayOfConstructor<V, ArrayBuffer>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(
+    keys: TypedArrayOfConstructor<K, ArrayBuffer>
+  , values: TypedArrayOfConstructor<V, ArrayBuffer>
+  ) {
+    assert(!keys.buffer.resizable, 'The keys buffer must not be resizable')
+    assert(!values.buffer.resizable, 'The values buffer must not be resizable')
+    assert(
+      values.length >= keys.length
+    , 'The values.length must greater than or equal to keys.length'
+    )
+
+    this.denseKeys = keys
+    this.denseValues = values
+
+    this.internalKeyArray = keys
+    this.internalValueArray = values
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.#length; i++) {
+      yield [
+        this.denseKeys[i]
+      , this.denseValues[i]
+      ]
+    }
+  }
+
+  * keys(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseKeys[i]
+    }
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseValues[i]
+    }
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    return this.sparse[key]
+  }
+
+  has(key: number): boolean {
+    return this.sparse[key] !== undefined
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      return this.denseValues[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.denseValues[index] = value
+    } else {
+      const index = this.#length++
+      this.denseKeys[index] = key
+      this.denseValues[index] = value
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (index !== undefined) {
+      this.sparse[key] = undefined
+
+      const lastIndex = --this.#length
+      const lastKey = this.denseKeys[lastIndex]
+      const lastValue = this.denseValues[lastIndex]
+      if (key !== lastKey) {
+        this.denseKeys[index] = lastKey
+        this.denseValues[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    this.sparse.length = 0
+  }
+}

package/src/sparse-map/typed-clean-sparse-map.ts

@@ -0,0 +1,149 @@
+import { assert } from '@blackglory/errors'
+import { go } from '@blackglory/go'
+import { getMaxValueOfUnsignedTypedArray, getMaxValueOfUnsignedTypedArrayConstructor } from '@utils/get-max-value-of-unsigned-typed-array.js'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor, UnsignedTypedArray } from 'justypes'
+
+export class TypedCleanSparseMap<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: TypedArrayOfConstructor<K>
+  private denseValues: TypedArrayOfConstructor<V>
+  private sparse: UnsignedTypedArray
+  private readonly NULL: number
+  #length = 0
+
+  readonly internalKeyArray: TypedArrayOfConstructor<K, ArrayBuffer>
+  readonly internalValueArray: TypedArrayOfConstructor<V, ArrayBuffer>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(
+    keys: TypedArrayOfConstructor<K, ArrayBuffer>
+  , values: TypedArrayOfConstructor<V, ArrayBuffer>
+  ) {
+    assert(!keys.buffer.resizable, 'The keys buffer must not be resizable')
+    assert(!values.buffer.resizable, 'The values buffer must not be resizable')
+    assert(
+      values.length >= keys.length
+    , 'The values.length must greater than or equal to keys.length'
+    )
+
+    this.denseKeys = keys
+    this.denseValues = values
+
+    this.internalKeyArray = keys
+    this.internalValueArray = values
+
+    const NULL = Math.min(
+      keys.length
+    , getMaxValueOfUnsignedTypedArray(keys) + 1
+    )
+    this.NULL = NULL
+
+    const sparseConstructor = go(() => {
+      if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint8Array)
+      ) {
+        return Uint8Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint16Array)
+      ) {
+        return Uint16Array
+      } else if (
+        NULL <=
+        getMaxValueOfUnsignedTypedArrayConstructor(Uint32Array)
+      ) {
+        return Uint32Array
+      } else {
+        throw new Error('The array is too large')
+      }
+    })
+    const sparse = new sparseConstructor(getMaxValueOfUnsignedTypedArray(keys) + 1)
+    sparse.fill(NULL)
+    this.sparse = sparse
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.#length; i++) {
+      yield [
+        this.denseKeys[i]
+      , this.denseValues[i]
+      ]
+    }
+  }
+
+  * keys(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseKeys[i]
+    }
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseValues[i]
+    }
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    return this.sparse[key]
+  }
+
+  has(key: number): boolean {
+    return this.sparse[key] !== this.NULL
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (index !== this.NULL) {
+      return this.denseValues[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (index !== this.NULL) {
+      this.denseValues[index] = value
+    } else {
+      const index = this.#length++
+      this.denseKeys[index] = key
+      this.denseValues[index] = value
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (index !== this.NULL) {
+      this.sparse[key] = this.NULL
+
+      const lastIndex = --this.#length
+      const lastKey = this.denseKeys[lastIndex]
+      const lastValue = this.denseValues[lastIndex]
+      if (key !== lastKey) {
+        this.denseKeys[index] = lastKey
+        this.denseValues[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    this.sparse.fill(this.NULL)
+  }
+}

package/src/sparse-map/typed-sparse-map-lite.ts

@@ -0,0 +1,141 @@
+import { assert } from '@blackglory/errors'
+import { TypedArrayConstructor, UnsignedTypedArrayConstructor, TypedArrayOfConstructor } from 'justypes'
+
+export class TypedSparseMapLite<
+  K extends UnsignedTypedArrayConstructor
+, V extends TypedArrayConstructor
+> {
+  private denseKeys: TypedArrayOfConstructor<K>
+  private denseValues: TypedArrayOfConstructor<V>
+  private sparse: Array<number | undefined> = []
+  #length = 0
+
+  readonly internalKeyArray: TypedArrayOfConstructor<K, ArrayBuffer>
+  readonly internalValueArray: TypedArrayOfConstructor<V, ArrayBuffer>
+
+  get [Symbol.toStringTag](): string {
+    return this.constructor.name
+  }
+
+  get size(): number {
+    return this.#length
+  }
+
+  constructor(
+    keys: TypedArrayOfConstructor<K, ArrayBuffer>
+  , values: TypedArrayOfConstructor<V, ArrayBuffer>
+  ) {
+    assert(!keys.buffer.resizable, 'The keys buffer must not be resizable')
+    assert(!values.buffer.resizable, 'The values buffer must not be resizable')
+    assert(
+      values.length >= keys.length
+    , 'The values.length must greater than or equal to keys.length'
+    )
+
+    this.denseKeys = keys
+    this.denseValues = values
+
+    this.internalKeyArray = keys
+    this.internalValueArray = values
+  }
+
+  * entries(): IterableIterator<[key: number, value: number]> {
+    for (let i = 0; i < this.#length; i++) {
+      yield [
+        this.denseKeys[i]
+      , this.denseValues[i]
+      ]
+    }
+  }
+
+  * keys(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseKeys[i]
+    }
+  }
+
+  * values(): IterableIterator<number> {
+    for (let i = 0; i < this.#length; i++) {
+      yield this.denseValues[i]
+    }
+  }
+
+  getInternalIndexOfKey(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      return index
+    }
+  }
+
+  has(key: number): boolean {
+    const index = this.sparse[key]
+    return index !== undefined
+        && index < this.#length
+        && index < this.denseKeys.length // 用于改善JIT优化.
+        && this.denseKeys[index] === key
+  }
+
+  get(key: number): number | undefined {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      return this.denseValues[index]
+    } else {
+      return undefined
+    }
+  }
+
+  set(key: number, value: number): void {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      this.denseValues[index] = value
+    } else {
+      const index = this.#length++
+      this.denseKeys[index] = key
+      this.denseValues[index] = value
+      this.sparse[key] = index
+    }
+  }
+
+  delete(key: number): boolean {
+    const index = this.sparse[key]
+    if (
+      index !== undefined &&
+      index < this.#length &&
+      index < this.denseKeys.length && // 用于改善JIT优化.
+      this.denseKeys[index] === key
+    ) {
+      const lastIndex = --this.#length
+      const lastKey = this.denseKeys[lastIndex]
+      const lastValue = this.denseValues[lastIndex]
+      if (key !== lastKey) {
+        this.denseKeys[index] = lastKey
+        this.denseValues[index] = lastValue
+        this.sparse[lastKey] = index
+      }
+
+      return true
+    } else {
+      return false
+    }
+  }
+
+  clear(): void {
+    this.#length = 0
+    // 无需清空dense和sparse数组.
+  }
+}