implab/implabjs-di Commit - r10:99a53d63fd6f

intoruced initial work on ILifetimeSlot

cin -

r10:99a53d63fd6f default

parent child

Context file:

r10:99a53d63fd6f

Collapse all files

src/main/ts/LifetimeManager.ts +91 -65

-             import { IActivationContext, ILifetime, ILifetimeManager } from "./interfaces";
+             import { IActivationContext, ILifetime, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
              import { ActivationContext } from "./ActivationContext";
              import { argumentNotNull, isDestroyable } from "./traits";
                  }
              };
-             const _emptyLifetime = Object.freeze({
-                 has() {
-                     return false;
-                 },
+             const _emptySlot = Object.freeze({
+                 has: () => false,
-                 initialize() {
-                 },
+                 initialize: () => void (0),
-                 get() {
+                 get: () => {
                      throw new Error("The specified item isn't registered with this lifetime manager");
                  },
-                 store() {
-                     // does nothing
-                 },
-                 toString() {
-                     return `[object EmptyLifetime]`;
+                 }
+                 store: () => void (0)
              });
-             const _unknownLifetime = Object.freeze({
-                 has() {
-                     return false;
-                 },
-                 initialize() {
+             const _unknonwSlot = Object.freeze({
+                 has: () => false,
+                 initialize: () => {
                      throw new Error("Can't call initialize on the unknown lifetime object");
                  },
-                 get() {
+                 get: () => {
                      throw new Error("The lifetime object isn't initialized");
                  },
-                 store() {
+                 store: () => {
                      throw new Error("Can't store a value in the unknown lifetime object");
-                 },
-                 toString() {
-                     return `[object UnknownLifetime]`;
                  }
              });
              const singletons: { [K: string]: unknown } = {};
-             export class LifetimeManager implements ILifetimeManager {
-                 private _cleanup: (() => void)[] = [];
-                 private readonly _cache: { [K: string]: unknown } = {};
-                 private _destroyed = false;
-                 private readonly _pending: { [K: string]: unknown } = {};
-                 create<T>(): ILifetime<T> & { remove(): void; } {
-                     const id = ++nextId;
-                     return {
-                         has: () => id in this._cache,
+             const pendingSlot = <T>(store: (item: T) => void) => ({
+                 has: () => false,
-                         get: () => {
-                             const t = this._cache[id] as T;
-                             if (t === undefined || t === null)
-                                 throw new Error(`The item with with the key ${id} isn't found`);
-                             return t;
+                     throw new Error("The value in this slot doesn't exist");
-                         },
-                         initialize: () => {
-                             if (this._pending[id])
-                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
-                             this._pending[id] = true;
+                     throw new Error("Cyclic reference detected");
+                 },
+                 store
+             });
+             const noop = () => void(0);
+             const valueSlot = <T>(value: T, cleanup: (item: T) => void) => ({
+                 has: () => true,
+                 get: () => value,
+                 initialize: () => {
+                     throw new Error("The slot already has a value");
-                         },
-                         store: (item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) => {
-                             if (id in this._cache)
-                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                             if (this._destroyed)
-                                 throw new Error("Lifetime manager is destroyed");
+                 store: () => {
+                     throw new Error("The slot already has a value");
+                 }
+             });
-                             delete this._pending[id];
+             export class LifetimeManager implements ILifetimeManager {
+                 private _destroyed = false;
-                             this._cache[id] = item;
+                 private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
+                 slot<T>(cookie: string): ILifetimeSlot<T> {
+                     if (cookie in this._slots)
+                         return this._slots[cookie] as ILifetimeSlot<T>;
-                             if (cleanup) {
-                                 this._cleanup.push(() => cleanup(item));
-                             } else if (isDestroyable(item)) {
-                                 this._cleanup.push(() => item.destroy());
+                             }
+                     const store = (item: T, cleanup?: (item: T) => void) => {
+                         this._assertNotDestroyed();
+                         this._slots[cookie] = valueSlot(
+                             item,
+                             cleanup ?? isDestroyable(item) ? () => item.destroy() : noop
+                         );
+                     };
+                     return {
+                         has: () => false,
+                         get: () => {
+                             throw new Error("The value isn't stored in this slot");
                          },
-                         remove: () => {
-                             if (this._pending[id])
-                                 throw new Error(`The item '${id}' can't be removed before it has been stored`);
-                             delete this._cache[id];
+                         store,
+                         initialize: () => {
+                             this._assertNotDestroyed();
+                             this._slots[cookie] = pendingSlot(store);
                          }
                      };
                  }
+                 private _assertNotDestroyed() {
+                     if (this._destroyed)
+                         throw new Error("The lifetime manager is destroyed");
+                 }
                  destroy() {
                      if (!this._destroyed) {
                          this._destroyed = true;
              export const hierarchyLifetime = <T>(): ILifetime<T> => {
                  let _lifetime: ILifetime<T> = _unknownLifetime;
                  return {
-                     initialize(context: IActivationContext<object>) {
+                     initialize(context: ILifetimeContext) {
                          if (_lifetime !== _unknownLifetime)
                              throw new Error("Cyclic reference activation detected");
                  };
              };
+             /**
+              * Creates a lifetime instance bound to the current activation context. This
+              * lifetime will store the service instance per activation context. Every
+              * top level service resolution will create a new activation context. This
+              * context is propagated to subsequent service resolution thus all services
+              * with context lifetime will be shared among their consumers.
+              *
+              * @returns The instance of the lifetime.
+              */
              export const contextLifetime = <T>(): ILifetime<T> => {
                  let _lifetime: ILifetime<T> = _unknownLifetime;
                  return {
-                     initialize(context: ActivationContext<object>) {
+                     initialize(context: ILifetimeContext) {
                          if (_lifetime !== _unknownLifetime)
                              throw new Error("Cyclic reference detected");
                          _lifetime = context.createLifetime();
                  };
              };
+             /**
+              * Creates the lifetime for the service which will allow existence only one
+              * instance with the specified {@linkcode typeId}. If there will be created
+              * several lifetime instances with same `typeId` in the runtime, they will
+              * share the same service instance.
+              *
+              * @param typeId The identified for the global instance, usually this is a
+              *   fully qualified class name
+              * @returns The lifetime instance
+              */
              export const singletonLifetime = <T>(typeId: string): ILifetime<T> => {
                  argumentNotNull(typeId, "typeId");
                  let pending = false;
                  };
              };
+             /** Creates a lifetime bound to the specified container. Using this lifetime
+              * will create a single service instance per the specified container.
+              *
+              * @param container The container which will manage the lifetime for the service
+              */
              export const containerLifetime = <T>(container: { createLifetime<X>(): ILifetime<X> }) => {
                  let _lifetime: ILifetime<T> = _unknownLifetime;
                  return {
                      has() {
                          return _lifetime.has();
                      },
-                     store(item: NonNullable<T>) {
-                         _lifetime.store(item);
+                     store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
+                         _lifetime.store(item, cleanup);
                      },
                      toString() {
                          return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;

src/main/ts/interfaces.ts +17 -2

                  activate(context: IActivationContext<S>): NonNullable<T>;
              }
-             export interface IActivationContext<S> extends ServiceLocator<S> {
+             /** The context used to initialize lifetime instance {@linkcode ILifetime} */
+             export interface ILifetimeContext {
                  createLifetime<T>(): ILifetime<T>;
                  createContainerLifetime<T>(): ILifetime<T>;
+             }
+             export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
                  register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
              }
                  get(): NonNullable<T>;
-                 initialize(context: IActivationContext<unknown>): void;
+                 initialize(context: ILifetimeContext): void;
                  store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
                  toString(): string;
              }
+             export interface ILifetimeSlot<T> {
+                 has: () => boolean;
+                 get: () => T;
+                 initialize: () => void;
+                 store(item: T, cleanup?: (item: T) => void): void;
+             }
              export interface ILifetimeManager extends IDestroyable {
                  create<T>(): ILifetime<T>;
              }

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