540 lines
15 KiB
TypeScript
540 lines
15 KiB
TypeScript
export interface ICommand
|
||
extends INotifier {
|
||
execute(notification: INotification): void;
|
||
}
|
||
|
||
export interface IController {
|
||
executeCommand(notification: INotification): void;
|
||
registerCommand(notificationName: string, commandClassRef: Function): void;
|
||
hasCommand(notificationName: string): boolean;
|
||
removeCommand(notificationName: string): void;
|
||
}
|
||
|
||
export interface IFacade
|
||
extends INotifier {
|
||
registerCommand(notificationName: string, commandClassRef: Function): void;
|
||
removeCommand(notificationName: string): void;
|
||
hasCommand(notificationName: string): boolean;
|
||
registerProxy(proxy: IProxy): void;
|
||
retrieveProxy(proxyName: string): IProxy;
|
||
removeProxy(proxyName: string): IProxy;
|
||
hasProxy(proxyName: string): boolean;
|
||
registerMediator(mediator: IMediator): void;
|
||
retrieveMediator(mediatorName: string): IMediator;
|
||
removeMediator(mediatorName: string): IMediator;
|
||
hasMediator(mediatorName: string): boolean;
|
||
notifyObservers(notification: INotification): void;
|
||
}
|
||
|
||
export interface IMediator
|
||
extends INotifier {
|
||
getMediatorName(): string;
|
||
getViewComponent(): any;
|
||
setViewComponent(viewComponent: any): void;
|
||
listNotificationInterests(): string[];
|
||
handleNotification(notification: INotification): void;
|
||
onRegister(): void;
|
||
onRemove(): void;
|
||
}
|
||
|
||
export interface IModel {
|
||
registerProxy(proxy: IProxy): void;
|
||
removeProxy(proxyName: string): IProxy;
|
||
retrieveProxy(proxyName: string): IProxy;
|
||
hasProxy(proxyName: string): boolean;
|
||
}
|
||
|
||
export interface INotification {
|
||
getName(): string;
|
||
setBody(body: any): void;
|
||
getBody(): any;
|
||
setType(type: string): void;
|
||
getType(): string;
|
||
toString(): string;
|
||
}
|
||
|
||
export interface INotifier {
|
||
sendNotification(name: string, body?: any, type?: string): void;
|
||
}
|
||
|
||
export interface IObserver {
|
||
setNotifyMethod(notifyMethod: Function): void;
|
||
setNotifyContext(notifyContext: any): void;
|
||
notifyObserver(notification: INotification): void;
|
||
compareNotifyContext(object: any): boolean;
|
||
}
|
||
|
||
export interface IProxy
|
||
extends INotifier {
|
||
getProxyName(): string;
|
||
setData(data: any): void;
|
||
getData(): any;
|
||
onRegister(): void;
|
||
onRemove(): void;
|
||
}
|
||
|
||
export interface IView {
|
||
registerObserver(notificationName: string, observer: IObserver): void;
|
||
removeObserver(notificationName: string, notifyContext: any): void;
|
||
notifyObservers(notification: INotification): void;
|
||
registerMediator(mediator: IMediator): void;
|
||
retrieveMediator(mediatorName: string): IMediator;
|
||
removeMediator(mediatorName: string): IMediator;
|
||
hasMediator(mediatorName: string): boolean;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
export class Observer
|
||
implements IObserver {
|
||
public notify: Function;
|
||
public context: any;
|
||
constructor(notifyMethod: Function, notifyContext: any) {
|
||
this.notify = null;
|
||
this.context = null;
|
||
this.setNotifyMethod(notifyMethod);
|
||
this.setNotifyContext(notifyContext);
|
||
};
|
||
private getNotifyMethod(): Function {
|
||
return this.notify;
|
||
};
|
||
public setNotifyMethod(notifyMethod: Function): void {
|
||
this.notify = notifyMethod;
|
||
};
|
||
private getNotifyContext(): any {
|
||
return this.context;
|
||
};
|
||
public setNotifyContext(notifyContext: any): void {
|
||
this.context = notifyContext;
|
||
};
|
||
public notifyObserver(notification: INotification): void {
|
||
// console.log("[mvcFrame:notifyObserver] notifyMethod!=null:"+!!this.getNotifyMethod());
|
||
this.getNotifyMethod().call(this.getNotifyContext(), notification);
|
||
};
|
||
public compareNotifyContext(object: any): boolean {
|
||
return object === this.context;
|
||
};
|
||
}
|
||
|
||
export class View
|
||
implements IView {
|
||
public mediatorMap: Object;
|
||
public observerMap: Object;
|
||
constructor() {
|
||
this.mediatorMap = null;
|
||
this.observerMap = null;
|
||
if (View.instance) {
|
||
throw Error(View.SINGLETON_MSG);
|
||
}
|
||
View.instance = this;
|
||
this.mediatorMap = {
|
||
};
|
||
this.observerMap = {
|
||
};
|
||
this.initializeView();
|
||
};
|
||
public initializeView(): void { };
|
||
public registerObserver(notificationName: string, observer: IObserver): void {
|
||
var observers = this.observerMap[notificationName];
|
||
if (observers) {
|
||
observers.push(observer);
|
||
} else {
|
||
this.observerMap[notificationName] = [
|
||
observer
|
||
];
|
||
}
|
||
};
|
||
public removeObserver(notificationName: string, notifyContext: any): void {
|
||
var observers = this.observerMap[notificationName];
|
||
var i = observers.length;
|
||
while (i--) {
|
||
var observer = observers[i];
|
||
if (observer.compareNotifyContext(notifyContext)) {
|
||
observers.splice(i, 1);
|
||
break;
|
||
}
|
||
}
|
||
if (observers.length == 0) {
|
||
delete this.observerMap[notificationName];
|
||
}
|
||
};
|
||
public notifyObservers(notification: INotification): void {
|
||
var notificationName = notification.getName();
|
||
// console.log("[mvcFrame:notifyObservers] notificationName:"+notificationName);
|
||
// console.log("[mvcFrame:notifyObservers] curObserversArr:"+Object.keys(this.observerMap));
|
||
var observersRef = this.observerMap[notificationName];
|
||
if (observersRef) {
|
||
var observers = observersRef.slice(0);
|
||
// console.log("[mvcFrame:notifyObservers] observers.length:"+observers.length);
|
||
var len = observers.length;
|
||
for (var i = 0; i < len; i++) {
|
||
var observer = observers[i];
|
||
observer.notifyObserver(notification);
|
||
}
|
||
}
|
||
};
|
||
public registerMediator(mediator: IMediator): void {
|
||
var name = mediator.getMediatorName();
|
||
if (this.mediatorMap[name]) {
|
||
return;
|
||
}
|
||
this.mediatorMap[name] = mediator;
|
||
var interests = mediator.listNotificationInterests();
|
||
var len = interests.length;
|
||
if (len > 0) {
|
||
var observer = new Observer(mediator.handleNotification, mediator);
|
||
for (var i = 0; i < len; i++) {
|
||
this.registerObserver(interests[i], observer);
|
||
}
|
||
}
|
||
mediator.onRegister();
|
||
};
|
||
public retrieveMediator(mediatorName: string): IMediator {
|
||
return this.mediatorMap[mediatorName] || null;
|
||
};
|
||
public removeMediator(mediatorName: string): IMediator {
|
||
var mediator = this.mediatorMap[mediatorName];
|
||
if (!mediator) {
|
||
return null;
|
||
}
|
||
var interests = mediator.listNotificationInterests();
|
||
var i = interests.length;
|
||
while (i--) {
|
||
this.removeObserver(interests[i], mediator);
|
||
}
|
||
delete this.mediatorMap[mediatorName];
|
||
mediator.onRemove();
|
||
return mediator;
|
||
};
|
||
public hasMediator(mediatorName: string): boolean {
|
||
return this.mediatorMap[mediatorName] != null;
|
||
};
|
||
static SINGLETON_MSG: string;
|
||
static instance: IView;
|
||
static getInstance(): IView {
|
||
if (!View.instance) {
|
||
View.instance = new View();
|
||
}
|
||
return View.instance;
|
||
};
|
||
}
|
||
|
||
|
||
export class Controller
|
||
implements IController {
|
||
public view: IView;
|
||
public commandMap: Object;
|
||
constructor() {
|
||
this.view = null;
|
||
this.commandMap = null;
|
||
if (Controller.instance) {
|
||
throw Error(Controller.SINGLETON_MSG);
|
||
}
|
||
Controller.instance = this;
|
||
this.commandMap = {
|
||
};
|
||
this.initializeController();
|
||
};
|
||
public initializeController(): void {
|
||
this.view = View.getInstance();
|
||
};
|
||
public executeCommand(notification: INotification): void {
|
||
var commandClassRef = this.commandMap[notification.getName()];
|
||
if (commandClassRef) {
|
||
var command = new commandClassRef();
|
||
command.execute(notification);
|
||
}
|
||
};
|
||
public registerCommand(notificationName: string, commandClassRef: Function): void {
|
||
if (!this.commandMap[notificationName]) {
|
||
this.view.registerObserver(notificationName, new Observer(this.executeCommand, this));
|
||
}
|
||
this.commandMap[notificationName] = commandClassRef;
|
||
};
|
||
public hasCommand(notificationName: string): boolean {
|
||
return this.commandMap[notificationName] != null;
|
||
};
|
||
public removeCommand(notificationName: string): void {
|
||
if (this.hasCommand(notificationName)) {
|
||
this.view.removeObserver(notificationName, this);
|
||
delete this.commandMap[notificationName];
|
||
}
|
||
};
|
||
static instance: IController = null;
|
||
static SINGLETON_MSG: string = "Controller singleton already constructed!";
|
||
static getInstance(): IController {
|
||
if (!Controller.instance) {
|
||
Controller.instance = new Controller();
|
||
}
|
||
return Controller.instance;
|
||
};
|
||
}
|
||
|
||
export class Model
|
||
implements IModel {
|
||
public proxyMap: Object;
|
||
constructor() {
|
||
this.proxyMap = null;
|
||
if (Model.instance) {
|
||
throw Error(Model.SINGLETON_MSG);
|
||
}
|
||
Model.instance = this;
|
||
this.proxyMap = {
|
||
};
|
||
this.initializeModel();
|
||
};
|
||
public initializeModel(): void { };
|
||
public registerProxy(proxy: IProxy): void {
|
||
this.proxyMap[proxy.getProxyName()] = proxy;
|
||
proxy.onRegister();
|
||
};
|
||
public removeProxy(proxyName: string): IProxy {
|
||
var proxy = this.proxyMap[proxyName];
|
||
if (proxy) {
|
||
delete this.proxyMap[proxyName];
|
||
proxy.onRemove();
|
||
}
|
||
return proxy;
|
||
};
|
||
public retrieveProxy(proxyName: string): IProxy {
|
||
return this.proxyMap[proxyName] || null;
|
||
};
|
||
public hasProxy(proxyName: string): boolean {
|
||
return this.proxyMap[proxyName] != null;
|
||
};
|
||
static SINGLETON_MSG: string = "Model singleton already constructed!";
|
||
static instance: IModel = null;
|
||
static getInstance(): IModel {
|
||
if (!Model.instance) {
|
||
Model.instance = new Model();
|
||
}
|
||
return Model.instance;
|
||
};
|
||
}
|
||
|
||
export class CoreNotification
|
||
implements INotification {
|
||
public name: string;
|
||
public body: any;
|
||
public type: string;
|
||
constructor(name: string, body?: any, type?: string) {
|
||
if (typeof body === "undefined") { body = null; }
|
||
if (typeof type === "undefined") { type = null; }
|
||
this.name = null;
|
||
this.body = null;
|
||
this.type = null;
|
||
this.name = name;
|
||
this.body = body;
|
||
this.type = type;
|
||
};
|
||
public getName(): string {
|
||
return this.name;
|
||
};
|
||
public setBody(body: any): void {
|
||
this.body = body;
|
||
};
|
||
public getBody(): any {
|
||
return this.body;
|
||
};
|
||
public setType(type: string): void {
|
||
this.type = type;
|
||
};
|
||
public getType(): string {
|
||
return this.type;
|
||
};
|
||
public toString(): string {
|
||
var msg = "Notification Name: " + this.getName();
|
||
msg += "\nBody:" + ((this.getBody() == null) ? "null" : this.getBody().toString());
|
||
msg += "\nType:" + ((this.getType() == null) ? "null" : this.getType());
|
||
return msg;
|
||
};
|
||
}
|
||
|
||
export class Facade
|
||
implements IFacade {
|
||
public model: IModel;
|
||
public view: IView;
|
||
public controller: IController;
|
||
constructor() {
|
||
this.model = null;
|
||
this.view = null;
|
||
this.controller = null;
|
||
if (Facade.instance) {
|
||
throw Error(Facade.SINGLETON_MSG);
|
||
}
|
||
Facade.instance = this;
|
||
this.initializeFacade();
|
||
};
|
||
public initializeFacade(): void {
|
||
this.initializeModel();
|
||
this.initializeController();
|
||
this.initializeView();
|
||
};
|
||
public initializeModel(): void {
|
||
if (!this.model) {
|
||
this.model = Model.getInstance();
|
||
}
|
||
};
|
||
public initializeController(): void {
|
||
if (!this.controller) {
|
||
this.controller = Controller.getInstance();
|
||
}
|
||
};
|
||
public initializeView(): void {
|
||
if (!this.view) {
|
||
this.view = View.getInstance();
|
||
}
|
||
};
|
||
public registerCommand(notificationName: string, commandClassRef: Function): void {
|
||
this.controller.registerCommand(notificationName, commandClassRef);
|
||
};
|
||
public removeCommand(notificationName: string): void {
|
||
this.controller.removeCommand(notificationName);
|
||
};
|
||
public hasCommand(notificationName: string): boolean {
|
||
return this.controller.hasCommand(notificationName);
|
||
};
|
||
public registerProxy(proxy: IProxy): void {
|
||
this.model.registerProxy(proxy);
|
||
};
|
||
public retrieveProxy(proxyName: string): IProxy {
|
||
return this.model.retrieveProxy(proxyName);
|
||
};
|
||
public removeProxy(proxyName: string): IProxy {
|
||
var proxy;
|
||
if (this.model) {
|
||
proxy = this.model.removeProxy(proxyName);
|
||
}
|
||
return proxy;
|
||
};
|
||
public hasProxy(proxyName: string): boolean {
|
||
return this.model.hasProxy(proxyName);
|
||
};
|
||
public registerMediator(mediator: IMediator): void {
|
||
if (this.view) {
|
||
this.view.registerMediator(mediator);
|
||
}
|
||
};
|
||
public retrieveMediator(mediatorName: string): IMediator {
|
||
return this.view.retrieveMediator(mediatorName);
|
||
};
|
||
public removeMediator(mediatorName: string): IMediator {
|
||
var mediator;
|
||
if (this.view) {
|
||
mediator = this.view.removeMediator(mediatorName);
|
||
}
|
||
return mediator;
|
||
};
|
||
public hasMediator(mediatorName: string): boolean {
|
||
return this.view.hasMediator(mediatorName);
|
||
};
|
||
public notifyObservers(notification: INotification): void {
|
||
// console.log("[mvcFrame::notifyObservers this.view!=null：]"+!!this.view);
|
||
if (this.view) {
|
||
this.view.notifyObservers(notification);
|
||
}
|
||
};
|
||
public sendNotification(name: string, body?: any, type?: string): void {
|
||
if (typeof body === "undefined") { body = null; }
|
||
if (typeof type === "undefined") { type = null; }
|
||
this.notifyObservers(new CoreNotification(name, body, type));
|
||
};
|
||
static SINGLETON_MSG: string = "Facade singleton already constructed!";
|
||
static instance: IFacade = null;
|
||
static getInstance(): IFacade {
|
||
if (!Facade.instance) {
|
||
Facade.instance = new Facade();
|
||
}
|
||
return Facade.instance;
|
||
};
|
||
}
|
||
|
||
export class Notifier
|
||
implements INotifier {
|
||
public facade: IFacade;
|
||
constructor() {
|
||
this.facade = null;
|
||
this.facade = Facade.getInstance();
|
||
};
|
||
public sendNotification(name: string, body?: any, type?: string): void {
|
||
if (typeof body === "undefined") { body = null; }
|
||
if (typeof type === "undefined") { type = null; }
|
||
this.facade.sendNotification(name, body, type);
|
||
};
|
||
}
|
||
|
||
export class SimpleCommand
|
||
extends Notifier
|
||
implements ICommand, INotifier {
|
||
public execute(notification: INotification): void { };
|
||
}
|
||
|
||
export class Mediator
|
||
extends Notifier
|
||
implements IMediator, INotifier {
|
||
public mediatorName: string;
|
||
public viewComponent: any;
|
||
constructor(mediatorName?: string, viewComponent?: any) {
|
||
super();
|
||
if (typeof mediatorName === "undefined") { mediatorName = null; }
|
||
if (typeof viewComponent === "undefined") { viewComponent = null; }
|
||
// _super.call(this);
|
||
this.mediatorName = null;
|
||
this.viewComponent = null;
|
||
this.mediatorName = (mediatorName != null) ? mediatorName : Mediator.NAME;
|
||
this.viewComponent = viewComponent;
|
||
};
|
||
public getMediatorName(): string {
|
||
return this.mediatorName;
|
||
};
|
||
public getViewComponent(): any {
|
||
return this.viewComponent;
|
||
};
|
||
public setViewComponent(viewComponent: any): void {
|
||
this.viewComponent = viewComponent;
|
||
};
|
||
public listNotificationInterests(): string[] {
|
||
return new Array();
|
||
};
|
||
public handleNotification(notification: CoreNotification): void { };
|
||
public onRegister(): void { };
|
||
public onRemove(): void { };
|
||
static NAME: string = 'Mediator';
|
||
}
|
||
|
||
export class CoreProxy
|
||
extends Notifier
|
||
implements IProxy, INotifier {
|
||
public proxyName: string;
|
||
public data: any;
|
||
constructor(proxyName?: string, data?: any) {
|
||
super();
|
||
if (typeof proxyName === "undefined") { proxyName = null; }
|
||
if (typeof data === "undefined") { data = null; }
|
||
// _super.call(this);
|
||
this.proxyName = null;
|
||
this.data = null;
|
||
this.proxyName = (proxyName != null) ? proxyName : CoreProxy.NAME;
|
||
if (data != null) {
|
||
this.setData(data);
|
||
}
|
||
};
|
||
public getProxyName(): string {
|
||
return this.proxyName;
|
||
};
|
||
public setData(data: any): void {
|
||
this.data = data;
|
||
};
|
||
public getData(): any {
|
||
return this.data;
|
||
};
|
||
public onRegister(): void { };
|
||
public onRemove(): void { };
|
||
static NAME: string = "Proxy";
|
||
} |