implab/implabjs-core Commit - r129:c13384c6c1ac

working on lifetime management

cin -

r129:c13384c6c1ac ioc ts support

parent child

Context file:

r129:c13384c6c1ac

Collapse all files

src/main/ts/di/LifetimeManager.ts created 644 +70 0

			@@ -0,0 +1,70
		1	import { IDestroyable, MapOf } from "../interfaces";
		2	import { argumentNotNull, isDestroyable } from "../safe";
		3	import { ILifetimeManager } from "./interfaces";
		4
		5	function safeCall(item: () => void) {
		6	try {
		7	item();
		8	} catch {
		9	// silence
		10	}
		11	}
		12
		13	export class LifetimeManager implements IDestroyable, ILifetimeManager {
		14	private _cleanup: (() => void)[] = [];
		15	private _cache: MapOf<any> = {};
		16	private _destroyed = false;
		17
		18	has(id: string) {
		19	return id in this._cache;
		20	}
		21
		22	get(id: string) {
		23	const t = this._cache[id];
		24	if (t === undefined)
		25	throw new Error(`The item with with the key ${id} isn't found`);
		26	return t;
		27	}
		28
		29	register(id: string, item: any, cleanup?: (item: any) => void) {
		30	argumentNotNull(id, "id");
		31	argumentNotNull(item, "item");
		32	if (this.has(id))
		33	throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
		34	this._cache[id] = item;
		35
		36	if (this._destroyed)
		37	throw new Error("Lifetime manager is destroyed");
		38	if (cleanup) {
		39	this._cleanup.push(() => cleanup(item));
		40	} else if (isDestroyable(item)) {
		41	this._cleanup.push(() => item.destroy());
		42	}
		43	}
		44
		45	destroy() {
		46	if (!this._destroyed) {
		47	this._destroyed = true;
		48	this._cleanup.forEach(safeCall);
		49	this._cleanup.length = 0;
		50	}
		51	}
		52
		53	static readonly empty: ILifetimeManager = {
		54	has() {
		55	return false;
		56	},
		57
		58	get() {
		59	throw new Error("The specified item isn't registered with this lifetime manager");
		60	},
		61
		62	register() {
		63	// does nothing
		64	},
		65
		66	destroy() {
		67	throw new Error("Trying to destroy empty lifetime manager, this is a bug.");
		68	}
		69	};
		70	}

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

                  toString() {
                      return "@walk";
                  }
+                 clone() {
+                     return this;
              }
+             }

src/main/ts/di/Container.ts +5 -2

              import { TraceSource } from "../log/TraceSource";
              import { Configuration, RegistrationMap } from "./Configuration";
              import { Cancellation } from "../Cancellation";
-             import { MapOf } from "../interfaces";
+             import { MapOf, IDestroyable } from "../interfaces";
              import { isDescriptor } from "./traits";
              const trace = TraceSource.get("@implab/core/di/ActivationContext");
-             export class Container<S extends object = any> implements Resolver<S> {
+             export class Container<S extends object = any> implements Resolver<S>, IDestroyable {
                  readonly _services: ContainerServiceMap<S>;
                  readonly _cache: MapOf<any>;
                      this._cleanup.push(callback);
                  }
+                 destroy() {
+                     return this.dispose();
+                 }
                  dispose() {
                      if (this._disposed)
                          return;

src/main/ts/di/FactoryServiceDescriptor.ts 0 -3

                      // bind to null
                      this._factory = (...args) => opts.factory.apply(null, args as any);
-                     if (opts.activation === "singleton") {
-                         this._cacheId = oid(opts.factory);
-                     }
                  }
+             }

src/main/ts/di/ServiceDescriptor.ts +29 -113

              import { ActivationContext } from "./ActivationContext";
-             import { Descriptor, ServiceMap, PartialServiceMap, ActivationType } from "./interfaces";
-             import { Container } from "./Container";
+             import { Descriptor, ServiceMap, PartialServiceMap, ActivationType, ILifetimeManager } from "./interfaces";
              import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
              import { TraceSource } from "../log/TraceSource";
              import { isDescriptor } from "./traits";
