@magic-xpa/engine 4.1100.0-dev4110.99 → 4.1101.0-dev4111.271

package/esm2022/src/rt/Argument.mjs

@@ -0,0 +1,265 @@
+import { ApplicationException, NNumber } from '@magic-xpa/mscorelib';
+import { Logger, StorageAttribute, StorageAttributeCheck } from '@magic-xpa/utils';
+import { BlobType, ExpVal, FieldDef } from '@magic-xpa/gui';
+import { ConstInterface } from '../ConstInterface';
+import { FieldBase } from '../data/FieldBase';
+export class Argument {
+    _exp = null;
+    _fld = null;
+    _skip = false;
+    _type = '\0';
+    _val = null;
+    _valueAttr = StorageAttribute.NONE;
+    _valueIsNull = false;
+    constructor(fieldOrExpValOrSrcArg) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        if (arguments.length === 1 && (fieldOrExpValOrSrcArg === null || fieldOrExpValOrSrcArg instanceof FieldBase)) {
+            this.constructor_1(fieldOrExpValOrSrcArg);
+            return;
+        }
+        if (arguments.length === 1 && (fieldOrExpValOrSrcArg === null || fieldOrExpValOrSrcArg instanceof ExpVal)) {
+            this.constructor_2(fieldOrExpValOrSrcArg);
+            return;
+        }
+        this.constructor_3(fieldOrExpValOrSrcArg);
+    }
+    constructor_0() {
+        this._type = '\0';
+        this._fld = null;
+        this._exp = null;
+        this._skip = false;
+    }
+    constructor_1(field) {
+        this._fld = field;
+        this._type = ConstInterface.ARG_TYPE_FIELD;
+        this._exp = null;
+        this._skip = false;
+    }
+    constructor_2(expVal) {
+        this._type = ConstInterface.ARG_TYPE_VALUE;
+        this._fld = null;
+        this._exp = null;
+        this._skip = false;
+        if (expVal.IsNull)
+            this._val = null;
+        else
+            this._val = expVal.ToMgVal();
+        this._valueIsNull = (this._val === null);
+        this._valueAttr = expVal.Attr;
+    }
+    constructor_3(srcArg) {
+        this._type = ConstInterface.ARG_TYPE_VALUE;
+        switch (srcArg._type) {
+            case ConstInterface.ARG_TYPE_FIELD:
+                this._valueAttr = srcArg._fld.getType();
+                break;
+            case ConstInterface.ARG_TYPE_EXP:
+                break;
+            case ConstInterface.ARG_TYPE_SKIP:
+                this._skip = true;
+                break;
+            default:
+                throw new ApplicationException("in Argument.Argument(): illegal source Argument type!");
+        }
+    }
+    async Initialize(srcArg) {
+        switch (srcArg._type) {
+            case ConstInterface.ARG_TYPE_FIELD:
+                this._val = srcArg._fld.getValue(true);
+                this._valueIsNull = srcArg._fld.isNull();
+                break;
+            case ConstInterface.ARG_TYPE_EXP:
+                let retVal = await srcArg._exp.evaluateWithResLength(255);
+                this._val = retVal.mgVal;
+                this._valueAttr = retVal.type;
+                this._valueIsNull = (this._val == null);
+                if (this._valueIsNull)
+                    this._val = Argument.getEmptyValue((retVal.type === StorageAttribute.BLOB ||
+                        retVal.type === StorageAttribute.BLOB_VECTOR));
+                break;
+        }
+    }
+    fillData(arg, srcTask) {
+        this._type = arg[0];
+        let argElements = arg.substr(2);
+        switch (this._type) {
+            case ConstInterface.ARG_TYPE_FIELD:
+                {
+                    let fieldId = argElements.split(',');
+                    let parent = NNumber.Parse(fieldId[0]);
+                    let fldIdx = NNumber.Parse(fieldId[1]);
+                    this._fld = srcTask.getFieldDef(parent, fldIdx);
+                }
+                break;
+            case ConstInterface.ARG_TYPE_EXP:
+                let expNum = NNumber.Parse(argElements);
+                this._exp = srcTask.getExpById(expNum);
+                break;
+            case ConstInterface.ARG_TYPE_SKIP:
+                this._skip = true;
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("in Argument.FillData() illegal type: " + arg);
+                break;
+        }
+    }
+    buildXML(message) {
+        switch (this._type) {
+            case ConstInterface.ARG_TYPE_FIELD:
+                message.Append("F:" + this._fld.getTask().getTaskTag() + "," + this._fld.getId());
+                break;
+            case ConstInterface.ARG_TYPE_EXP:
+                message.Append("E:" + this._exp.getId());
+                break;
+            case ConstInterface.ARG_TYPE_SKIP:
+                message.Append("X:0");
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("in Argument.buildXML() illegal type: " + this._type);
+                break;
+        }
+    }
+    getType() {
+        return this._type;
+    }
+    getField() {
+        if (this._type === ConstInterface.ARG_TYPE_FIELD)
+            return this._fld;
+        return null;
+    }
+    getExp() {
+        if (this._type === ConstInterface.ARG_TYPE_EXP)
+            return this._exp;
+        return null;
+    }
+    async setValueToField(destFld) {
+        let val;
+        let isNull;
+        switch (this._type) {
+            case ConstInterface.ARG_TYPE_FIELD:
+                val = this._fld.getValue(true);
+                val = Argument.convertArgs(val, this._fld.getType(), destFld.getType());
+                isNull = this._fld.isNull() || val == null;
+                break;
+            case ConstInterface.ARG_TYPE_EXP:
+                val = await this._exp.evaluateWithResultTypeAndLength(destFld.getType(), destFld.getSize());
+                isNull = (val == null);
+                if (isNull)
+                    val = Argument.getEmptyValue((destFld.getType() === StorageAttribute.BLOB ||
+                        destFld.getType() === StorageAttribute.BLOB_VECTOR));
+                break;
+            case ConstInterface.ARG_TYPE_VALUE:
+                val = Argument.convertArgs(this._val, this._valueAttr, destFld.getType());
+                isNull = this._valueIsNull || val == null;
+                break;
+            default:
+                return;
+        }
+        destFld.takeValFromRec();
+        await destFld.setValueAndStartRecompute(val, isNull, destFld.getTask().DataViewWasRetrieved, false, true);
+    }
+    static convertArgs(value, srcAttr, expectedType) {
+        let invalidArg = false;
+        switch (expectedType) {
+            case StorageAttribute.ALPHA:
+            case StorageAttribute.UNICODE:
+                if (srcAttr === StorageAttribute.BLOB) {
+                    if (BlobType.isValidBlob(value))
+                        value = BlobType.getString(value);
+                }
+                else if (!StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr))
+                    invalidArg = true;
+                break;
+            case StorageAttribute.NUMERIC:
+            case StorageAttribute.DATE:
+            case StorageAttribute.TIME:
+                if (!StorageAttributeCheck.isTypeNumeric(srcAttr))
+                    invalidArg = true;
+                break;
+            case StorageAttribute.BLOB:
+                if (StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr)) {
+                    let contentType = srcAttr === StorageAttribute.ALPHA
+                        ? BlobType.CONTENT_TYPE_ANSI
+                        : BlobType.CONTENT_TYPE_UNICODE;
+                    value = BlobType.createFromString(value, contentType);
+                }
+                else if (!StorageAttributeCheck.isTypeBlob(srcAttr))
+                    invalidArg = true;
+                break;
+        }
+        if (invalidArg)
+            value = FieldDef.getMagicDefaultValue(expectedType);
+        return value;
+    }
+    async getValue(expType, expSize) {
+        switch (this._type) {
+            case ConstInterface.ARG_TYPE_EXP:
+                this._val = await this._exp.evaluateWithResultTypeAndLength(expType, expSize);
+                if (this._val == null)
+                    this._val = Argument.getEmptyValue(expType === StorageAttribute.BLOB
+                        || expType === StorageAttribute.BLOB_VECTOR);
+                break;
+            case ConstInterface.ARG_TYPE_FIELD:
+                this._val = this._fld.getValue(true);
+                break;
+            case ConstInterface.ARG_TYPE_VALUE:
+                break;
+            default:
+                return null;
+        }
+        return this._val;
+    }
+    skipArg() {
+        return this._skip;
+    }
+    fillDataByParams(paramValueAttr, paramValue, paramNull) {
+        this._valueAttr = paramValueAttr;
+        this._val = paramValue;
+        this._valueIsNull = paramNull;
+        if (this._valueAttr === StorageAttribute.SKIP) {
+            this._type = ConstInterface.ARG_TYPE_SKIP;
+            this._skip = true;
+        }
+        else {
+            this._type = ConstInterface.ARG_TYPE_VALUE;
+        }
+    }
+    static getEmptyValue(isBlob) {
+        return isBlob ? (BlobType.getEmptyBlobPrefix('\0') + ";") : "";
+    }
+    FillFromString(argStr) {
+        this._type = ConstInterface.ARG_TYPE_VALUE;
+        let argType = null;
+        if (argStr.length > 2)
+            argType = argStr.substr(0, 2);
+        switch (argType) {
+            case ConstInterface.REQ_ARG_ALPHA:
+                this._valueAttr = StorageAttribute.ALPHA;
+                break;
+            case ConstInterface.REQ_ARG_UNICODE:
+                this._valueAttr = StorageAttribute.UNICODE;
+                break;
+            case ConstInterface.REQ_ARG_NUMERIC:
+                this._valueAttr = StorageAttribute.NUMERIC;
+                break;
+            case ConstInterface.REQ_ARG_DOUBLE:
+                this._valueAttr = StorageAttribute.NUMERIC;
+                break;
+            case ConstInterface.REQ_ARG_LOGICAL:
+                this._valueAttr = StorageAttribute.BOOLEAN;
+                break;
+            case ConstInterface.REQ_ARG_NULL:
+                this._valueAttr = StorageAttribute.NONE;
+                break;
+            default:
+                this._valueAttr = StorageAttribute.ALPHA;
+                this._val = argStr;
+                return;
+        }
+        this._val = argStr.substr(2);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Argument.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/Argument.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApplicationException, NNumber, StringBuilder } from '@magic-xpa/mscorelib';\r\nimport { Logger, StorageAttribute, StorageAttributeCheck} from '@magic-xpa/utils';\r\nimport { BlobType, ExpVal, FieldDef } from '@magic-xpa/gui';\r\nimport { Expression } from '../exp/Expression';\r\nimport { Task } from '../tasks/Task';\r\nimport { ConstInterface } from '../ConstInterface';\r\nimport { FieldBase } from '../data/FieldBase';\r\n\r\n\r\nexport class Argument {\r\n  private _exp: Expression = null;\r\n  private _fld: FieldBase = null;\r\n  private _skip: boolean = false;\r\n  private _type: string = '\\0'; // FieldBase|Expression|Value\r\n  private _val: string = null;\r\n  private _valueAttr: StorageAttribute = StorageAttribute.NONE; // true is argument is of type ARG_TYPE_VALUE and\r\n  private _valueIsNull: boolean = false;\r\n\r\n  constructor();\r\n  constructor(field: FieldBase);\r\n  constructor(expVal: ExpVal);\r\n  constructor(srcArg: Argument);\r\n  constructor(fieldOrExpValOrSrcArg?: any) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    if (arguments.length === 1 && (fieldOrExpValOrSrcArg === null || fieldOrExpValOrSrcArg instanceof FieldBase)) {\r\n      this.constructor_1(fieldOrExpValOrSrcArg);\r\n      return;\r\n    }\r\n    if (arguments.length === 1 && (fieldOrExpValOrSrcArg === null || fieldOrExpValOrSrcArg instanceof ExpVal)) {\r\n      this.constructor_2(fieldOrExpValOrSrcArg);\r\n      return;\r\n    }\r\n    this.constructor_3(fieldOrExpValOrSrcArg);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  private constructor_0(): void {\r\n    this._type = '\\0'/*'\u0000'*/;\r\n    this._fld = null;\r\n    this._exp = null;\r\n    this._skip = false;\r\n  }\r\n\r\n  /// <summary>\r\n  /// CTOR - create an argument from a field\r\n  /// </summary>\r\n  private constructor_1(field: FieldBase): void {\r\n    this._fld = field;\r\n    this._type = ConstInterface.ARG_TYPE_FIELD /*'F'*/;\r\n    this._exp = null;\r\n    this._skip = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR that creates a \"Value\" type argument from a given Expression Value\r\n  /// </summary>\r\n  /// <param name = \"expVal\">the source expression value</param>\r\n  private constructor_2(expVal: ExpVal): void {\r\n    this._type = ConstInterface.ARG_TYPE_VALUE;\r\n    this._fld = null;\r\n    this._exp = null;\r\n    this._skip = false;\r\n\r\n    if (expVal.IsNull)\r\n      this._val = null;\r\n    else\r\n      this._val = expVal.ToMgVal();\r\n\r\n    this._valueIsNull = (this._val === null);\r\n    this._valueAttr = expVal.Attr;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR that creates a \"Value\" type argument from a given FieldBase or Expression type\r\n  ///   argument\r\n  /// </summary>\r\n  /// <param name = \"srcArg\">the source argument</param>\r\n  constructor_3(srcArg: Argument) {\r\n    this._type = ConstInterface.ARG_TYPE_VALUE;\r\n\r\n    switch (srcArg._type) {\r\n      case ConstInterface.ARG_TYPE_FIELD:\r\n        this._valueAttr = srcArg._fld.getType();\r\n        break;\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        break;\r\n      case ConstInterface.ARG_TYPE_SKIP:\r\n        this._skip = true;\r\n        break;\r\n      default:\r\n        throw new ApplicationException(\"in Argument.Argument(): illegal source Argument type!\");\r\n    }\r\n  }\r\n\r\n  public async Initialize(srcArg: Argument): Promise<void>{\r\n    switch (srcArg._type) {\r\n      case ConstInterface.ARG_TYPE_FIELD:\r\n        this._val = srcArg._fld.getValue(true);\r\n        this._valueIsNull = srcArg._fld.isNull();\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        let retVal = await srcArg._exp.evaluateWithResLength(255);\r\n        this._val = retVal.mgVal;\r\n        this._valueAttr = retVal.type;\r\n        this._valueIsNull = (this._val == null);\r\n        if (this._valueIsNull)\r\n          this._val = Argument.getEmptyValue((retVal.type === StorageAttribute.BLOB ||\r\n            retVal.type === StorageAttribute.BLOB_VECTOR));\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Parsing Argument string and fill inner objects\r\n  /// </summary>\r\n  /// <param name = \"arg\">string to parse </param>\r\n  /// <param name = \"srcTask\">of the argument to find expression argument </param>\r\n  public fillData(arg: String, srcTask: Task): void {\r\n    this._type = arg[0];\r\n    let argElements: string = arg.substr(2);\r\n\r\n    switch (this._type) {\r\n      case ConstInterface.ARG_TYPE_FIELD: {\r\n        let fieldId: string[] = argElements.split(',');\r\n        let parent: number =  NNumber.Parse(fieldId[0]);\r\n        let fldIdx: number =  NNumber.Parse(fieldId[1]);\r\n        this._fld = <FieldBase>srcTask.getFieldDef(parent, fldIdx);\r\n      }\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        let expNum: number = NNumber.Parse(argElements);\r\n        this._exp = srcTask.getExpById(expNum);\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_SKIP:\r\n        this._skip = true;\r\n        break;\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"in Argument.FillData() illegal type: \" + arg);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the argument\r\n  /// </summary>\r\n  /// <param name = \"message\">the XML string to append the argument to</param>\r\n  public buildXML(message: StringBuilder): void {\r\n    switch (this._type) {\r\n      case ConstInterface.ARG_TYPE_FIELD:\r\n        message.Append(\"F:\" + this._fld.getTask().getTaskTag() + \",\" + this._fld.getId());\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        message.Append(\"E:\" + this._exp.getId());\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_SKIP:\r\n        message.Append(\"X:0\");\r\n        break;\r\n\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"in Argument.buildXML() illegal type: \" + this._type);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the type of the argument\r\n  /// </summary>\r\n  getType(): string {\r\n    return this._type;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   for field type arguments returns a reference to the field\r\n  /// </summary>\r\n  getField(): FieldBase {\r\n    if (this._type === ConstInterface.ARG_TYPE_FIELD)\r\n      return this._fld;\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   for expression type arguments returns a reference to the expression\r\n  /// </summary>\r\n  protected getExp(): Expression {\r\n    if (this._type === ConstInterface.ARG_TYPE_EXP)\r\n      return this._exp;\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of this argument to a given field\r\n  /// </summary>\r\n  /// <param name = \"destFld\">the destination field\r\n  /// </param>\r\n  public async setValueToField(destFld: FieldBase): Promise<void> {\r\n    let val: string;\r\n    let isNull: boolean;\r\n\r\n    switch (this._type) {\r\n      case ConstInterface.ARG_TYPE_FIELD:\r\n        val = this._fld.getValue(true);\r\n        val = Argument.convertArgs(val, this._fld.getType(), destFld.getType());\r\n        isNull = this._fld.isNull() || val == null;\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        val = await this._exp.evaluateWithResultTypeAndLength(destFld.getType(), destFld.getSize());\r\n        isNull = (val == null);\r\n        if (isNull)\r\n          val = Argument.getEmptyValue((destFld.getType() === StorageAttribute.BLOB ||\r\n            destFld.getType() === StorageAttribute.BLOB_VECTOR));\r\n        break;\r\n      case ConstInterface.ARG_TYPE_VALUE:\r\n        val = Argument.convertArgs(this._val, this._valueAttr, destFld.getType());\r\n        isNull = this._valueIsNull || val == null;\r\n        break;\r\n      default:\r\n        return;\r\n    }\r\n    // Update destination field's _isNULL with the value from record. This is needed to identify\r\n    // if the variable is modified.\r\n    destFld.takeValFromRec();\r\n    await destFld.setValueAndStartRecompute(val, isNull, (<Task>destFld.getTask()).DataViewWasRetrieved, false, true);\r\n  }\r\n\r\n  /// <summary>\r\n  /// converts Alpha/Unicode values to Blob and vice versa.\r\n  /// </summary>\r\n  /// <param name=\"value\"></param>\r\n  /// <param name=\"srcAttr\"></param>\r\n  /// <param name=\"expectedType\"></param>\r\n  /// <returns></returns>\r\n  public static convertArgs(value: string, srcAttr: StorageAttribute, expectedType: StorageAttribute): string {\r\n    let invalidArg: boolean = false;\r\n\r\n    switch (expectedType) {\r\n      case StorageAttribute.ALPHA:\r\n      case StorageAttribute.UNICODE:\r\n        if (srcAttr === StorageAttribute.BLOB) {\r\n          if (BlobType.isValidBlob(value))\r\n            value = BlobType.getString(value);\r\n        }\r\n        else if (!StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr))\r\n          invalidArg = true;\r\n        break;\r\n\r\n      case StorageAttribute.NUMERIC:\r\n      case StorageAttribute.DATE:\r\n      case StorageAttribute.TIME:\r\n        if (!StorageAttributeCheck.isTypeNumeric(srcAttr))\r\n          invalidArg = true;\r\n        break;\r\n\r\n      case StorageAttribute.BLOB:\r\n        if (StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr)) {\r\n          let contentType: string = srcAttr === StorageAttribute.ALPHA\r\n            ? BlobType.CONTENT_TYPE_ANSI\r\n            : BlobType.CONTENT_TYPE_UNICODE;\r\n          value = BlobType.createFromString(value, contentType);\r\n        }\r\n        else if (!StorageAttributeCheck.isTypeBlob(srcAttr))\r\n          invalidArg = true;\r\n        break;\r\n    }\r\n\r\n    // If there is mismatch in attribute, take default value of expectd argument.\r\n    if (invalidArg)\r\n      value = FieldDef.getMagicDefaultValue(expectedType);\r\n    return value;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get value of Argument\r\n  /// </summary>\r\n  /// <param name = \"expType\">type of expected type of evaluation</param>\r\n  /// <param name = \"expSize\">size of expected string from evaluation</param>\r\n  /// <returns> value of the Argument</returns>\r\n  public async getValue(expType: StorageAttribute, expSize: number): Promise<string> {\r\n    switch (this._type) {\r\n      case ConstInterface.ARG_TYPE_EXP:\r\n        this._val = await this._exp.evaluateWithResultTypeAndLength(expType, expSize);\r\n        if (this._val == null)\r\n          this._val = Argument.getEmptyValue(expType === StorageAttribute.BLOB\r\n            || expType === StorageAttribute.BLOB_VECTOR);\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_FIELD:\r\n        this._val = this._fld.getValue(true);\r\n        break;\r\n\r\n      case ConstInterface.ARG_TYPE_VALUE:\r\n        break;\r\n\r\n      default:\r\n        return null;\r\n    }\r\n    return this._val;\r\n  }\r\n\r\n  /// <returns> value of the skip flag </returns>\r\n  skipArg(): boolean {\r\n    return this._skip;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill an argument data from a parameter data\r\n  /// </summary>\r\n  /// <param name = \"paramValueAttr\"></param>\r\n  /// <param name = \"paramValue\"></param>\r\n  /// <param name = \"paramNull\"></param>\r\n  fillDataByParams(paramValueAttr: StorageAttribute, paramValue: string, paramNull: boolean): void {\r\n    this._valueAttr = paramValueAttr;\r\n    this._val = paramValue;\r\n    this._valueIsNull = paramNull;\r\n\r\n    // The server indicates skip on a parameter by sending DATA_TYPE_SKIP instead of the real attribute.\r\n    if (this._valueAttr === StorageAttribute.SKIP) {\r\n      this._type = ConstInterface.ARG_TYPE_SKIP /*'X'*/;\r\n      this._skip = true;\r\n    }\r\n    else {\r\n      this._type = ConstInterface.ARG_TYPE_VALUE /*V*/;\r\n    }\r\n  }\r\n\r\n  /// <summary> returns empty value</summary>\r\n  /// <param name=\"isBlob\">- true is value is for blob</param>\r\n  private static getEmptyValue(isBlob: boolean): string {\r\n    return isBlob ? (BlobType.getEmptyBlobPrefix('\\0') /*'\u0000'*/ + \";\") : \"\";\r\n  }\r\n\r\n  /// <summary>\r\n  /// fill the argument from a string\r\n  /// </summary>\r\n  /// <param name=\"argStr\"></param>\r\n  public FillFromString(argStr: string): void {\r\n    // type is always a value\r\n    this._type = ConstInterface.ARG_TYPE_VALUE;\r\n\r\n    let argType: string = null;\r\n    // If string is shorter than 3, assume it does not have an attribute identifier\r\n    if (argStr.length > 2)\r\n      argType = argStr.substr(0, 2);\r\n\r\n    switch (argType) {\r\n      case ConstInterface.REQ_ARG_ALPHA:\r\n        this._valueAttr = StorageAttribute.ALPHA;\r\n        break;\r\n      case ConstInterface.REQ_ARG_UNICODE:\r\n        this._valueAttr = StorageAttribute.UNICODE;\r\n        break;\r\n      case ConstInterface.REQ_ARG_NUMERIC:\r\n        this._valueAttr = StorageAttribute.NUMERIC;\r\n        break;\r\n      case ConstInterface.REQ_ARG_DOUBLE:\r\n        this._valueAttr = StorageAttribute.NUMERIC;\r\n        break;\r\n      case ConstInterface.REQ_ARG_LOGICAL:\r\n        this._valueAttr = StorageAttribute.BOOLEAN;\r\n        break;\r\n      case ConstInterface.REQ_ARG_NULL:\r\n        this._valueAttr = StorageAttribute.NONE;\r\n        break;\r\n      default:\r\n        // if storage type is not defined, assume alpha string and the entire string is the value\r\n        this._valueAttr = StorageAttribute.ALPHA;\r\n        this._val = argStr;\r\n        return;\r\n    }\r\n    // the case the string is too short was dealt with earlier - it will get to the default case in the switch\r\n    // and return from there\r\n    this._val = argStr.substr(2);\r\n  }\r\n\r\n\r\n}\r\n"]}

package/esm2022/src/rt/ArgumentsList.mjs

@@ -0,0 +1,103 @@
+import { List } from '@magic-xpa/mscorelib';
+import { Argument } from './Argument';
+import { StrUtil } from '@magic-xpa/utils';
+export class ArgumentsList {
+    _list = null;
+    RefreshOnString = null;
+    constructor(srcArgsOrExp_paramsOrArgument) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        if (arguments.length === 1 && (srcArgsOrExp_paramsOrArgument === null || srcArgsOrExp_paramsOrArgument instanceof Array)) {
+            this.constructor_2(srcArgsOrExp_paramsOrArgument);
+            return;
+        }
+        this.constructor_3(srcArgsOrExp_paramsOrArgument);
+    }
+    constructor_0() {
+    }
+    async Initialize(srcArgs) {
+        this.constructor_0();
+        if (srcArgs === null)
+            this._list = null;
+        else {
+            this._list = new List();
+            for (let i = 0; i < srcArgs.getSize(); i = i + 1) {
+                let arg = new Argument(srcArgs.getArg(i));
+                await arg.Initialize(srcArgs.getArg(i));
+                this._list.push(arg);
+            }
+        }
+    }
+    constructor_2(Exp_params) {
+        this.constructor_0();
+        let argCnt = Exp_params.length;
+        if (argCnt === 0)
+            this._list = null;
+        else {
+            this._list = new List();
+            for (let i = 0; i < argCnt; i = i + 1) {
+                this._list.push(new Argument(Exp_params[i]));
+            }
+        }
+    }
+    constructor_3(argument) {
+        this.Add(argument);
+    }
+    fillList(valueStr, srcTask) {
+        let tok = StrUtil.tokenize(valueStr, "$");
+        let size = tok.length;
+        this._list = new List();
+        for (let i = 0; i < size; i = i + 1) {
+            let argument = new Argument();
+            argument.fillData(tok[i], srcTask);
+            this._list.push(argument);
+        }
+    }
+    buildListFromParams(size, attrs, vals, nulls) {
+        this._list = new List();
+        for (let i = 0; i < size; i = i + 1) {
+            let argument = new Argument();
+            argument.fillDataByParams(attrs.charAt(i), vals[i], nulls.charAt(i) !== '0');
+            this._list.push(argument);
+        }
+    }
+    buildXML(message) {
+        for (let i = 0; i < this._list.length; i = i + 1) {
+            if (i > 0)
+                message.Append('$');
+            this._list.get_Item(i).buildXML(message);
+        }
+    }
+    getSize() {
+        return (this._list === null) ? 0 : this._list.length;
+    }
+    getArg(idx) {
+        if (idx < 0 || idx >= this._list.length)
+            return null;
+        return this._list.get_Item(idx);
+    }
+    async getArgValue(idx, expType, expSize) {
+        let arg = this.getArg(idx);
+        if (arg === null)
+            return null;
+        return await arg.getValue(expType, expSize);
+    }
+    FillListFromString(argsString) {
+        let pattern = new RegExp("(?<!\\\\),");
+        let array = argsString.split(pattern);
+        this._list = new List();
+        for (let i = 0; i < array.length; i = i + 1) {
+            let argument = new Argument();
+            argument.FillFromString(array[i]);
+            this._list.push(argument);
+        }
+    }
+    Add(argument) {
+        if (this._list === null)
+            this._list = new List();
+        this._list.push(argument);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArgumentsList.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/ArgumentsList.ts"],"names":[],"mappings":"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","sourcesContent":["import { ExpVal } from '@magic-xpa/gui';\r\nimport { List, StringBuilder } from '@magic-xpa/mscorelib';\r\nimport { Argument } from './Argument';\r\nimport { Task } from '../tasks/Task';\r\nimport { TaskBase } from '../tasks/TaskBase';\r\nimport { StorageAttribute, StrUtil } from '@magic-xpa/utils';\r\n\r\nexport class ArgumentsList {\r\n  private _list: List<Argument> = null;\r\n\r\n  // String for subform arguments\r\n  // Only for offline. It's relevant for call with destination\r\n  RefreshOnString: string = null;\r\n\r\n  constructor();\r\n  constructor(Exp_params: ExpVal[]);\r\n  constructor(argument: Argument);\r\n  constructor(srcArgsOrExp_paramsOrArgument?: any) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    if (arguments.length === 1 && (srcArgsOrExp_paramsOrArgument === null || srcArgsOrExp_paramsOrArgument instanceof Array)) {\r\n      this.constructor_2(srcArgsOrExp_paramsOrArgument);\r\n      return;\r\n    }\r\n    this.constructor_3(srcArgsOrExp_paramsOrArgument);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  private constructor_0(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR that creates a VALUE argument list using a given argument list\r\n  /// </summary>\r\n  public async Initialize(srcArgs: ArgumentsList): Promise<void> {\r\n    this.constructor_0();\r\n    if (srcArgs === null)\r\n      this._list = null;\r\n    else {\r\n      this._list = new List<Argument>();\r\n\r\n      for (let i: number = 0; i < srcArgs.getSize(); i = i + 1) {\r\n        let arg = new Argument(srcArgs.getArg(i));\r\n        await arg.Initialize(srcArgs.getArg(i));\r\n        this._list.push(arg);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR that creates a VALUE argument list using a given expression value list\r\n  /// </summary>\r\n  private constructor_2(Exp_params: ExpVal[]): void {\r\n    this.constructor_0();\r\n    let argCnt: number = Exp_params.length;\r\n\r\n    if (argCnt === 0)\r\n      this._list = null;\r\n    else {\r\n      this._list = new List<Argument>();\r\n\r\n      for (let i: number = 0; i < argCnt; i = i + 1) {\r\n        this._list.push(new Argument(Exp_params[i]));\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// CTOR - create an argument list with one specified argument\r\n  /// </summary>\r\n  /// <param name=\"argument\"></param>\r\n  private constructor_3(argument: Argument): void {\r\n    this.Add(argument);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill the argument list\r\n  /// </summary>\r\n  /// <param name = \"valueStr\">string in the format of: \"[F:str,str]|[E:str]$...\"</param>\r\n  /// <param name = \"srcTask\">the source task for parsing expression arguments</param>\r\n  fillList(valueStr: string, srcTask: TaskBase): void {\r\n    let tok: string[] = StrUtil.tokenize(valueStr, \"$\");\r\n    let size: number = tok.length;\r\n\r\n    this._list = new List<Argument>();\r\n\r\n    for (let i: number = 0; i < size; i = i + 1) {\r\n      let argument: Argument = new Argument();\r\n      argument.fillData(tok[i], <Task>srcTask);\r\n      this._list.push(argument);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   builds argument list from the event parameters\r\n  /// </summary>\r\n  /// <param name = \"size\">   - argument number </param>\r\n  /// <param name = \"attrs\">  - string of attributes</param>\r\n  /// <param name = \"vals\">   - value strings</param>\r\n  /// <param name = \"nulls\">  - arguments nulls</param>\r\n  buildListFromParams(size: number, attrs: string, vals: string[], nulls: string): void {\r\n    this._list = new List<Argument>();\r\n\r\n    for (let i: number = 0; i < size; i = i + 1) {\r\n      let argument: Argument = new Argument();\r\n      argument.fillDataByParams(<StorageAttribute>attrs.charAt(i), vals[i], nulls.charAt(i) !== '0'/*'0'*/);\r\n      this._list.push(argument);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the arguments list\r\n  /// </summary>\r\n  /// <param name = \"message\">the XML string to append the arguments to</param>\r\n  buildXML(message: StringBuilder): void {\r\n    for (let i: number = 0; i < this._list.length; i = i + 1) {\r\n      if (i > 0)\r\n        message.Append('$')/*'$'*/;\r\n      this._list.get_Item(i).buildXML(message);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the size of the list\r\n  /// </summary>\r\n  getSize(): number {\r\n    return (this._list === null) ? 0 : this._list.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns an argument item from the list by its index\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the requested argument</param>\r\n  getArg(idx: number): Argument {\r\n    if (idx < 0 || idx >= this._list.length)\r\n      return null;\r\n\r\n    return this._list.get_Item(idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get Value of Argument\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the requested argument</param>\r\n  /// <param name = \"expType\">type of expected type of evaluation, for expression only</param>\r\n  /// <param name = \"expSize\">size of expected string from evaluation, for expression only</param>\r\n  /// <returns> value of evaluated Argument</returns>\r\n  async getArgValue(idx: number, expType: StorageAttribute, expSize: number): Promise<string> {\r\n    let arg: Argument = this.getArg(idx);\r\n    if (arg === null)\r\n      return null;\r\n    return await arg.getValue(expType, expSize);\r\n  }\r\n\r\n  /// <summary>\r\n  /// fill the arguments list from a string\r\n  /// </summary>\r\n  /// <param name=\"argsString\"></param>\r\n  FillListFromString(argsString: string): void {\r\n\r\n    // TODO : check size of bundle and decide whether to use RegExp\r\n    let pattern = new RegExp(\"(?<!\\\\\\\\),\");\r\n    let array: string[] = argsString.split(pattern);\r\n    this._list = new List<Argument>();\r\n\r\n    for (let i: number = 0; i < array.length; i = i + 1) {\r\n      let argument: Argument = new Argument();\r\n      argument.FillFromString(array[i]);\r\n      this._list.push(argument);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// add an argument to the list\r\n  /// </summary>\r\n  /// <param name=\"argument\"></param>\r\n  Add(argument: Argument): void {\r\n    if (this._list === null)\r\n      this._list = new List<Argument>();\r\n    this._list.push(argument);\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/Boundary.mjs

@@ -0,0 +1,152 @@
+import { ExpressionEvaluator, NullValueException } from "../exp/ExpressionEvaluator";
+import { DisplayConvertor, ExpVal } from "@magic-xpa/gui";
+import { StorageAttribute, StrUtil } from "@magic-xpa/utils";
+import { Char, NString } from "@magic-xpa/mscorelib";
+export class Boundary {
+    _cacheTableFldId = 0;
+    _max = null;
+    _min = null;
+    _retType = StorageAttribute.NONE;
+    _size = 0;
+    _maxExpVal = null;
+    _minExpVal = null;
+    DiscardMin = false;
+    DiscardMax = false;
+    MaxEqualsMin = false;
+    constructor(task, minIdx, maxIdx, returnType, size, cacheTableId) {
+        if (arguments.length === 5)
+            this.constructor_0(task, minIdx, maxIdx, returnType, size);
+        else
+            this.constructor_1(task, minIdx, maxIdx, returnType, size, cacheTableId);
+    }
+    constructor_0(task, minIdx, maxIdx, returnType, size) {
+        this.constructor_1(task, minIdx, maxIdx, returnType, size, -1);
+    }
+    constructor_1(task, minIdx, maxIdx, returnType, size, cacheTableId) {
+        this._retType = returnType;
+        this._size = size;
+        this._cacheTableFldId = cacheTableId;
+        if (minIdx !== -1)
+            this._min = task.getExpById(minIdx);
+        if (maxIdx !== -1)
+            this._max = task.getExpById(maxIdx);
+    }
+    hasMinExp() {
+        return this._min !== null;
+    }
+    hasMaxExp() {
+        return this._max !== null;
+    }
+    getExpType() {
+        return this._retType;
+    }
+    getCacheTableFldId() {
+        return this._cacheTableFldId;
+    }
+    async compute(padValueWithMinMaxCharacters) {
+        if (this.hasMinExp()) {
+            let minVal = await this._min.evaluateWithResultTypeAndLength(this.getExpType(), this._size);
+            if (minVal !== null) {
+                minVal = NString.TrimEnd(minVal, new Array(0));
+            }
+            this._minExpVal = new ExpVal(this.getExpType(), minVal === null, minVal);
+            this.MaxEqualsMin = this.IsMaxEqualsMin();
+            if (!this._minExpVal.IsNull && (this._minExpVal.Attr === StorageAttribute.ALPHA || this._minExpVal.Attr === StorageAttribute.UNICODE)) {
+                if (padValueWithMinMaxCharacters) {
+                    this._minExpVal.StrVal = DisplayConvertor.StringValueToMgValue(this._minExpVal.StrVal, this._minExpVal.Attr, Char.MinValue, this._size).toString();
+                    this.MaxEqualsMin = false;
+                }
+                this._minExpVal.StrVal = StrUtil.SearchAndReplaceWildChars(this._minExpVal.StrVal, this._size, Char.MinValue);
+            }
+            this.DiscardMin = await this._min.DiscardCndRangeResult();
+        }
+        if (this.hasMaxExp()) {
+            let maxVal = await this._max.evaluateWithResultTypeAndLength(this.getExpType(), this._size);
+            this._maxExpVal = new ExpVal(this.getExpType(), maxVal === null, maxVal);
+            if (!this._maxExpVal.IsNull && (this._maxExpVal.Attr === StorageAttribute.ALPHA || this._maxExpVal.Attr === StorageAttribute.UNICODE)) {
+                if (padValueWithMinMaxCharacters) {
+                    this._maxExpVal.StrVal = DisplayConvertor.StringValueToMgValue(this._maxExpVal.StrVal, this._maxExpVal.Attr, Char.MaxValue, this._size);
+                }
+                this._maxExpVal.StrVal = StrUtil.SearchAndReplaceWildChars(this._maxExpVal.StrVal, this._size, Char.MaxValue);
+            }
+            this.DiscardMax = await this._max.DiscardCndRangeResult();
+        }
+    }
+    checkRange(val, IsNull) {
+        let res = true;
+        let cmpVal = new ExpVal(this.getExpType(), IsNull, val);
+        if (cmpVal.IsNull && ((this.hasMinExp() && this._minExpVal.IsNull) || (this.hasMaxExp() && this._maxExpVal.IsNull))) {
+            res = true;
+        }
+        else {
+            if (this.hasMinExp()) {
+                if (!this._minExpVal.IsNull && !cmpVal.IsNull) {
+                    try {
+                        if (ExpressionEvaluator.val_cmp_any(cmpVal, this._minExpVal) < 0)
+                            res = false;
+                    }
+                    catch (exception) {
+                        if (exception instanceof NullValueException) {
+                            res = false;
+                        }
+                        else
+                            throw exception;
+                    }
+                }
+                else {
+                    if (cmpVal.IsNull !== this._minExpVal.IsNull)
+                        res = false;
+                }
+            }
+            if (this.hasMaxExp() && res) {
+                if (!this._maxExpVal.IsNull && !cmpVal.IsNull) {
+                    try {
+                        if (ExpressionEvaluator.val_cmp_any(cmpVal, this._maxExpVal) > 0)
+                            res = false;
+                    }
+                    catch (exception) {
+                        if (exception instanceof NullValueException)
+                            res = false;
+                        else
+                            throw exception;
+                    }
+                }
+                else if (cmpVal.IsNull !== this._maxExpVal.IsNull)
+                    res = false;
+            }
+        }
+        return res;
+    }
+    IsMaxEqualsMin() {
+        let result = false;
+        if (this.hasMaxExp() && this.hasMinExp()) {
+            if (this._min.getId() === this._max.getId()) {
+                if (this._retType === StorageAttribute.ALPHA || this._retType === StorageAttribute.UNICODE)
+                    result = !this.WildCharExist();
+                else
+                    result = true;
+            }
+        }
+        return result;
+    }
+    WildCharExist() {
+        let wildChars = ["*", "?"];
+        let result = false;
+        if (!this._minExpVal.IsNull) {
+            let stringValue = this._minExpVal.StrVal;
+            for (let i = 0; i < wildChars.length; i = i + 1) {
+                if (stringValue.endsWith(wildChars[i])) {
+                    result = true;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    toString() {
+        return NString.Format("{{Boundary: {0}-{1}, {2}, {3}}}", [
+            this._max, this._max, this._retType, this._size
+        ]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Boundary.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/Boundary.ts"],"names":[],"mappings":"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","sourcesContent":["import {ExpressionEvaluator, NullValueException} from \"../exp/ExpressionEvaluator\";\r\nimport {DisplayConvertor, ExpVal} from \"@magic-xpa/gui\";\r\nimport {StorageAttribute, StrUtil} from \"@magic-xpa/utils\";\r\nimport {Expression} from \"../exp/Expression\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {Char, NString} from \"@magic-xpa/mscorelib\";\r\n\r\n/// <summary>\r\n///   this class represent a range or locate sections - i.e. min/max expressions\r\n/// </summary>\r\nexport class Boundary {\r\n  private _cacheTableFldId: number = 0;\r\n  private _max: Expression = null;\r\n  private _min: Expression = null;\r\n  private _retType: StorageAttribute = StorageAttribute.NONE;\r\n  private _size: number = 0;\r\n  private _maxExpVal: ExpVal = null;\r\n  private _minExpVal: ExpVal = null;\r\n\r\n  DiscardMin: boolean = false;\r\n  DiscardMax: boolean = false;\r\n  MaxEqualsMin: boolean = false;\r\n\r\n\r\n  constructor(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number);\r\n  constructor(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number, cacheTableId: number);\r\n  constructor(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number, cacheTableId?: number) {\r\n    if (arguments.length === 5)\r\n      this.constructor_0(task, minIdx, maxIdx, returnType, size);\r\n    else\r\n      this.constructor_1(task, minIdx, maxIdx, returnType, size, cacheTableId);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Instantiates a new Boundary object\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"minIdx\"></param>\r\n  /// <param name=\"maxIdx\"></param>\r\n  /// <param name=\"returnType\"></param>\r\n  /// <param name=\"size\"></param>\r\n  private constructor_0(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number): void {\r\n    this.constructor_1(task, minIdx, maxIdx, returnType, size, -1);\r\n  }\r\n\r\n  private constructor_1(task: Task, minIdx: number, maxIdx: number, returnType: StorageAttribute, size: number, cacheTableId: number): void {\r\n    this._retType = returnType;\r\n    this._size = size;\r\n    this._cacheTableFldId = cacheTableId;\r\n    if (minIdx !== -1)\r\n      this._min = task.getExpById(minIdx);\r\n\r\n    if (maxIdx !== -1)\r\n      this._max = task.getExpById(maxIdx);\r\n  }\r\n\r\n  // sometimes the min or max does not have an expression\r\n  hasMinExp(): boolean {\r\n    return this._min !== null;\r\n  }\r\n\r\n  // sometimes the min or max does not have an expression\r\n  hasMaxExp(): boolean {\r\n    return this._max !== null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the min/max expressions return type - it actually the type of the field they are Associated with\r\n  /// </summary>\r\n  getExpType(): StorageAttribute {\r\n    return this._retType;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   return the id of the cached table field this range corresponds to\r\n  /// </summary>\r\n  getCacheTableFldId(): number {\r\n    return this._cacheTableFldId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   computes the min and max expression to check their values\r\n  /// </summary>\r\n  async compute(padValueWithMinMaxCharacters: boolean): Promise<void> {\r\n    if (this.hasMinExp()) {\r\n\r\n      // evaluate the min expression\r\n      let minVal: string = await this._min.evaluateWithResultTypeAndLength(this.getExpType(), this._size);\r\n      if (minVal !== null) {\r\n        minVal = NString.TrimEnd(minVal, new Array<string>(0));\r\n      }\r\n\r\n      this._minExpVal = new ExpVal(this.getExpType(), minVal === null, minVal);\r\n\r\n      // check and set the MaxEqualsMin before the wild chars are replaced on the string result\r\n      this.MaxEqualsMin = this.IsMaxEqualsMin();\r\n\r\n      if (!this._minExpVal.IsNull && (this._minExpVal.Attr === StorageAttribute.ALPHA || this._minExpVal.Attr === StorageAttribute.UNICODE)) {\r\n        if (padValueWithMinMaxCharacters) {\r\n          this._minExpVal.StrVal = DisplayConvertor.StringValueToMgValue(this._minExpVal.StrVal, this._minExpVal.Attr, Char.MinValue, /*'\u0000'*/this._size).toString();\r\n          this.MaxEqualsMin = false;\r\n        }\r\n        this._minExpVal.StrVal = StrUtil.SearchAndReplaceWildChars(this._minExpVal.StrVal, this._size, Char.MinValue)/*'\u0000'*/;\r\n      }\r\n      this.DiscardMin = await this._min.DiscardCndRangeResult();\r\n    }\r\n\r\n    if (this.hasMaxExp()) {\r\n\r\n      // evaluate the max expression\r\n      let maxVal: string = await this._max.evaluateWithResultTypeAndLength(this.getExpType(), this._size);\r\n      this._maxExpVal = new ExpVal(this.getExpType(), maxVal === null, maxVal);\r\n\r\n      if (!this._maxExpVal.IsNull && (this._maxExpVal.Attr === StorageAttribute.ALPHA || this._maxExpVal.Attr === StorageAttribute.UNICODE)) {\r\n        if (padValueWithMinMaxCharacters) {\r\n          this._maxExpVal.StrVal = DisplayConvertor.StringValueToMgValue(this._maxExpVal.StrVal, this._maxExpVal.Attr, Char.MaxValue /*'￿'*/, this._size);\r\n        }\r\n        this._maxExpVal.StrVal = StrUtil.SearchAndReplaceWildChars(this._maxExpVal.StrVal, this._size, Char.MaxValue)/*'￿'*/;\r\n      }\r\n      this.DiscardMax = await this._max.DiscardCndRangeResult();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   this function gets a value and checks whether it satisfies the range section\r\n  /// </summary>\r\n  /// <param name = \"val\">- the value to be compared\r\n  /// </param>\r\n  checkRange(val: string, IsNull: boolean): boolean {\r\n    let res: boolean = true;\r\n\r\n    let cmpVal: ExpVal = new ExpVal(this.getExpType(), IsNull, val);\r\n\r\n    if (cmpVal.IsNull && ((this.hasMinExp() && this._minExpVal.IsNull) || (this.hasMaxExp() && this._maxExpVal.IsNull))) {\r\n      res = true;\r\n    }\r\n    else {\r\n      // check min expression Compliance\r\n      if (this.hasMinExp()) {\r\n\r\n        // if both of the compared values are not null\r\n        if (!this._minExpVal.IsNull && !cmpVal.IsNull) {\r\n          try {\r\n            // the compared value must be equal or greater to the min value\r\n            if (ExpressionEvaluator.val_cmp_any(cmpVal, this._minExpVal) < 0)\r\n              res = false;\r\n          }\r\n          catch (exception) {\r\n            if (exception instanceof NullValueException) {\r\n              res = false;\r\n            }\r\n            else\r\n              throw exception;\r\n          }\r\n        }\r\n        else {\r\n          if (cmpVal.IsNull !== this._minExpVal.IsNull)\r\n            res = false;\r\n        }\r\n      }\r\n      // check max expression Compliance\r\n      if (this.hasMaxExp() && res) {\r\n        // if both of the compared values are not null\r\n        if (!this._maxExpVal.IsNull && !cmpVal.IsNull) {\r\n          try {\r\n            // the compared value must be equal or greater to the min value\r\n            if (ExpressionEvaluator.val_cmp_any(cmpVal, this._maxExpVal) > 0)\r\n              res = false;\r\n          }\r\n          catch (exception) {\r\n            if (exception instanceof NullValueException)\r\n              res = false;\r\n            else\r\n              throw exception;\r\n          }\r\n        }\r\n        // if one of them is null and null is the greatest value there is we must check that maxExpVal is not null\r\n        else if (cmpVal.IsNull !== this._maxExpVal.IsNull)\r\n          res = false;\r\n      }\r\n    }\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns true if min expression equal to max expression and no wild chars (*, ?) exist in the range\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  IsMaxEqualsMin(): boolean {\r\n    let result: boolean = false;\r\n    if (this.hasMaxExp() && this.hasMinExp()) {\r\n      if (this._min.getId() === this._max.getId()) {\r\n        if (this._retType === StorageAttribute.ALPHA || this._retType === StorageAttribute.UNICODE)\r\n          result = !this.WildCharExist();\r\n        else\r\n          result = true;\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// checks if wild char exist in tne value\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private WildCharExist(): boolean {\r\n    let wildChars: string[] = [\"*\", \"?\"];\r\n    let result: boolean = false;\r\n\r\n    // check trim\r\n    if (!this._minExpVal.IsNull) {\r\n      let stringValue: string = this._minExpVal.StrVal;\r\n\r\n      for (let i: number = 0; i < wildChars.length; i = i + 1) {\r\n        if (stringValue.endsWith(wildChars[i])) {\r\n          result = true;\r\n          break;\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  toString(): string {\r\n    return NString.Format(\"{{Boundary: {0}-{1}, {2}, {3}}}\", [\r\n      this._max, this._max, this._retType, this._size\r\n    ]);\r\n  }\r\n}\r\n"]}