lik/ts/classes.interestmap.ts

/* ===========
The InterestMap is an mechanism that collects interests into something
An interest is expressed by an object, string or number.
A comparison func can be specified to make interests comparable

For every unique interestId an interest is created.
Subssequent interests will be mapped to the same interest
which is then is only fullfilled once.
=========== */

import * as plugins from './classes.plugins.js';
import { ObjectMap } from './classes.objectmap.js';
import { Interest } from './classes.interestmap.interest.js';

export type IInterestComparisonFunc<T> = (objectArg: T) => string;

export interface IInterestMapOptions {
  markLostAfterDefault?: number;
}

export class InterestMap<DTInterestId, DTInterestFullfillment> {
  public options: IInterestMapOptions;

  /**
   * stores interests that are currently fullfilled by the cache
   */
  private interestObjectMap = new ObjectMap<Interest<DTInterestId, DTInterestFullfillment>>();

  /**
   * O(1) lookup of interests by their comparison string
   */
  private interestsByComparisonString = new Map<string, Interest<DTInterestId, DTInterestFullfillment>>();

  /**
   * a function to compare interests
   */
  private comparisonFunc: IInterestComparisonFunc<DTInterestId>;

  constructor(
    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
    optionsArg: IInterestMapOptions = {}
  ) {
    this.comparisonFunc = comparisonFuncArg;
    this.options = optionsArg;
  }

  /**
   * adds an interest to the InterestMap
   * @param interestId
   */
  public async addInterest(
    interestId: DTInterestId,
    defaultFullfillmentArg?: DTInterestFullfillment
  ): Promise<Interest<DTInterestId, DTInterestFullfillment>> {
    const comparisonString = this.comparisonFunc(interestId);
    let returnInterest: Interest<DTInterestId, DTInterestFullfillment>;

    const existingInterest = this.interestsByComparisonString.get(comparisonString);
    if (existingInterest) {
      returnInterest = existingInterest;
      returnInterest.renew();
    } else {
      returnInterest = new Interest<DTInterestId, DTInterestFullfillment>(
        this,
        interestId,
        this.comparisonFunc,
        {
          markLostAfterDefault: this.options.markLostAfterDefault,
          defaultFullfillment: defaultFullfillmentArg,
        }
      );
      this.interestObjectMap.add(returnInterest);
      this.interestsByComparisonString.set(comparisonString, returnInterest);
    }
    this.interestObservable.push(returnInterest);
    return returnInterest;
  }

  public interestObservable = new plugins.smartrx.ObservableIntake<Interest<DTInterestId, any>>();

  /**
   * removes an interest from the interest map
   */
  public removeInterest(interestArg: Interest<DTInterestId, DTInterestFullfillment>) {
    this.interestObjectMap.findOneAndRemoveSync((interestArg2) => {
      return interestArg.comparisonString === interestArg2.comparisonString;
    });
    this.interestsByComparisonString.delete(interestArg.comparisonString);
  }

  /**
   * check interest
   */
  public checkInterest(objectArg: DTInterestId): boolean {
    const comparisonString = this.comparisonFunc(objectArg);
    return this.checkInterestByString(comparisonString);
  }

  /**
   * checks an interest
   * @param comparisonStringArg
   */
  public checkInterestByString(comparisonStringArg: string): boolean {
    return this.interestsByComparisonString.has(comparisonStringArg);
  }

  /**
   * inform lost interest
   * @param interestId
   */
  public informLostInterest(interestId: DTInterestId) {
    const wantedInterest = this.findInterest(interestId);
    if (wantedInterest) {
      wantedInterest.markLost();
    }
  }

  /**
   * finds an interest
   * @param interestId
   */
  public findInterest(interestId: DTInterestId): Interest<DTInterestId, DTInterestFullfillment> {
    const comparableString = this.comparisonFunc(interestId);
    return this.interestsByComparisonString.get(comparableString) ?? null;
  }

  /**
   * destroys the InterestMap and cleans up all resources
   */
  public destroy() {
    const interests = this.interestObjectMap.getArray();
    for (const interest of interests) {
      interest.destroy();
    }
    this.interestObjectMap.wipe();
    this.interestsByComparisonString.clear();
    this.interestObservable.signalComplete();
  }
}