implab/implabjs-core Commit - r172:3969a8fb8049

Added CancelledError, fixed lint warnings

cin -

parent child

Context file:

r172:3969a8fb8049

Collapse all files

src/main/ts/CancelledError.ts created 644 +12 0

			@@ -0,0 +1,12
		1	import { Cancellation } from "./Cancellation";
		2	import { ICancellation } from "./interfaces";
		3
		4	export class CancelledError extends Error {
		5	readonly cancellationToken: ICancellation;
		6
		7	constructor(message = "The operation is cancelled", ct = Cancellation.none) {
		8	super(message);
		9	this.cancellationToken = ct;
		10	this.name = "CancelledError";
		11	}
		12	}

src/main/ts/Cancellation.ts +7 -6

              import { CancellationAggregate } from "./CancellationAggregate";
+             import { CancelledError } from "./CancelledError";
              import { ICancellation, IDestroyable } from "./interfaces";
              import { argumentNotNull, destroyed } from "./safe";
                      if (this._reason)
                          return;
-                     this._reason = (reason = reason || new Error("Operation cancelled"));
+                     this._reason = (reason = reason || new CancelledError(undefined, this));
                      if (this._cbs) {
                          this._cbs.forEach(cb => cb(reason));
                  /**
                   * 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
+                  * @returns Aggregated cancellation token
                   */
                  static combine(...args: ICancellation[]) {
                      const tokens = args.filter(ct => ct.isSupported());
                      return tokens.length > 1 ?
                          new CancellationAggregate(tokens) :
-                         tokens.length == 1 ? tokens[0] :
+                         tokens.length === 1 ? tokens[0] :
                              this.none;
                  }
              }

src/main/ts/CancellationAggregate.ts +4 -4

                              destroy();
                              cb(e);
                          }
+                     }
+                     };
                      const destroy = () => subscriptions
-                         .splice(0,subscriptions.length) // empty array
+                         .splice(0, subscriptions.length) // empty array
                          .forEach(subscription => subscription.destroy()); // cleanup
-                     const subscriptions = this._tokens.map(ct => ct.register(once))
+                     const subscriptions = this._tokens.map(ct => ct.register(once));
                      return {
                          destroy
                      };

src/main/ts/components/AsyncComponent.ts +4 -1

                      const guard = async () => {
                          try {
-                             return op(Cancellation.combine(ct, inner));
+                             const combined = Cancellation.combine(ct, inner);
+                             const result = await op(combined);
+                             combined.throwIfRequested();
+                             return result;
                          } finally {
                              // after the operation is complete we need to cleanup the
                              // resources

src/main/ts/di/LifetimeManager.ts +1 -1

                              _lifetime.store(item);
                          },
                          toString() {
-                             return `[object ContainerLifetime, has=${_lifetime.has()}]`
+                             return `[object ContainerLifetime, has=${_lifetime.has()}]`;
                          }
                      };
                  }

src/main/ts/interfaces.ts +38 0

		@@ -29,10 +29,48 export interface IRemovable {
29	29	remove(): void;
30	30	}
31	31
	32	/**
	33	* Interface for the cancellation token. Cancellation token is
	34	* a marker indicating that the cancellation was requested, it
	35	* is up to the operation to decide whether to interrupt or
	36	* to complete its execution.
	37	*
	38	* This interface defines several methods of interaction with
	39	* the cancellation i.e. either to poll its status or to react
	40	* through the callback.
	41	*/
32	42	export interface ICancellation {
	43	/**
	44	* Throws an exception if the cancellation has been requested,
	45	* otherwise does nothing.
	46	*/
33	47	throwIfRequested(): void;
	48
	49	/**
	50	* Checks whether the cancellation is requested.
	51	* @returns true is the cancellation has been requested,
	52	* otherwise returns false.
	53	*/
34	54	isRequested(): boolean;
	55
	56	/**
	57	* Checks the ability of the token to be signaled.
	58	*
	59	* @returns true if the token is able to request
	60	* the cancellation, false otherwise.
	61	*/
35	62	isSupported(): boolean;
	63
	64	/**
	65	* Registers the callback to be called when the cancellation
	66	* is requested.
	67	*
	68	* @param cb The callback which receives the reason of the
	69	* cancellation.
	70	* @returns The subscription, after the operation is completed
	71	* it should unregister the callback to free resources by
	72	* calling the `destroy()` method of the subscription.
	73	*/
36	74	register(cb: (e: any) => void): IDestroyable;
37	75	}
38	76

src/test/ts/tests/FluentContainerTests.ts +2 -2

                  });
                  t.assert(container.resolve("box").getValue(), "The dependency should be set");
-                 t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
+                 t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once");
              });
              test("Bad fluent config", async t => {
              test("Child container config", async t => {
                  const container = await new Container<{}>().applyConfig(import("../mock/config"));
                  const fooServices: ContainerConfiguration<FooServices> = (await import("../mock/config2")).default;
                  const child = await fooServices.apply(container.createChildContainer());

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