@magic-xpa/engine 4.800.0-dev480.94 → 4.801.0-dev000.0

package/esm2020/src/event/EventHandlerPosition.mjs

@@ -0,0 +1,201 @@
+import { InternalInterface, Logger } from "@magic-xpa/utils";
+import { ConstInterface } from "../ConstInterface";
+import { AccessHelper } from "../AccessHelper";
+import { isNullOrUndefined } from "@magic-xpa/mscorelib";
+export class EventHandlerPosition {
+    constructor() {
+        this._handlerIdx = 0;
+        this._handlersTab = null;
+        this._orgPrevTask = null;
+        this._orgTask = null;
+        this._phase = 0;
+        this._prevTask = null;
+        this._rtEvt = null;
+        this._task = null;
+    }
+    init(rtEvent) {
+        this._rtEvt = rtEvent;
+        this._task = this._rtEvt.getTask();
+        if (this._task.isMainProg()) {
+            this._prevTask = this._rtEvt.getMainPrgCreator();
+            if (this._prevTask !== null && this._prevTask.isMainProg())
+                this._prevTask = null;
+        }
+        if (rtEvent.getType() === ConstInterface.EVENT_TYPE_USER_FUNC)
+            this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;
+        else {
+            if (rtEvent.getType() === ConstInterface.EVENT_TYPE_USER_FUNC)
+                this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;
+            else
+                this._phase = EventHandlerPosition.PHASE_CONTROL_SPECIFIC;
+        }
+        this._orgTask = this._task;
+        this._orgPrevTask = this._prevTask;
+        this._handlersTab = this._task.getHandlersTab();
+        if (this._handlersTab === null) {
+            this.goUpTaskChain();
+        }
+        this._handlerIdx = -1;
+    }
+    getNext(evt) {
+        if (!isNullOrUndefined(evt))
+            return this.getNext_0(evt);
+        else
+            return this.getNext_1();
+    }
+    getNext_0(evt) {
+        this._rtEvt = evt;
+        return this.getNext();
+    }
+    getNext_1() {
+        if (this._handlersTab === null)
+            return null;
+        let result;
+        if (this._rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && this._rtEvt.getInternalCode() !== InternalInterface.MG_ACT_VARIABLE) {
+            switch (this._rtEvt.getInternalCode()) {
+                case InternalInterface.MG_ACT_TASK_PREFIX:
+                case InternalInterface.MG_ACT_TASK_SUFFIX:
+                case InternalInterface.MG_ACT_REC_PREFIX:
+                case InternalInterface.MG_ACT_REC_SUFFIX:
+                case InternalInterface.MG_ACT_CTRL_PREFIX:
+                case InternalInterface.MG_ACT_CTRL_SUFFIX: {
+                    if (this._handlerIdx === -1) {
+                        for (this._handlerIdx = this._handlersTab.getSize() - 1; this._handlerIdx >= 0; this._handlerIdx--) {
+                            let handler = this._handlersTab.getHandler(this._handlerIdx);
+                            if ((handler.isNonSpecificHandlerOf(this._rtEvt)) || (handler.isSpecificHandlerOf(this._rtEvt))) {
+                                return handler;
+                            }
+                        }
+                    }
+                    return null;
+                }
+                default:
+                    break;
+            }
+        }
+        while (this.setNextHandlerIdx()) {
+            let handler = this._handlersTab.getHandler(this._handlerIdx);
+            switch (this._phase) {
+                case EventHandlerPosition.PHASE_CONTROL_SPECIFIC:
+                    if (handler.isSpecificHandlerOf(this._rtEvt))
+                        return handler;
+                    continue;
+                case EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC:
+                    if (handler.isNonSpecificHandlerOf(this._rtEvt))
+                        return handler;
+                    continue;
+                case EventHandlerPosition.PHASE_GLOBAL_SPECIFIC:
+                    if (handler.isGlobalSpecificHandlerOf(this._rtEvt))
+                        return handler;
+                    continue;
+                case EventHandlerPosition.PHASE_GLOBAL:
+                    if (handler.isGlobalHandlerOf(this._rtEvt))
+                        return handler;
+                    continue;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("in EventHandlerPosition.getNext() invalid phase: " + this._phase);
+                    break;
+            }
+        }
+        return null;
+    }
+    setNextHandlerIdx() {
+        if (this._handlerIdx < 0)
+            this._handlerIdx = this._handlersTab.getSize() - 1;
+        else
+            this._handlerIdx = this._handlerIdx - 1;
+        if (this._handlerIdx < 0 || this._task.isAborting()) {
+            if (this.goUpTaskChain())
+                return this.setNextHandlerIdx();
+            else
+                return false;
+        }
+        return true;
+    }
+    goUpTaskChain() {
+        let mGData = this._task.getMGData();
+        let ctlIdx = this._task.getCtlIdx();
+        switch (this._phase) {
+            case EventHandlerPosition.PHASE_CONTROL_SPECIFIC:
+            case EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC: {
+                if (!this._task.isMainProg()) {
+                    this.getParentOrCompMainPrg();
+                    break;
+                }
+                else {
+                    if ((this._rtEvt.getType() === ConstInterface.EVENT_TYPE_PUBLIC ||
+                        this._rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL ||
+                        this._rtEvt.getType() === ConstInterface.EVENT_TYPE_SYSTEM ||
+                        this._rtEvt.getType() === ConstInterface.EVENT_TYPE_USER) && ctlIdx > 0) {
+                        if (this._prevTask === null) {
+                            this._task = mGData.getNextMainProg(ctlIdx);
+                            if (this._task === null && ctlIdx > 0)
+                                this._task = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, AccessHelper.eventsManager.getCompMainPrgTab().getCtlIdx(0));
+                        }
+                        else {
+                            this._task = this._prevTask.PathParentTask;
+                            this._prevTask = null;
+                        }
+                        this._rtEvt.setMainPrgCreator(null);
+                        break;
+                    }
+                    if (this._phase === EventHandlerPosition.PHASE_CONTROL_SPECIFIC) {
+                        this._phase = EventHandlerPosition.PHASE_GLOBAL_SPECIFIC;
+                    }
+                    else {
+                        this._phase = EventHandlerPosition.PHASE_GLOBAL;
+                    }
+                    this._task = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, AccessHelper.eventsManager.getCompMainPrgTab().getCtlIdx(0));
+                    this._rtEvt.setMainPrgCreator(this._task);
+                    if (this._task === null)
+                        return false;
+                    break;
+                }
+            }
+            case EventHandlerPosition.PHASE_GLOBAL_SPECIFIC:
+            case EventHandlerPosition.PHASE_GLOBAL: {
+                this._task = mGData.getNextMainProg(ctlIdx);
+                if (this._task === null) {
+                    if (this._phase === EventHandlerPosition.PHASE_GLOBAL)
+                        return false;
+                    this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;
+                    this._task = this._orgTask;
+                    this._prevTask = this._orgPrevTask;
+                }
+                break;
+            }
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("in EventHandlerPosition.goUpTaskChain() invalid phase: " + this._phase);
+                break;
+        }
+        if (this._task === null)
+            return false;
+        this._handlersTab = this._task.getHandlersTab();
+        if (this._handlersTab === null)
+            return this.goUpTaskChain();
+        this._handlerIdx = -1;
+        return true;
+    }
+    getParentOrCompMainPrg() {
+        let ctlIdx = this._task.getCtlIdx();
+        this._prevTask = this._task;
+        let pathParentTask = this._task.PathParentTask;
+        if (pathParentTask === null) {
+            this._task = null;
+            return;
+        }
+        if (ctlIdx !== pathParentTask.getCtlIdx()) {
+            this._rtEvt.setMainPrgCreator(this._task);
+            this._task = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);
+        }
+        else {
+            this._rtEvt.setMainPrgCreator(null);
+            this._task = pathParentTask;
+        }
+    }
+}
+EventHandlerPosition.PHASE_CONTROL_SPECIFIC = 1;
+EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC = 2;
+EventHandlerPosition.PHASE_GLOBAL = 3;
+EventHandlerPosition.PHASE_GLOBAL_SPECIFIC = 4;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventHandlerPosition.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/event/EventHandlerPosition.ts"],"names":[],"mappings":"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","sourcesContent":["import {InternalInterface, Logger} from \"@magic-xpa/utils\";\r\nimport {HandlersTable} from \"../rt/HandlersTable\";\r\nimport {RunTimeEvent} from \"./RunTimeEvent\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {EventHandler} from \"./EventHandler\";\r\nimport {MGData} from \"../tasks/MGData\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\nimport {isNullOrUndefined} from \"@magic-xpa/mscorelib\";\r\n\r\n/// <summary>\r\n///   an object of this class points to the position of an event handler in the\r\n///   chain of the event handlers\r\n/// </summary>\r\nexport class EventHandlerPosition {\r\n  private static PHASE_CONTROL_SPECIFIC: number = 1;\r\n  private static PHASE_CONTROL_NON_SPECIFIC: number = 2;\r\n  private static PHASE_GLOBAL: number = 3;\r\n  private static PHASE_GLOBAL_SPECIFIC: number = 4;\r\n\r\n  private _handlerIdx: number = 0; // the index of the handler within the task\r\n  private _handlersTab: HandlersTable = null;\r\n  private _orgPrevTask: Task = null; // reference to the previous checked task\r\n  private _orgTask: Task = null; // reference to the current checked task\r\n  private _phase: number = 0; // the phase of the search: control specific, control non-specific, global\r\n  private _prevTask: Task = null; // reference to the previous checked task\r\n  private _rtEvt: RunTimeEvent = null; // the event\r\n  private _task: Task = null; // reference to the current checked task\r\n\r\n\r\n  constructor() {\r\n  }\r\n  ///   init the position to start a new chain of search\r\n  init(rtEvent: RunTimeEvent): void {\r\n    this._rtEvt = rtEvent;\r\n    this._task = <Task>this._rtEvt.getTask();\r\n    if (this._task.isMainProg()) {\r\n      this._prevTask = <Task>this._rtEvt.getMainPrgCreator();\r\n      if (this._prevTask !== null && this._prevTask.isMainProg())\r\n        this._prevTask = null;\r\n    }\r\n\r\n    if (rtEvent.getType() === ConstInterface.EVENT_TYPE_USER_FUNC)\r\n      this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;\r\n    else {\r\n      if (rtEvent.getType() === ConstInterface.EVENT_TYPE_USER_FUNC)\r\n        this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;\r\n      else\r\n        this._phase = EventHandlerPosition.PHASE_CONTROL_SPECIFIC;\r\n    }\r\n\r\n    this._orgTask = this._task;\r\n    this._orgPrevTask = this._prevTask;\r\n    this._handlersTab = this._task.getHandlersTab();\r\n    if (this._handlersTab === null) {\r\n      this.goUpTaskChain();\r\n    }\r\n\r\n    this._handlerIdx = -1;\r\n  }\r\n\r\n  getNext(evt: RunTimeEvent): EventHandler;\r\n  getNext(): EventHandler;\r\n  getNext(evt?: RunTimeEvent): EventHandler {\r\n    if (!isNullOrUndefined(evt))\r\n      return this.getNext_0(evt);\r\n    else\r\n      return this.getNext_1();\r\n  }\r\n\r\n  ///   changes the current run time event and returns the next event handler\r\n  private getNext_0(evt: RunTimeEvent): EventHandler {\r\n    this._rtEvt = evt;\r\n    return this.getNext();\r\n  }\r\n\r\n  ///   returns the next event handler\r\n  private getNext_1(): EventHandler {\r\n    if (this._handlersTab === null)\r\n      return null;\r\n\r\n    let result: EventHandler;\r\n\r\n    if (this._rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && this._rtEvt.getInternalCode() !== InternalInterface.MG_ACT_VARIABLE) {\r\n      // special treatment for TASK, RECORD and CONTROL level Prefix/Suffix events\r\n      switch (this._rtEvt.getInternalCode()) {\r\n        case InternalInterface.MG_ACT_TASK_PREFIX:\r\n        case InternalInterface.MG_ACT_TASK_SUFFIX:\r\n        case InternalInterface.MG_ACT_REC_PREFIX:\r\n        case InternalInterface.MG_ACT_REC_SUFFIX:\r\n        case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n        case InternalInterface.MG_ACT_CTRL_SUFFIX: {\r\n          if (this._handlerIdx === -1) {\r\n            for (this._handlerIdx = this._handlersTab.getSize() - 1; this._handlerIdx >= 0; this._handlerIdx--) {\r\n              let handler: EventHandler = this._handlersTab.getHandler(this._handlerIdx);\r\n              if ((handler.isNonSpecificHandlerOf(this._rtEvt)) || (handler.isSpecificHandlerOf(this._rtEvt))) {\r\n                return handler;\r\n              }\r\n            }\r\n          }\r\n\r\n          // an event handler was not found or was returned in a previous call to this method\r\n          return null;\r\n        }\r\n\r\n        default:\r\n          // other internal events should continue\r\n          break;\r\n      }\r\n    }\r\n\r\n    while (this.setNextHandlerIdx()) {\r\n      let handler: EventHandler = this._handlersTab.getHandler(this._handlerIdx);\r\n      switch (this._phase) {\r\n        case EventHandlerPosition.PHASE_CONTROL_SPECIFIC:\r\n          if (handler.isSpecificHandlerOf(this._rtEvt))\r\n            return handler;\r\n          continue;\r\n\r\n        case EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC:\r\n          if (handler.isNonSpecificHandlerOf(this._rtEvt))\r\n            return handler;\r\n          continue;\r\n\r\n        case EventHandlerPosition.PHASE_GLOBAL_SPECIFIC:\r\n          if (handler.isGlobalSpecificHandlerOf(this._rtEvt))\r\n            return handler;\r\n          continue;\r\n\r\n        case EventHandlerPosition.PHASE_GLOBAL:\r\n          if (handler.isGlobalHandlerOf(this._rtEvt))\r\n            return handler;\r\n          continue;\r\n\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"in EventHandlerPosition.getNext() invalid phase: \" + this._phase);\r\n          break;\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  ///   returns true if a next handler was found\r\n  private setNextHandlerIdx(): boolean {\r\n\r\n    // the handler idx is (-1) when starting to search in a task\r\n    if (this._handlerIdx < 0)\r\n      this._handlerIdx = this._handlersTab.getSize() - 1;\r\n    else\r\n      this._handlerIdx = this._handlerIdx - 1;\r\n\r\n    if (this._handlerIdx < 0 || this._task.isAborting()) {\r\n      // if there are no more handlers in the task then go up the chain of tasks\r\n      if (this.goUpTaskChain())\r\n        return this.setNextHandlerIdx();\r\n      else // no more tasks in the chain\r\n        return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  ///   get the next task in the tasks chain and returns false if no task was found.\r\n  ///   this function changes the phase variable accordingly\r\n  private goUpTaskChain(): boolean {\r\n    let mGData: MGData = this._task.getMGData();\r\n    let ctlIdx: number = this._task.getCtlIdx();\r\n\r\n    switch (this._phase) {\r\n      case EventHandlerPosition.PHASE_CONTROL_SPECIFIC:\r\n      case EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC: {\r\n        // non specific handlers are searched till we hit our main program (inclusive)\r\n        // afterwards we switch to global phase.\r\n        if (!this._task.isMainProg()) {\r\n          this.getParentOrCompMainPrg();\r\n          break;\r\n        }\r\n        else {\r\n          // internal, internal, system and user events may cross component bounderies\r\n          if ((this._rtEvt.getType() === ConstInterface.EVENT_TYPE_PUBLIC ||\r\n               this._rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL ||\r\n               this._rtEvt.getType() === ConstInterface.EVENT_TYPE_SYSTEM ||\r\n               this._rtEvt.getType() === ConstInterface.EVENT_TYPE_USER) && ctlIdx > 0) {\r\n            // load the RT parent of the previous task. If no prevtask exists then we are\r\n            // simply running on the main progs list (for example, when a main prg catches\r\n            // a timer event, no prevtask exists.\r\n            if (this._prevTask === null) {\r\n              this._task = mGData.getNextMainProg(ctlIdx);\r\n              if (this._task === null && ctlIdx > 0)\r\n                this._task = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, AccessHelper.eventsManager.getCompMainPrgTab().getCtlIdx(0));\r\n            }\r\n            else {\r\n              // the component main program that was set in getParentOrCompMainPrg, is now replaced back to the path parent.\r\n              this._task = this._prevTask.PathParentTask;\r\n              this._prevTask = null;\r\n            }\r\n            this._rtEvt.setMainPrgCreator(null); // moving out of a main program to another task\r\n            break;\r\n          }\r\n\r\n          if (this._phase === EventHandlerPosition.PHASE_CONTROL_SPECIFIC) {\r\n            // specific search is over. start the non specific search from the first task.\r\n            this._phase = EventHandlerPosition.PHASE_GLOBAL_SPECIFIC;\r\n          }\r\n          else {\r\n            // here we scan the main progs according to the load sequence (first to last).\r\n            this._phase = EventHandlerPosition.PHASE_GLOBAL;\r\n          }\r\n\r\n          this._task = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, AccessHelper.eventsManager.getCompMainPrgTab().getCtlIdx(0));\r\n          this._rtEvt.setMainPrgCreator(this._task);\r\n          if (this._task === null)\r\n            return false;\r\n          break;\r\n        }\r\n      }\r\n      case EventHandlerPosition.PHASE_GLOBAL_SPECIFIC:\r\n      case EventHandlerPosition.PHASE_GLOBAL: {\r\n        this._task = mGData.getNextMainProg(ctlIdx);\r\n        if (this._task === null) {\r\n          if (this._phase === EventHandlerPosition.PHASE_GLOBAL)\r\n            return false;\r\n\r\n          // specific search is over. start the non specific search from the first task.\r\n          this._phase = EventHandlerPosition.PHASE_CONTROL_NON_SPECIFIC;\r\n          this._task = this._orgTask;\r\n          this._prevTask = this._orgPrevTask;\r\n        }\r\n        break;\r\n      }\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"in EventHandlerPosition.goUpTaskChain() invalid phase: \" + this._phase);\r\n        break;\r\n    }\r\n    if (this._task === null)\r\n      return false;\r\n\r\n    this._handlersTab = this._task.getHandlersTab();\r\n    if (this._handlersTab === null)\r\n      return this.goUpTaskChain();\r\n\r\n    this._handlerIdx = -1;\r\n    return true;\r\n  }\r\n\r\n  ///   if the current task and its parent are from different components then\r\n  ///   set the task to the main program of the component of the current task.\r\n  ///   otherwise, set the task to be the parent of the current task\r\n  private getParentOrCompMainPrg(): void {\r\n    let ctlIdx: number = this._task.getCtlIdx();\r\n    this._prevTask = this._task;\r\n\r\n    // Retrieve the task's calling-parent. We need the task who invoked the current task\r\n    // rather than the task's triggering parent.\r\n    // The Path Parent is the parent of that task as if the server had done build path. It is more logical to search using the trigger task tree\r\n    // but since the online/server does not use the trigger tree, we decided not to use it here as well.\r\n    // If the path parent is from a different comp, it means that between curr task and parent there should be a comp main prog.\r\n    let pathParentTask: Task = this._task.PathParentTask;\r\n    if (pathParentTask === null) {\r\n      this._task = null;\r\n      return;\r\n    }\r\n\r\n    // check if the parent task is from another component\r\n    if (ctlIdx !== pathParentTask.getCtlIdx()) {\r\n      // replace the parent task to search with the comp main program. later on, the main prog will be replaced with\r\n      // the real PathParentTask.\r\n      this._rtEvt.setMainPrgCreator(this._task);\r\n      this._task = <Task>AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);\r\n    }\r\n    else {\r\n      this._rtEvt.setMainPrgCreator(null);\r\n      this._task = pathParentTask;\r\n    }\r\n  }\r\n}\r\n"]}