+             import { LifetimeManager } from "./LifetimeManager";
+             import { MatchingMemberKeys } from "../interfaces";
              let cacheId = 0;
                      return m.call(target, _parse(args, context, "." + method));
              }
-             function makeClenupCallback<T>(target: T, method: Cleaner<T>): () => void;
-             function makeClenupCallback(target: any, method: any) {
-                 if (typeof (method) === "string") {
-                     return () => {
-                         target[method]();
+             function makeClenupCallback<T>(method: Cleaner<T>) {
+                 if (typeof (method) === "function") {
+                     return (target: T) => {
+                         method(target);
                      };
                  } else {
-                     return () => {
-                         method(target);
+                     return (target: T) => {
+                         (target[method] as any)();
                      };
                  }
              }
                  return t;
              }
-             export type Cleaner<T> = ((x: T) => void) | keyof Extract<T, { [M in keyof T]: () => void }>;
+             export type Cleaner<T> = ((x: T) => void) | MatchingMemberKeys<() => void, T>;
              export type InjectionSpec<T> = {
                  [m in keyof T]?: any;
              };
              export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-                 activation?: ActivationType;
-                 owner: Container<S>;
+                 lifetime: ILifetimeManager;
                  params?: P;
              }
              export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
-                 _instance: T | undefined;
-                 _hasInstance = false;
-                 _activationType: ActivationType = "call";
                  _services: ServiceMap<S>;
                  _params: P | undefined;
                  _inject: InjectionSpec<T>[];
-                 _cleanup: Cleaner<T> | undefined;
+                 _cleanup: ((item: T) => void) | undefined;
-                 _cacheId: any;
+                 _cacheId = String(++cacheId);
-                 _owner: Container<S>;
+                 _lifetime = LifetimeManager.empty;
                  constructor(opts: ServiceDescriptorParams<S, T, P>) {
                      argumentNotNull(opts, "opts");
-                     argumentNotNull(opts.owner, "owner");
-                     this._owner = opts.owner;
-                     if (!isNull(opts.activation))
-                         this._activationType = opts.activation;
+                     if (opts.lifetime)
+                         this._lifetime = opts.lifetime;
                      if (!isNull(opts.params))
                          this._params = opts.params;
                              throw new Error(
                                  "The cleanup parameter must be either a function or a function name");
-                         this._cleanup = opts.cleanup;
+                         this._cleanup = makeClenupCallback(opts.cleanup);
                      }
                  }
                  activate(context: ActivationContext<S>) {
-                     // if we have a local service records, register them first
-                     let instance: T;
-                     // ensure we have a cache id
-                     if (!this._cacheId)
-                         this._cacheId = ++cacheId;
-                     switch (this._activationType) {
-                         case "singleton": // SINGLETON
-                             // if the value is cached return it
-                             if (this._hasInstance)
-                                 return this._instance;
-                             // singletons are bound to the root container
-                             const container = context.container.getRootContainer();
-                             if (container.has(this._cacheId)) {
-                                 instance = container.get(this._cacheId);
-                             } else {
-                                 instance = this._create(context);
-                                 container.store(this._cacheId, instance);
-                                 if (this._cleanup)
-                                     container.onDispose(
-                                         makeClenupCallback(instance, this._cleanup));
+                             }
-                             this._hasInstance = true;
-                             return (this._instance = instance);
-                         case "container": // CONTAINER
-                             // return a cached value
-                             if (this._hasInstance)
-                                 return this._instance;
-                             // create an instance
-                             instance = this._create(context);
+                     const lifetime = this._lifetime.initialize(this._cacheId, context);
-                             // the instance is bound to the container
-                             if (this._cleanup)
-                                 this._owner.onDispose(
-                                     makeClenupCallback(instance, this._cleanup));
-                             // cache and return the instance
-                             this._hasInstance = true;
-                             return (this._instance = instance);
-                         case "context": // CONTEXT
-                             // return a cached value if one exists
-                             if (context.has(this._cacheId))
-                                 return context.get(this._cacheId);
-                             // context context activated instances are controlled by callers
-                             return context.store(this._cacheId, this._create(context));
-                         case "call": // CALL
-                             // per-call created instances are controlled by callers
-                             return this._create(context);
-                         case "hierarchy": // HIERARCHY
-                             // hierarchy activated instances are behave much like container activated
-                             // except they are created and bound to the child container
-                             // return a cached value
-                             if (context.container.has(this._cacheId))
-                                 return context.container.get(this._cacheId);
-                             instance = this._create(context);
-                             if (this._cleanup)
-                                 context.container.onDispose(makeClenupCallback(
-                                     instance,
-                                     this._cleanup));
-                             return context.container.store(this._cacheId, instance);
-                         default:
-                             throw new Error("Invalid activation type: " + this._activationType);
+                     if (lifetime.has()) {
+                         return lifetime.get();
+                     } else {
+                         const instance = this._create(context);
+                         lifetime.store(this._cacheId, this._cleanup);
+                         return instance;
                      }
                  }
-                 isInstanceCreated() {
-                     return this._hasInstance;
+                 }
-                 getInstance() {
-                     return this._instance;
+                 }
                  _factory(...params: any[]): T {
                      throw Error("Not implemented");
                  }
                  _create(context: ActivationContext<S>) {
                      trace.debug(`constructing ${context._name}`);
-                     if (this._activationType !== "call" &&
-                         context.visit(this._cacheId) > 0)
-                         throw new Error("Recursion detected");
                      if (this._services) {
                          keys(this._services).forEach(p => context.register(p, this._services[p]));
                      }
                      }
                      return instance;
                  }
+                 clone() {
+                     return Object.create(this);
              }
+             }

