implab/implabjs-core Commit - r130:1af015b1d265

working on services lifetime

cin -

r130:1af015b1d265 ioc ts support

parent child

Context file:

r130:1af015b1d265

Collapse all files

src/main/ts/di/LifetimeManager.ts +35 -13

              import { IDestroyable, MapOf } from "../interfaces";
              import { argumentNotNull, isDestroyable } from "../safe";
-             import { ILifetimeManager } from "./interfaces";
+             import { ILifetimeManager, ILifetime } from "./interfaces";
+             import { ActivationContext } from "./ActivationContext";
              function safeCall(item: () => void) {
                  try {
                  private _cache: MapOf<any> = {};
                  private _destroyed = false;
-                 has(id: string) {
-                     return id in this._cache;
+                 }
+                 initialize(id: string, context: ActivationContext<any>): ILifetime {
+                     const self = this;
+                     let pending = false;
+                     return {
+                         has() {
+                             return (id in self._cache);
+                         },
-                 get(id: string) {
-                     const t = this._cache[id];
+                         get() {
+                             const t = self._cache[id];
                      if (t === undefined)
                          throw new Error(`The item with with the key ${id} isn't found`);
                      return t;
+                 }
+                         },
-                 register(id: string, item: any, cleanup?: (item: any) => void) {
+                         enter() {
+                             if (pending)
+                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
+                             pending = true;
+                         },
+                         store(item: any, cleanup?: (item: any) => void) {
                      argumentNotNull(id, "id");
                      argumentNotNull(item, "item");
-                     if (this.has(id))
+                             if (this.has())
                          throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                     this._cache[id] = item;
+                             pending = false;
-                     if (this._destroyed)
+                             self._cache[id] = item;
+                             if (self._destroyed)
                          throw new Error("Lifetime manager is destroyed");
                      if (cleanup) {
-                         this._cleanup.push(() => cleanup(item));
+                                 self._cleanup.push(() => cleanup(item));
                      } else if (isDestroyable(item)) {
-                         this._cleanup.push(() => item.destroy());
+                                 self._cleanup.push(() => item.destroy());
                      }
                  }
+                     };
+                 }
                  destroy() {
                      if (!this._destroyed) {

src/main/ts/di/ServiceDescriptor.ts +5 -3

                      return m.call(target, _parse(args, context, "." + method));
              }
-             function makeClenupCallback<T>(method: Cleaner<T>) {
+             function makeCleanupCallback<T>(method: Cleaner<T>) {
                  if (typeof (method) === "function") {
                      return (target: T) => {
                          method(target);
                      };
                  } else {
                      return (target: T) => {
-                         (target[method] as any)();
+                         const m = target[method] as any;
+                         m.apply(target);
                      };
                  }
              }
                              throw new Error(
                                  "The cleanup parameter must be either a function or a function name");
-                         this._cleanup = makeClenupCallback(opts.cleanup);
+                         this._cleanup = makeCleanupCallback(opts.cleanup);
                      }
                  }
                      if (lifetime.has()) {
                          return lifetime.get();
                      } else {
+                         lifetime.enter();
                          const instance = this._create(context);
                          lifetime.store(this._cacheId, this._cleanup);
                          return instance;

src/main/ts/di/interfaces.ts +4 0

              export interface ILifetime {
                  has(): boolean;
                  get(): any;
+                 enter(): void;
                  store(item: any, cleanup?: (item: any) => void): void;
              }
  No newline at end of file

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