implab/implabjs-di Commit - r12:94f233c23aa4

WIP lifetime services

cin -

r12:94f233c23aa4 default

parent child

Context file:

r12:94f233c23aa4

Collapse all files

src/main/ts/ContainerBuilder.ts +3 -4

                      if (!this._complete())
                          throw new Error("The configuration didn't complete.");
-                     const lifetime = this._lifetime;
+                     const {remove, store} = this._lifetime(null);
-                     const detach = isDestroyable(lifetime) ? () => lifetime.destroy() : () => void (0);
+                     const container = new Container(this._services, this._lifetimeManager, remove);
-                     const container = new Container(this._services, this._lifetimeManager, detach);
-                     lifetime.store(container);
+                     store(container);
                      return container;
                  }

src/main/ts/DescriptorImpl.ts +9 -5

-             import { ActivationError } from "./ActivationError";
-             import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
              import { each, key } from "./traits";
                  activate(context: IActivationContext<S>): NonNullable<T> {
-                     if (this._lifetime.has())
-                         return this._lifetime.get();
+                     const { has, get, initialize, store } = this._lifetime(context);
-                     this._lifetime.initialize(context);
+                     if (has())
+                         return get();
+                     initialize();
                      if (this._overrides)
                          each(this._overrides, (v, k) => context.register(k, v));
                          {};
                      try {
+                         // call the factory method
                          const instance = (0,this._factory)(refs);
-                         this._lifetime.store(instance, this._cleanup);
+                         // store the instance
+                         store(instance, this._cleanup);
                          return instance;
                      } catch(err) {
                          context.fail(err);

src/main/ts/LifetimeManager.ts +67 -149

-             import { IActivationContext, ILifetime, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
-             import { ActivationContext } from "./ActivationContext";
+             import { IDestroyable, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
              import { argumentNotNull, isDestroyable } from "./traits";
              const safeCall = (item: () => void) => {
              const noop = () => {};
-             const fail = (message: string) => {
+             const fail = (message: string) => (): never => {
                  throw new Error(message);
              };
                  store: noop,
-                 remove: noop
-             });
-             const _unknonwSlot = Object.freeze({
-                 has: () => false,
+                 remove: noop,
-                 initialize: () => {
-                     throw new Error("Can't call initialize on the unknown lifetime object");
-                 },
-                 get: () => {
-                     throw new Error("The lifetime object isn't initialized");
-                 },
-                 store: () => {
-                     throw new Error("Can't store a value in the unknown lifetime object");
+                 }
+                 cleanup: noop,
              });
+             const _destroy = (item: IDestroyable) => item.destroy();
-             const pendingSlot = <T>(store: (item: T) => void) => ({
+             const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
+                 cleanup ? () => cleanup(value) :
+                     isDestroyable(value) ? () => _destroy(value) :
+                         noop;
+             const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
                  has: () => false,
-                 get: () => {
-                     throw new Error("The value in this slot doesn't exist");
-                 },
+                 initialize: () => put(pendingSlot(put, remove)),
+                 get: fail("The slot doesn't hold a value"),
-                 initialize: () => {
-                     throw new Error("Cyclic reference detected");
-                 },
+                 store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
-                 store
+                 remove: noop,
+                 cleanup: noop,
              });
-             const valueSlot = <T>(value: T, cleanup: (item: T) => void) => ({
+             const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
+                 has: () => false,
+                 get: fail("The value in this slot doesn't exist"),
+                 initialize: fail("Cyclic reference detected"),
+                 store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
+                 remove,
+                 cleanup: noop
+             });
+             const valueSlot = <T>(value: T, cleanup: ((item: T) => void) | undefined, remove: () => void) => ({
                  has: () => true,
                  get: () => value,
-                 initialize: () => {
-                     throw new Error("The slot already has a value");
-                 },
+                 initialize: fail("The slot already has a value"),
+                 store: fail("The slot already has a value"),
-                 store: () => {
-                     throw new Error("The slot already has a value");
+                 }
+                 cleanup: _makeCleanup(value, cleanup),
+                 remove: remove
              });
-             const singletons: { [K: string]: unknown } = {};
              export class LifetimeManager implements ILifetimeManager {
                  private _destroyed = false;
                  private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
-                 slot<T>(cookie: string): ILifetimeSlot<T> {
+                 slot<T>(cookie: string | number): ILifetimeSlot<T> {
                      if (cookie in this._slots)
                          return this._slots[cookie] as ILifetimeSlot<T>;
-                     const store = (item: T, cleanup?: (item: T) => void) => {
+                     return newSlot<T>(this._put(cookie), this._remove(cookie));
+                 }
+                 private readonly _put = (id: string | number) => <T>(slot: ILifetimeSlot<T>) => {
-                         this._assertNotDestroyed();
-                         this._slots[cookie] = valueSlot(
-                             item,
-                             cleanup ?? isDestroyable(item) ? () => item.destroy() : noop
-                         );
+                     this._slots[id] = slot as ILifetimeSlot<unknown>;
-                     };
-                     return {
-                         has: () => false,
-                         get: () => {
-                             throw new Error("The value isn't stored in this slot");
-                         },
-                         store,
-                         initialize: () => {
+                 private readonly _remove = (id: string | number) => () => {
-                             this._assertNotDestroyed();
-                             this._slots[cookie] = pendingSlot(store);
+                         }
+                     delete this._slots[id];
-                     };
+                 }
-                 remove(cookie: string) {
-                     delete this._slots[cookie];
+                 }
                  private _assertNotDestroyed() {
                      if (this._destroyed)
                  destroy() {
                      if (!this._destroyed) {
                          this._destroyed = true;
-                         Object.values(this._slots).forEach(({clean}) => )
+                         Object.values(this._slots).forEach(({ cleanup }) => safeCall(cleanup));
                      }
                  }
              }
-             export const emptyLifetime = <T>(): ILifetime<T> => {
-                 return _emptyLifetime;
-             };
+             export const emptyLifetime = <T>() => () => _emptySlot as ILifetimeSlot<T>;
-             export const hierarchyLifetime = <T>(): ILifetime<T> => {
-                 // TODO: вот здесь ошибка, при первой активации сервиса будет получен и
-                 // привязан lifetime из дочернего контейнера, при активации через второй
-                 // дочерний контейнера это приведет к ошибке, точнее будет взят экземпляр
-                 // из первого контейнера.
-                 let _lifetime: ILifetime<T> = _unknownLifetime;
-                 return {
-                     initialize(context: ILifetimeContext) {
-                         if (_lifetime !== _unknownLifetime)
-                             throw new Error("Cyclic reference activation detected");
+             let nextId = 1;
-                         _lifetime = context.createContainerLifetime<T>();
-                     },
-                     get() {
-                         return _lifetime.get();
-                     },
-                     has() {
-                         return _lifetime.has();
-                     },
-                     store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
-                         return _lifetime.store(item, cleanup);
-                     },
-                     toString() {
-                         return `[object HierarchyLifetime, has=${String(this.has())}]`;
+                     }
-                 };
+             export const hierarchyLifetime = <T>() => {
+                 const slotId = nextId++;
+                 return (context: ILifetimeContext) =>
+                     context.containerSlot<T>(slotId);
              };
              /**
               *
               * @returns The instance of the lifetime.
               */
-             export const contextLifetime = <T>(): ILifetime<T> => {
-                 let _lifetime: ILifetime<T> = _unknownLifetime;
-                 return {
-                     initialize(context: ILifetimeContext) {
-                         if (_lifetime !== _unknownLifetime)
-                             throw new Error("Cyclic reference detected");
-                         _lifetime = context.createLifetime();
-                     },
-                     get() {
-                         return _lifetime.get();
-                     },
-                     has() {
-                         return _lifetime.has();
-                     },
-                     store(item: NonNullable<T>) {
-                         _lifetime.store(item);
-                     },
-                     toString() {
-                         return `[object ContextLifetime, has=${String(this.has())}]`;
+                     }
+             export const contextLifetime = <T>() => {
+                 const slotId = nextId++;
+                 return (context: ILifetimeContext) =>
+                     context.contextSlot<T>(slotId);
                  };
-             };
+             const singletons = new LifetimeManager();
              /**
               * Creates the lifetime for the service which will allow existence only one
               *   fully qualified class name
               * @returns The lifetime instance
               */
-             export const singletonLifetime = <T>(typeId: string): ILifetime<T> => {
+             export const singletonLifetime = <T>(typeId: string) => {
                  argumentNotNull(typeId, "typeId");
-                 let pending = false;
-                 return {
-                     has() {
-                         return typeId in singletons;
-                     },
-                     get() {
-                         if (!this.has())
-                             throw new Error(`The instance ${typeId} doesn't exists`);
-                         return singletons[typeId] as NonNullable<T>;
-                     },
-                     initialize() {
-                         if (pending)
-                             throw new Error("Cyclic reference detected");
-                         pending = true;
-                     },
-                     store(item: NonNullable<T>) {
-                         singletons[typeId] = item;
-                         pending = false;
-                     },
-                     toString() {
-                         return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
+                     }
-                 };
+                 return () => singletons.slot<T>(typeId);
              };
              /** Creates a lifetime bound to the specified container. Using this lifetime
               *
               * @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 {
-                     initialize() {
-                         if (_lifetime !== _unknownLifetime)
-                             throw new Error("Cyclic reference detected");
-                         _lifetime = container.createLifetime();
-                     },
-                     get() {
-                         return _lifetime.get();
-                     },
-                     has() {
-                         return _lifetime.has();
-                     },
-                     store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
-                         _lifetime.store(item, cleanup);
-                     },
-                     toString() {
-                         return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
+                     }
+             export const containerLifetime = <T>(manager: ILifetimeManager) => {
+                 const slotId = nextId++;
+                 return () => manager.slot<T>(slotId);
                  };
-             };

src/main/ts/interfaces.ts +12 -19

              /** The context used to initialize lifetime instance {@linkcode ILifetime} */
              export interface ILifetimeContext {
-                 contextSlot<T>(slotId: string): ILifetimeSlot<T>;
+                 contextSlot<T>(slotId: string | number): ILifetimeSlot<T>;
-                 containerSlot<T>(slotId: string): ILifetimeSlot<T>;
+                 containerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
              }
               * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
               * свой собственный объект `ILifetime`, который создается при первой активации
               */
-             export interface ILifetime<T> {
-                 /** Проверяет, что уже создан экземпляр объекта */
-                 has(): boolean;
-                 get(): NonNullable<T>;
-                 initialize(context: ILifetimeContext): void;
-                 store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
-                 toString(): string;
+             }
+             export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<NonNullable<T>>;
              export interface ILifetimeSlot<T> {
-                 has: () => boolean;
+                 readonly has: () => boolean;
-                 get: () => T;
+                 readonly get: () => T;
+                 readonly initialize: () => void;
-                 initialize: () => void;
+                 readonly store: (item: T, cleanup?: (item: T) => void) => void;
-                 store(item: T, cleanup?: (item: T) => void): void;
+                 readonly remove: () => void;
+                 readonly cleanup: () => void;
-             }
              export interface ILifetimeManager extends IDestroyable {
-                 create<T>(): ILifetime<T>;
+                 slot<T>(id: string | number): ILifetimeSlot<T>;
              }
              export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };

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