src/main/ts/di/fluent/interfaces.ts 0 -2

                  visitFactoryRegistration(): void;
-                 visitBuilder<T>(builder: (t: ServiceRecordBuilder<T, S>) => void): void;
              }
              export interface RegistrationBuilder<T, S extends object> {

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

              import { ActivationContext } from "./ActivationContext";
+             import { IDestroyable } from "../interfaces";
              export interface Descriptor<S extends object = any, T = any> {
                  activate(context: ActivationContext<S>): T;
+                 clone(): this;
              }
              export type ServiceMap<S extends object> = {
                  Exclude<S, ContainerProvided<S>>;
              export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
+             export interface ILifetimeManager extends IDestroyable {
+                 initialize(id: string, context: ActivationContext<any>): ILifetime;
+             }
+             export interface ILifetime {
+                 has(): boolean;
+                 get(): any;
+                 store(item: any, cleanup?: (item: any) => void): void;
+             }
  No newline at end of file

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

              export type Predicate<T = any> = (x: T) => boolean;
+             export type MatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? K : never}[keyof From];
+             export type NotMatchingMemberKeys<T, From> = { [K in keyof From]: From[K] extends T ? never : K}[keyof From];
+             export type ExtractMembers<T, From> = Pick<From, MatchingMemberKeys<T, From>>;
+             export type ExcludeMembers<T, From> = Pick<From, NotMatchingMemberKeys<T, From>>;
              export interface MapOf<T> {
                  [key: string]: T;
              }

src/main/ts/safe.ts +7 -1

-             import { ICancellable, Constructor } from "./interfaces";
+             import { ICancellable, Constructor, IDestroyable } from "./interfaces";
              import { Cancellation } from "./Cancellation";
              let _nextOid = 0;
                  }
              }
+             export function isDestroyable(d: any): d is IDestroyable {
+                 if (d && "destroy" in d && typeof(destroy) === "function")
+                     return true;
+                 return false;
+             }
              export function destroy(d: any) {
                  if (d && "destroy" in d)
                      d.destroy();

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