initial commit

src/equality-set.ts

@@ -0,0 +1,195 @@
+import { Equater } from "./sync.js";
+import { MaybeAsyncEquater } from "./async.js";
+import { asAsyncGenerator } from "./utils.js";
+
+export interface EqualitySet<T> extends Iterable<T> {
+  readonly size: number;
+  add(obj: T): boolean;
+  contains(obj: T): boolean;
+  remove(obj: T): boolean;
+  clear(): void;
+}
+
+class NativeEqualitySet<T> implements EqualitySet<T> {
+  readonly #set = new Set<T>();
+
+  get size() {
+    return this.#set.size;
+  }
+
+  add(obj: T) {
+    const exists = this.contains(obj);
+    this.#set.add(obj);
+    return !exists;
+  }
+
+  contains(obj: T) {
+    return this.#set.has(obj);
+  }
+
+  remove(obj: T) {
+    return this.#set.delete(obj);
+  }
+
+  clear() {
+    this.#set.clear();
+  }
+
+  [Symbol.iterator]() {
+    return this.#set[Symbol.iterator]();
+  }
+}
+
+class CustomEqualitySet<T> implements EqualitySet<T> {
+  readonly #equater: Equater<T>;
+  readonly #list: T[] = [];
+
+  constructor(equater: Equater<T>) {
+    this.#equater = equater;
+  }
+
+  get size() {
+    return this.#list.length;
+  }
+
+  add(obj: T) {
+    if (this.contains(obj)) {
+      return false;
+    }
+
+    this.#list.push(obj);
+
+    return true;
+  }
+
+  contains(obj: T) {
+    for (const val of this.#list) {
+      if (this.#equater(obj, val)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  remove(obj: T) {
+    const length = this.#list.length;
+
+    for (let i = 0; i < length; i++) {
+      if (this.#equater(obj, this.#list[i])) {
+        this.#list.splice(i, 1);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  clear() {
+    this.#list.length = 0;
+  }
+
+  [Symbol.iterator]() {
+    return this.#list[Symbol.iterator]();
+  }
+}
+
+export function createEqualitySet<T>(equater?: Equater<T>): EqualitySet<T> {
+  return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
+}
+
+export interface AsyncEqualitySet<T> extends AsyncIterable<T> {
+  readonly size: number;
+  add(obj: T): Promise<boolean>;
+  contains(obj: T): Promise<boolean>;
+  remove(obj: T): Promise<boolean>;
+  clear(): Promise<void>;
+}
+
+class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
+  readonly #set = new Set<T>();
+
+  get size() {
+    return this.#set.size;
+  }
+
+  async add(obj: T) {
+    const exists = await this.contains(obj);
+    this.#set.add(obj);
+    return !exists;
+  }
+
+  async contains(obj: T) {
+    return this.#set.has(obj);
+  }
+
+  async remove(obj: T) {
+    return this.#set.delete(obj);
+  }
+
+  async clear() {
+    this.#set.clear();
+  }
+
+  [Symbol.asyncIterator]() {
+    return asAsyncGenerator(this.#set[Symbol.iterator]());
+  }
+}
+
+class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
+  readonly #equater: MaybeAsyncEquater<T>;
+  readonly #list: T[] = [];
+
+  constructor(equater: MaybeAsyncEquater<T>) {
+    this.#equater = equater;
+  }
+
+  get size() {
+    return this.#list.length;
+  }
+
+  async add(obj: T) {
+    if (await this.contains(obj)) {
+      return false;
+    }
+
+    this.#list.push(obj);
+
+    return true;
+  }
+
+  async contains(obj: T) {
+    for (const val of this.#list) {
+      if (await this.#equater(obj, val)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async remove(obj: T) {
+    const length = this.#list.length;
+
+    for (let i = 0; i < length; i++) {
+      if (await this.#equater(obj, this.#list[i])) {
+        this.#list.splice(i, 1);
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async clear() {
+    this.#list.length = 0;
+  }
+
+  [Symbol.asyncIterator]() {
+    return asAsyncGenerator(this.#list[Symbol.iterator]());
+  }
+}
+
+export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEquater<T>): AsyncEqualitySet<T> {
+  return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
+}