mix-async-generator
Version:
``` npm i mix-async-generator ```
229 lines • 29.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MixAsyncGenerator = void 0;
const evt_1 = require("evt");
const util_extends_promise_1 = require("@bfchain/util-extends-promise");
const FastQuene_1 = require("./FastQuene");
const DONE = Promise.resolve({
step: { value: undefined, done: true },
});
class MixAsyncGenerator {
constructor() {
this._allGenList = new FastQuene_1.FastQuene();
/**正在执行中的任务，等待返回后就从这个集合中移除 */
this._runnings = new Map();
/**候补队列 */
this._benchGen = new FastQuene_1.FastQuene();
/**自由队列 */
this._freeGen = new FastQuene_1.FastQuene();
this._genWaitter = new FastQuene_1.FastQuene();
// private _traceCount = 0;
this._freeResult = new FastQuene_1.FastQuene();
this._benchResult = new FastQuene_1.FastQuene();
this._resultWaiter = new FastQuene_1.FastQuene();
this.onError = new evt_1.Evt();
}
join(runner, opts) {
let bench = false;
let jumpGun;
let name = `gen-${this._allGenList.size + 1}`;
if (opts !== undefined) {
opts.name !== undefined && (name = opts.name);
opts.bench !== undefined && (bench = opts.bench);
jumpGun = opts.jumpGun;
}
if (jumpGun === undefined) {
jumpGun = bench ? 1 : 1; /**非惰性元素至少抢跑1步 */
}
if (bench === false && jumpGun < 1) {
throw new RangeError("when runner no in bench, jump gun should not be 0");
}
return this._join({
runner,
name,
bench,
jumpGun,
currentStep: undefined,
inQueueSteps: 0,
});
}
_join(gen) {
this._allGenList.push(gen);
/// 否则保存到惰性列表中，需要时再使用
if (gen.bench) {
this._benchGen.push(gen);
}
/// 如果是非惰性的，那么直接启动迭代
else {
this._handleGen(gen);
}
return gen;
}
remove(gen) {
if (this._allGenList.remove(gen)) {
/// 如果全部归空了，那么将其余在等待中的都关闭掉
if (this._allGenList.size === 0) {
do {
const waiter = this._resultWaiter.shift();
if (waiter === undefined) {
break;
}
waiter.resolve(DONE);
} while (true);
}
return true;
}
return false;
}
_enqueueGen(gen) {
// 是否有在等待中的
const waiter = this._genWaitter.shift();
if (waiter) {
waiter.resolve(gen);
}
/// 如果是惰性元素，那么回到惰性队列
else if (gen.bench) {
this._benchGen.push(gen);
}
/// 如果是非惰性元素，那么回到自由队列
else {
this._freeGen.push(gen);
}
}
async _dequeueGen() {
// 获取一个可用的迭代器
const gen = this._freeGen.shift() ||
this._benchGen.shift() ||
(await this._genWaitter.push(new util_extends_promise_1.PromiseOut()).promise);
this._handleGen(gen);
}
_handleGen(gen) {
const item = gen.runner.next();
this._runnings.set(item, gen);
// 如果完成，则回到自由队列
util_extends_promise_1.safePromiseThen(item, (value) => {
this._runnings.delete(item);
// 缓存当前结果
gen.currentStep = value;
/// 如果已经完结了，那么直接移除掉了
if (value.done) {
this.remove(gen);
/// 如果没有任何在执行中的元素，就需要继续从队列中读取出来执行，否则外面的Promise就永远无法resolve
if (this._runnings.size === 0) {
this._dequeueGen();
}
}
/// 否则回到队列中继续提供下一个迭代
else {
// 传递到结果队列中
this._enqueueResult({ from: gen, step: value });
/// 如果可以偷跑，那么继续执行
if (gen.inQueueSteps < gen.jumpGun) {
this._handleGen(gen);
}
else {
// 回到空闲队列中
this._enqueueGen(gen);
}
}
}, (reason) => {
this._runnings.delete(item);
// 如果已经出错，那么直接移除
this.remove(gen);
// 向外传递错误
this.onError.post({ from: gen, reason });
});
}
/**入列
* 这个函数与_handleGen是紧密关联的，是_handleGen的一部分
*/
_enqueueResult(result) {
/// 是否有在等待中的
const waiter = this._resultWaiter.shift();
if (waiter !== undefined) {
/**
* 因为本就是要直接返回的，所以这里直接将步数减去
*
* Waiter模式不需要修改inQueueSteps，因为是预约的，直接返回
*/
waiter.resolve(result);
}
else {
result.from.bench
? this._benchResult.push(result)
: this._freeResult.push(result);
result.from.inQueueSteps += 1;
}
}
/**出列 */
_dequeueResult() {
/// 再从结果队列中读取
const resultWithFrom1 = this._freeResult.shift();
if (resultWithFrom1 !== undefined) {
const gen = resultWithFrom1.from;
gen.inQueueSteps -= 1;
if (this._freeGen.remove(gen)) {
this._handleGen(gen);
}
return resultWithFrom1;
}
const resultWithFrom2 = this._benchResult.shift();
if (resultWithFrom2 !== undefined) {
const gen = resultWithFrom2.from;
gen.inQueueSteps -= 1;
if (this._benchGen.remove(gen)) {
this._handleGen(gen);
}
/**
* @TODO 使用了候补元素，那么就要对元素尽快进行补充
*/
return resultWithFrom2;
}
// 否则排队进行等待，Waiter模式不需要修改inQueueSteps，因为是预约的，直接返回
const resultPromise = this._resultWaiter.push(new util_extends_promise_1.PromiseOut()).promise;
/// 必要时，让选手出列
if (
// 如果没有任何一个在运行中的任务：那么立刻执行
this._runnings.size === 0 ||
// 如果自由队列为空，但是候补队列有存在的：那么也立刻执行
(this._freeGen.size === 0 && this._benchGen.size !== 0)) {
this._dequeueGen();
}
// console.log(++this._traceCount);
// if (this._traceCount === 2) {
// debugger;
// }
return resultPromise;
}
next() {
if (this.isDone) {
return DONE;
}
return this._dequeueResult();
}
get isDone() {
return (
/* _allGenList为空也就意味着_running为空 */ this._allGenList.size === 0 &&
this._freeResult.size === 0 &&
this._benchResult.size === 0);
}
async *toAsyncIterator() {
while (true) {
const result = await this.next();
if (result.step.done) {
return;
}
yield result.step.value;
}
}
async toPromise() {
while (true) {
const result = await this.next();
if (result.step.done) {
return;
}
}
}
}
exports.MixAsyncGenerator = MixAsyncGenerator;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MixAsyncGenerator.js","sourceRoot":"","sources":["../../src/MixAsyncGenerator.ts"],"names":[],"mappings":"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","sourcesContent":["import { Evt } from \"evt\";\r\nimport { safePromiseThen, PromiseOut } from \"@bfchain/util-extends-promise\";\r\nimport { FastQuene } from \"./FastQuene\";\r\n\r\nexport declare namespace MixAsyncGenerator {\r\n  type AG<NextOut = unknown, Return = unknown, NextIn = unknown> = [\r\n    NextOut,\r\n    Return,\r\n    NextIn\r\n  ];\r\n  type Gen<T extends AG, B extends boolean = boolean> = {\r\n    name: string;\r\n    runner: AsyncGenerator<T[0], T[1], T[2]>;\r\n    /**替补元素/惰性元素\r\n     * 意味着只有到不得不用的时候才会去使用\r\n     */\r\n    bench: B;\r\n    /**当前的步伐 */\r\n    currentStep: IteratorResult<T[0], T[1]> | undefined;\r\n    /**偷跑的步数，默认是0\r\n     * 偷跑意味着它始终会努力提供jumpGun个result\r\n     * 替补元素也可以偷跑，但只有轮到它上场才能偷跑\r\n     */\r\n    jumpGun: number;\r\n    /**缓存在队列中的步伐数 */\r\n    inQueueSteps: number;\r\n  };\r\n  type Result<T extends AG> = {\r\n    step: IteratorResult<T[0], T[1]>;\r\n    from?: Gen<T>;\r\n  };\r\n  type ResultWithFrom<T extends AG, B extends boolean = boolean> = {\r\n    step: IteratorResult<T[0], T[1]>;\r\n    from: Gen<T, B>;\r\n  };\r\n  type Error<T extends AG> = {\r\n    from: Gen<T>;\r\n    reason: unknown;\r\n  };\r\n}\r\n\r\nconst DONE = Promise.resolve({\r\n  step: { value: undefined, done: true as const },\r\n});\r\n\r\nexport class MixAsyncGenerator<\r\n  T extends MixAsyncGenerator.AG = MixAsyncGenerator.AG\r\n> {\r\n  private _allGenList = new FastQuene<MixAsyncGenerator.Gen<T>>();\r\n  join(\r\n    runner: AsyncGenerator<T[0], T[1], T[2]>,\r\n    opts?: { name?: string; bench?: boolean; jumpGun?: number }\r\n  ) {\r\n    let bench = false;\r\n    let jumpGun: number | undefined;\r\n    let name = `gen-${this._allGenList.size + 1}`;\r\n    if (opts !== undefined) {\r\n      opts.name !== undefined && (name = opts.name);\r\n      opts.bench !== undefined && (bench = opts.bench);\r\n      jumpGun = opts.jumpGun;\r\n    }\r\n    if (jumpGun === undefined) {\r\n      jumpGun = bench ? 1 : 1; /**非惰性元素至少抢跑1步 */\r\n    }\r\n    if (bench === false && jumpGun < 1) {\r\n      throw new RangeError(\"when runner no in bench, jump gun should not be 0\");\r\n    }\r\n\r\n    return this._join({\r\n      runner,\r\n      name,\r\n      bench,\r\n      jumpGun,\r\n      currentStep: undefined,\r\n      inQueueSteps: 0,\r\n    });\r\n  }\r\n  private _join(gen: MixAsyncGenerator.Gen<T>) {\r\n    this._allGenList.push(gen);\r\n    /// 否则保存到惰性列表中，需要时再使用\r\n    if (gen.bench) {\r\n      this._benchGen.push(gen as MixAsyncGenerator.Gen<T, true>);\r\n    }\r\n    /// 如果是非惰性的，那么直接启动迭代\r\n    else {\r\n      this._handleGen(gen);\r\n    }\r\n    return gen;\r\n  }\r\n  remove(gen: MixAsyncGenerator.Gen<T>) {\r\n    if (this._allGenList.remove(gen)) {\r\n      /// 如果全部归空了，那么将其余在等待中的都关闭掉\r\n      if (this._allGenList.size === 0) {\r\n        do {\r\n          const waiter = this._resultWaiter.shift();\r\n          if (waiter === undefined) {\r\n            break;\r\n          }\r\n          waiter.resolve(DONE);\r\n        } while (true);\r\n      }\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n  private _enqueueGen(gen: MixAsyncGenerator.Gen<T>) {\r\n    // 是否有在等待中的\r\n    const waiter = this._genWaitter.shift();\r\n    if (waiter) {\r\n      waiter.resolve(gen);\r\n    }\r\n    /// 如果是惰性元素，那么回到惰性队列\r\n    else if (gen.bench) {\r\n      this._benchGen.push(gen as MixAsyncGenerator.Gen<T, true>);\r\n    }\r\n    /// 如果是非惰性元素，那么回到自由队列\r\n    else {\r\n      this._freeGen.push(gen as MixAsyncGenerator.Gen<T, false>);\r\n    }\r\n  }\r\n  private async _dequeueGen() {\r\n    // 获取一个可用的迭代器\r\n    const gen =\r\n      this._freeGen.shift() ||\r\n      this._benchGen.shift() ||\r\n      (await this._genWaitter.push(new PromiseOut()).promise);\r\n    this._handleGen(gen);\r\n  }\r\n  /**正在执行中的任务，等待返回后就从这个集合中移除 */\r\n  private _runnings = new Map<\r\n    Promise<IteratorResult<T[0], T[1]>>,\r\n    MixAsyncGenerator.Gen<T>\r\n  >();\r\n  private _handleGen(gen: MixAsyncGenerator.Gen<T>) {\r\n    const item = gen.runner.next();\r\n    this._runnings.set(item, gen);\r\n    // 如果完成，则回到自由队列\r\n    safePromiseThen(\r\n      item,\r\n      (value) => {\r\n        this._runnings.delete(item);\r\n        // 缓存当前结果\r\n        gen.currentStep = value;\r\n        /// 如果已经完结了，那么直接移除掉了\r\n        if (value.done) {\r\n          this.remove(gen);\r\n\r\n          /// 如果没有任何在执行中的元素，就需要继续从队列中读取出来执行，否则外面的Promise就永远无法resolve\r\n          if (this._runnings.size === 0) {\r\n            this._dequeueGen();\r\n          }\r\n        }\r\n        /// 否则回到队列中继续提供下一个迭代\r\n        else {\r\n          // 传递到结果队列中\r\n          this._enqueueResult({ from: gen, step: value });\r\n\r\n          /// 如果可以偷跑，那么继续执行\r\n          if (gen.inQueueSteps < gen.jumpGun) {\r\n            this._handleGen(gen);\r\n          } else {\r\n            // 回到空闲队列中\r\n            this._enqueueGen(gen);\r\n          }\r\n        }\r\n      },\r\n      (reason: unknown) => {\r\n        this._runnings.delete(item);\r\n        // 如果已经出错，那么直接移除\r\n        this.remove(gen);\r\n        // 向外传递错误\r\n        this.onError.post({ from: gen, reason });\r\n      }\r\n    );\r\n  }\r\n\r\n  /**候补队列 */\r\n  private _benchGen = new FastQuene<MixAsyncGenerator.Gen<T, true>>();\r\n  /**自由队列 */\r\n  private _freeGen = new FastQuene<MixAsyncGenerator.Gen<T, false>>();\r\n  private _genWaitter = new FastQuene<PromiseOut<MixAsyncGenerator.Gen<T>>>();\r\n  /**入列\r\n   * 这个函数与_handleGen是紧密关联的，是_handleGen的一部分\r\n   */\r\n  private _enqueueResult(result: MixAsyncGenerator.ResultWithFrom<T>) {\r\n    /// 是否有在等待中的\r\n    const waiter = this._resultWaiter.shift();\r\n    if (waiter !== undefined) {\r\n      /**\r\n       * 因为本就是要直接返回的，所以这里直接将步数减去\r\n       *\r\n       * Waiter模式不需要修改inQueueSteps，因为是预约的，直接返回\r\n       */\r\n      waiter.resolve(result);\r\n    } else {\r\n      result.from.bench\r\n        ? this._benchResult.push(\r\n            result as MixAsyncGenerator.ResultWithFrom<T, true>\r\n          )\r\n        : this._freeResult.push(\r\n            result as MixAsyncGenerator.ResultWithFrom<T, false>\r\n          );\r\n      result.from.inQueueSteps += 1;\r\n    }\r\n  }\r\n  /**出列 */\r\n  private _dequeueResult() {\r\n    /// 再从结果队列中读取\r\n    const resultWithFrom1 = this._freeResult.shift();\r\n    if (resultWithFrom1 !== undefined) {\r\n      const gen = resultWithFrom1.from;\r\n      gen.inQueueSteps -= 1;\r\n      if (this._freeGen.remove(gen)) {\r\n        this._handleGen(gen);\r\n      }\r\n      return resultWithFrom1;\r\n    }\r\n\r\n    const resultWithFrom2 = this._benchResult.shift();\r\n    if (resultWithFrom2 !== undefined) {\r\n      const gen = resultWithFrom2.from;\r\n      gen.inQueueSteps -= 1;\r\n      if (this._benchGen.remove(gen)) {\r\n        this._handleGen(gen);\r\n      }\r\n      /**\r\n       * @TODO 使用了候补元素，那么就要对元素尽快进行补充\r\n       */\r\n      return resultWithFrom2;\r\n    }\r\n\r\n    // 否则排队进行等待，Waiter模式不需要修改inQueueSteps，因为是预约的，直接返回\r\n    const resultPromise = this._resultWaiter.push(new PromiseOut()).promise;\r\n    /// 必要时，让选手出列\r\n    if (\r\n      // 如果没有任何一个在运行中的任务：那么立刻执行\r\n      this._runnings.size === 0 ||\r\n      // 如果自由队列为空，但是候补队列有存在的：那么也立刻执行\r\n      (this._freeGen.size === 0 && this._benchGen.size !== 0)\r\n    ) {\r\n      this._dequeueGen();\r\n    }\r\n    // console.log(++this._traceCount);\r\n    // if (this._traceCount === 2) {\r\n    //   debugger;\r\n    // }\r\n    return resultPromise;\r\n  }\r\n  // private _traceCount = 0;\r\n  private _freeResult = new FastQuene<\r\n    MixAsyncGenerator.ResultWithFrom<T, false>\r\n  >();\r\n  private _benchResult = new FastQuene<\r\n    MixAsyncGenerator.ResultWithFrom<T, true>\r\n  >();\r\n  private _resultWaiter = new FastQuene<\r\n    PromiseOut<MixAsyncGenerator.Result<T>>\r\n  >();\r\n  readonly onError = new Evt<MixAsyncGenerator.Error<T>>();\r\n  next() {\r\n    if (this.isDone) {\r\n      return DONE as Promise<MixAsyncGenerator.Result<T>>;\r\n    }\r\n    return this._dequeueResult();\r\n  }\r\n  get isDone() {\r\n    return (\r\n      /* _allGenList为空也就意味着_running为空 */ this._allGenList.size === 0 &&\r\n      this._freeResult.size === 0 &&\r\n      this._benchResult.size === 0\r\n    );\r\n  }\r\n  async *toAsyncIterator() {\r\n    while (true) {\r\n      const result = await this.next();\r\n      if (result.step.done) {\r\n        return;\r\n      }\r\n      yield result.step.value;\r\n    }\r\n  }\r\n  async toPromise() {\r\n    while (true) {\r\n      const result = await this.next();\r\n      if (result.step.done) {\r\n        return;\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}