implab/implabjs-core Commit - r170:1391543e8282

Added Cancellation.combine(...tokens) method to combine multiple cancellation...

cin -

r170:1391543e8282 v1.4.5 default

parent child

Context file:

r170:1391543e8282

Collapse all files

src/main/ts/CancellationAggregate.ts created 644 +41 0

@@ -0,0 +1,41
	1	import { ICancellation, IDestroyable } from "./interfaces";
	2
	3	export class CancellationAggregate implements ICancellation {
	4	private readonly _tokens: ICancellation[];
	5
	6	constructor(tokens: ICancellation[]) {
	7	this._tokens = tokens \|\| [];
	8	}
	9
	10	throwIfRequested() {
	11	this._tokens.forEach(ct => ct.throwIfRequested());
	12	}
	13
	14	isRequested() {
	15	return this._tokens.some(ct => ct.isRequested());
	16	}
	17	isSupported() {
	18	return !!this._tokens.length;
	19	}
	20	register(cb: (e: any) => void): IDestroyable {
	21	let fired = false;
	22
	23	const once = (e: any) => {
	24	if (!fired) {
	25	fired = true;
	26	destroy();
	27	cb(e);
	28	}
	29	}
	30
	31	const destroy = () => subscriptions
	32	.splice(0,subscriptions.length) // empty array
	33	.forEach(subscription => subscription.destroy()); // cleanup
	34
	35	const subscriptions = this._tokens.map(ct => ct.register(once))
	36
	37	return {
	38	destroy
	39	};
	40	}
	41	}

src/main/ts/Cancellation.ts +23 0

+            import { CancellationAggregate } from "./CancellationAggregate";
             import { ICancellation, IDestroyable } from "./interfaces";
             import { argumentNotNull, destroyed } from "./safe";
             export class Cancellation implements ICancellation {
                 private _reason: any;
                 private _cbs: Array<(e: any) => void> | undefined;
                 constructor(action: (cancel: (e?: any) => void) => void) {
                     argumentNotNull(action, "action");
                     action(this._cancel.bind(this));
                 }
                 isSupported(): boolean {
                     return true;
                 }
                 throwIfRequested(): void {
                     if (this._reason)
                         throw this._reason;
                 }
                 isRequested(): boolean {
                     return !!this._reason;
                 }
                 register(cb: (e: any) => void): IDestroyable {
                     argumentNotNull(cb, "cb");
                     if (this._reason) {
                         cb(this._reason);
                         return destroyed;
                     } else {
                         if (!this._cbs)
                             this._cbs = [cb];
                         else
                             this._cbs.push(cb);
                         const me = this;
                         return {
                             destroy() {
                                 me._unregister(cb);
                             }
                         };
                     }
                 }
                 private _unregister(cb: any) {
                     if (this._cbs) {
                         const i = this._cbs.indexOf(cb);
                         if (i >= 0)
                             this._cbs.splice(i, 1);
                     }
                 }
                 private _cancel(reason: any) {
                     if (this._reason)
                         return;
                     this._reason = (reason = reason || new Error("Operation cancelled"));
                     if (this._cbs) {
                         this._cbs.forEach(cb => cb(reason));
                         this._cbs = undefined;
                     }
                 }
                 static readonly none: ICancellation = {
                     isSupported(): boolean {
                         return false;
                     },
                     throwIfRequested(): void {
                     },
                     isRequested(): boolean {
                         return false;
                     },
                     register(_cb: (e: any) => void): IDestroyable {
                         return destroyed;
                     }
                 };
+                /**
+                 * Combines multiple cancellation tokens to the single aggregated token.
+                 *
+                 * Aggregated token will be considered as signalled when some tokens are
+                 * signalled. The cancellation callback can be registered with the `register`
+                 * method, it will be fired once with the first signalled token, all other
+                 * tokens will be ignored.
+                 *
+                 * The tokens which don't support cancellation are filtered out, if there are
+                 * no tokens left in the list the method returns `Cancellation.none`.
+                 *
+                 * @param args The list of cancellation tokens to combine
+                 * @returns
+                 */
+                static combine(...args: ICancellation[]) {
+                    const tokens = args.filter(ct => ct.isSupported());
+                    return tokens.length > 1 ?
+                        new CancellationAggregate(tokens) :
+                        tokens.length == 1 ? tokens[0] :
+                            this.none;
+                }
             }

src/main/ts/components/AsyncComponent.ts +2 -8

             import { Cancellation } from "../Cancellation";
-            import { IAsyncComponent, ICancellation, ICancellable, IDestroyable } from "../interfaces";
+            import { IAsyncComponent, ICancellation, ICancellable } from "../interfaces";
-            import { destroy } from "../safe";
             const noop = () => void (0);
             export class AsyncComponent implements IAsyncComponent, ICancellable {
                 _cancel: ((e: any) => void) = noop;
                 _completion: Promise<void> = Promise.resolve();
                 getCompletion() { return this._completion; }
                 runOperation(op: (ct: ICancellation) => any, ct: ICancellation = Cancellation.none) {
                     // create inner cancellation bound to the passed cancellation token
-                    let h: IDestroyable;
                     const inner = new Cancellation(cancel => {
                         this._cancel = cancel;
-                        h = ct.register(cancel);
                     });
-                    // TODO create cancellation source here
                     const guard = async () => {
                         try {
-                            await op(inner);
+                            return op(Cancellation.combine(ct, inner));
                         } finally {
                             // after the operation is complete we need to cleanup the
                             // resources
-                            destroy(h);
                             this._cancel = noop;
                         }
                     };
                     return this._completion = guard();
                 }
                 cancel(reason: any) {
                     this._cancel(reason);
                 }
             }

src/test/ts/tests/CancellationTests.ts +18 0

             import { Cancellation } from "../Cancellation";
+            import { CancellationAggregate } from "../CancellationAggregate";
             import { delay, notImplemented } from "../safe";
             import { test } from "./TestTraits";
             test("standalone cancellation", async t => {
                 let doCancel: (e: any) => void = notImplemented;
                 const ct = new Cancellation(cancel => {
                     doCancel = cancel;
                 });
                 let counter = 0;
                 const reason = "BILL";
                 t.true(ct.isSupported(), "Cancellation must be supported");
                 t.false(ct.isRequested(), "Cancellation shouldn't be requested");
                 ct.throwIfRequested();
                 t.pass("The exception shouldn't be thrown unless the cancellation is requested");
                 ct.register(() => counter++);
                 t.equals(counter, 0, "counter should be zero");
                 ct.register(() => counter++).destroy();
                 doCancel(reason);
                 t.true(ct.isRequested(), "Cancellation should be requested");
                 t.equals(counter, 1, "The registered callback should be triggered");
                 ct.register(() => counter++);
                 t.equals(counter, 2, "The callback should be triggered immediately");
                 let msg;
                 ct.register(e => msg = e);
                 t.equals(msg, reason, "The cancellation reason should be passed to callback");
                 try {
                     msg = null;
                     ct.throwIfRequested();
                     t.fail("The exception should be thrown");
                 } catch (e) {
                     msg = e;
                 }
                 t.equals(msg, reason, "The cancellation reason should be catched");
             });
             test("async cancellation", async t => {
                 const ct = new Cancellation(cancel => {
                     cancel("STOP!");
                 });
                 try {
                     await delay(0, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
             });
             test("cancel with external event", async t => {
                 const ct = new Cancellation(cancel => {
                     setTimeout(x => cancel("STOP!"), 0);
                 });
                 try {
                     await delay(10000, ct);
                     t.fail("Should thow the exception");
                 } catch (e) {
                     t.equals(e, "STOP!", "Should throw the cancellation reason");
                 }
             });
             test("operation normal flow", async t => {
                 let htimeout;
                 const ct = new Cancellation(cancel => {
                     htimeout = setTimeout(() => cancel("STOP!"), 1000);
                 });
                 try {
                     await delay(0, ct);
                     t.pass("Should pass");
                 } finally {
                     clearTimeout(htimeout);
                 }
             });
+            test("combine cancellations", t => {
+                const ct1 = new Cancellation(cancel => {
+                    cancel("cancelled");
+                });
+                const ct2 = new Cancellation(() => {});
+                const cct1 = Cancellation.combine(Cancellation.none, ct1);
+                t.equals(cct1, ct1, "Cancellation.combine should filter out Cancellation.none tokens");
+                const cct2 = Cancellation.combine(Cancellation.none, ct1, ct2);
+                t.assert(cct2 instanceof CancellationAggregate, "Cancellation.combine should return CancellationAggregate");
+                t.true(cct2.isRequested(), "CancellationAggregate should return isRequested true if any of cancellations is requested");
+            });

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages