@colijnit/corecomponents_v12 254.1.9 → 255.1.1

package/projects/corecomponents/src/lib/core/utils/number-utils.ts

@@ -0,0 +1,350 @@
+import {anyNill} from "../function/any-nill.function";
+import {ArrayUtils} from "./array-utils";
+import {CheckWithinSteppedBoundsResult} from "../model/check-within-stepped-bounds-result";
+import {isNill} from "../function/is-nill.function";
+import { ObjectUtils } from './object-utils';
+import { CheckPrecisionAndScaleResult } from '../model/check-precision-and-scale-result';
+
+// @dynamic
+export class NumberUtils {
+    // @returns The inclusive max value
+    public static PrecisionScaleToMaxValue(precision: number, scale: number): number {
+        const oneStep: number = this.DecimalsToStepIncrement(scale);
+        const maxExclusive: number = Math.pow(10, precision - scale);
+        return maxExclusive - oneStep;
+    }
+
+    // Parses given argument to an integer, using a native parseInt() function with a radix of 10. Returns NaN if parsing was not possible.
+    public static ParseInt(arg: any): number {
+        if (isNill(arg) || Array.isArray(arg)) {
+            return undefined;
+        }
+
+        return parseInt(arg, 10);
+    }
+
+    public static DecimalsToStepIncrement(numberOfDecimals: number): number {
+        return Math.pow(10, -1 * numberOfDecimals);
+    }
+
+    // Returns the given argument as a number. Returns given defaultValue if conversion of argument was impossible.
+    public static ParseNumberOrDefault(arg: any, defaultValue: number = 0): number {
+        if (Array.isArray(arg)) {
+            return defaultValue;
+        }
+
+        if (!NumberUtils.IsNumber(arg)) {
+            arg = parseFloat(arg);
+            arg = isNaN(arg) ? defaultValue : arg;
+        }
+        return arg;
+    }
+
+    // Parses given numberInput to a number, or returns given defaultValue if parse not possible. Allows ',' char as decimal delimiter.
+    public static ParseNumberInputOrDefault(numberInput: any, defaultValue: number = 0): number {
+        return NumberUtils.ParseNumberOrDefault(NumberUtils._NumberInputToNumberStr(numberInput), defaultValue);
+    }
+
+    public static IsParsableNumberInput(numberInput: any): boolean {
+        return NumberUtils.IsParsableNumber(NumberUtils._NumberInputToNumberStr(numberInput));
+    }
+
+    // Returns whether the type of given argument is 'number'.
+    public static IsNumber(arg: any): boolean {
+        return typeof arg === 'number';
+    }
+
+    // Returns whether the value is parasable as a number.
+    public static IsParsableNumber(arg: any): boolean {
+        if (Array.isArray(arg)) {
+            return false;
+        }
+
+        return !isNaN(parseFloat(arg));
+    }
+
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param The argument to parse to a float
+     * @param The number of decimals, or the precision, the parsed return float should have
+     * @returns NaN if not possible, else the parsed float value
+     */
+    public static ParseFloat(arg: any, decimalPrecision: number = 2): number {
+        if (anyNill(arg, decimalPrecision) || Array.isArray(arg)) {
+            return NaN;
+        }
+
+        if (!NumberUtils.IsInteger(decimalPrecision) || decimalPrecision < 0) {
+            decimalPrecision = 2;
+            // toFixed() can only handle up until 20
+        } else if (decimalPrecision > 20) {
+            decimalPrecision = 20;
+        }
+
+        return parseFloat(parseFloat(arg).toFixed(decimalPrecision));
+    }
+
+    /**
+     * Returns given arg as a float number with given decimal precision, if possible. Returns NaN if parse conversion failed.
+     *
+     * @param The argument to parse to a float
+     * @returns The argument as a float with its original decimal precision intact
+     */
+    public static ParseFloatKeepPrecision(arg: any): number {
+        let decimalPrecision: number = this.GetDecimalPlaces(arg);
+        return this.ParseFloat(arg, decimalPrecision);
+    }
+
+    public static ParseFloatNumberInputKeepPrecision(arg: any): number {
+        let correctedInputStr: string = NumberUtils._NumberInputToNumberStr(arg);
+        let decimalPrecision: number = this.GetDecimalPlaces(correctedInputStr);
+        return NumberUtils.ParseFloat(correctedInputStr, decimalPrecision);
+    }
+
+    /**
+     * Finds the number closest to the originalNumber, that adheres to the given bounds. That is, for which it holds that
+     * nr = min + N * step with N integer or 0.
+     * @param originalNr Find closest answer to this number
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns The closest OK number for bounds.
+     */
+    public static GetNearestNumberWithinSteppedBounds(originalNr: number, min: number, max: number, stepSize: number = 1): number {
+        if (originalNr < min) {
+            return min;
+        } else if (originalNr > max) {
+            return NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize);
+        }
+
+        let boundsCheck: CheckWithinSteppedBoundsResult = NumberUtils.CheckWithinSteppedBounds(originalNr, min, max, stepSize);
+        if (boundsCheck.isOk) {
+            return originalNr;
+        }
+
+        let answer: number = undefined;
+
+        let remainder: number = boundsCheck.remainder;
+        if (remainder) {
+            // round up or down?
+            if ((remainder / stepSize) < 0.5) {
+                //  round down, but not below min
+                answer = (originalNr - remainder >= min ? originalNr - remainder : min);
+            } else {
+                // round up, but not above max
+                answer = (originalNr + stepSize - remainder <= max ? originalNr + stepSize - remainder :
+                    NumberUtils.GetTrueSteppedBoundsMax(min, max, stepSize));
+            }
+        } else {
+            // is this real life, why wasn't our stepped bounds check OK?
+            answer = originalNr;
+        }
+
+        // 'correct' float errors
+        answer = NumberUtils.ParseFloat(answer, NumberUtils._GetLargestDecimalPrecisionOf(originalNr, min, max, stepSize));
+        return answer;
+    }
+
+    // Returns the number of decimal places of the given number. Returns 0 if no decimals whatsoever could be found on given arg.
+    public static GetDecimalPlaces(arg: any, maxAnswer: number = 1000): number {
+        let match: RegExpMatchArray = ('' + arg).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+        if (!match) {
+            return 0;
+        }
+
+        let answer: number = Math.max(0,
+            // number of digits right of decimal point.
+            (match[1] ? match[1].length : 0)
+            // adjust for scientific notation
+            - (match[2] ? +match[2] : 0));
+
+        if (answer > maxAnswer) {
+            answer = maxAnswer;
+        }
+
+        return answer;
+    }
+
+    // Returns true iff given argument is an integer number. Returns false on non-numbers or numbers with significant decimals.
+    public static IsInteger(arg: any): boolean {
+        if (isNaN(arg) || Array.isArray(arg)) {
+            return false;
+        }
+        let argAsFloat: number = parseFloat(arg);
+        return ((argAsFloat | 0) === argAsFloat); // returns whether 'arg converted to an integer equals arg'
+    }
+
+    /**
+     * Returns whether given arg is parseable as a number, and whether the lengts of its number parse result is equal to its original length.
+     * I.e. this function returns FALSE with given number-parsable strings, but that have non-numeric appendices, eg '2233ff'. That arg
+     * IS number-parseable, but not a strict 'string number', the latter being what this method actually checks for.
+     */
+    public static IsStringNumber(arg: string): boolean {
+        if (!NumberUtils.IsParsableNumber(arg)) {
+            return false;
+        } else {
+            return arg.toString().length === parseFloat(arg).toString().length;
+        }
+    }
+
+    /**
+     * Returns a random integer in range [lowerBound .. upperBound], an inclusive range. Returns NaN if not possible.
+     * Given bounds are truncated first, before serving as the true lower- and upper bounds for the random int.
+     */
+    public static RandomInt(lowerBoundInt: number, upperBoundInt: number): number {
+        if (!NumberUtils.IsNumber(lowerBoundInt) || !NumberUtils.IsNumber(upperBoundInt) || lowerBoundInt > upperBoundInt) {
+            return NaN;
+        }
+
+        lowerBoundInt = Math.trunc(lowerBoundInt);
+        upperBoundInt = Math.trunc(upperBoundInt);
+
+        if (lowerBoundInt === upperBoundInt) {
+            return lowerBoundInt;
+        }
+
+        const delta: number = upperBoundInt - lowerBoundInt;
+        return (Math.round(Math.random() * delta) + lowerBoundInt);
+    }
+
+    /**
+     * Returns the true maximum allowed value for the given "stepped bounds": min, stepSize and max, for which it holds that each allowed
+     * value Y = min + stepSize * N, for any INTEGER or 0 N where it also holds, of course, that Y <= max.
+     * @param min
+     * @param max
+     * @param stepSize
+     */
+    public static GetTrueSteppedBoundsMax(min: number, max: number, stepSize: number = 1): number {
+        // solve max integer X in formula min + X * step <= max, and return min + X * stepSize for that X
+        let maxSteps: number = Math.floor((max - min) / stepSize);
+        // 'correct' float errors
+        return NumberUtils.ParseFloat(min + maxSteps * stepSize, NumberUtils._GetLargestDecimalPrecisionOf(min, min, max));
+    }
+
+    // Returns the string representation of given number. If it's not a number, returns the empty string.
+    public static ToString(nr: number): string {
+        if (!NumberUtils.IsNaN(nr)) {
+            return "" + nr;
+        } else {
+            return "";
+        }
+    }
+
+    // Returns whether given arg is indeed not a number (it's NaN or it has another type than 'number').
+    public static IsNaN(arg: any): boolean {
+        return isNaN(arg) || !NumberUtils.IsNumber(arg);
+    }
+
+    /**
+     * Returns whether given x is OK within the given min, max and step boundaries, where it should hold that nrToCheck = min + N * step,
+     * with N integer or 0.
+     * @param nrToCheck Number to check whether it's within the given bounds
+     * @param min Inclusive
+     * @param max Inclusive
+     * @param stepSize
+     * @returns Returns remainder of undefined when nrToCheck was OUTSIDE [min, max], else full result object.
+     */
+    public static CheckWithinSteppedBounds(
+        nrToCheck: number,
+        min: number,
+        max: number,
+        stepSize: number = 1
+    ): CheckWithinSteppedBoundsResult {
+        if (nrToCheck < min || nrToCheck > max) {
+            return {isOk: false, remainder: undefined};
+        }
+
+        // we're in [min, max], but still check if nrToCheck = min + N * step holds (for N integer or 0)
+        let remainder: number = (nrToCheck - min) % stepSize;
+        // correct float for largest precision amongst input numbers
+        remainder = NumberUtils.ParseFloat(remainder, NumberUtils._GetLargestDecimalPrecisionOf(nrToCheck, min, stepSize));
+        return {isOk: (remainder === 0), remainder: remainder};
+    }
+
+    // Adds thousands comma's to given value, E.g. '1000' to '1,000'. Returns empty string if value was undefined.
+    public static AddThousandsCommasTo(value: any): string {
+        if (isNill(value)) {
+            return "";
+        }
+
+        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    }
+
+    // Returns the nearest number, relative to the given originalNr, that is within the given [min, max] inclusive bounds.
+    public static GetNearestNumberWithinBounds(originalNr: number, min: number, max: number): number {
+        let answer: number = originalNr;
+
+        if (originalNr < min) {
+            answer = min;
+        } else if (originalNr > max) {
+            answer = max;
+        }
+
+        return answer;
+    }
+
+    /**
+     * Returns whether given nrToCheck is within the given precision and scale limits. Precision and scale, here, are Oracle DB terms.
+     * This function can thus be used to check whether the given number is safe to send to the 'database' beforehand, if we know the
+     * precision and scale of the number in the db declaration.
+     *
+     * I.e. A number declared in the Oracle DB as number(5, 2) has a precision of 5 and a scale of 2.
+     *
+     * @param nrToCheck
+     * @param precision The number of significant digits, including possibly negative scale. E.g. 3 in '123' and 5 in '51.123'
+     * @param [scale = 0] The number of significant digits AFTER the decimal point. E.g. 1 in 5432.1 and 3 in 54000.003
+     * @returns Whether given nrToCheck is ok for given precision and scale, and if not, the
+     * nearest number that IS ok for those constraints.
+     */
+    public static CheckPrecisionAndScale(nrToCheck: number, precision: number, scale: number = 0): CheckPrecisionAndScaleResult {
+        // let's say any undefined number is checked OK, and all numbers are checked OK for an undefined precision
+        if (!ObjectUtils.AllExist(nrToCheck, precision, scale)) {
+            return {isOk: true, nearestOkNr: NaN};
+        }
+        // no number can have 0 or less than 0 significant digits, in our universe
+        if (precision < 1 || precision - scale < 1) {
+            return {isOk: false, nearestOkNr: NaN};
+        }
+        // begin check
+        const isNegative: boolean = (nrToCheck < 0);
+        const nrParts: string[] = nrToCheck.toString().split(".");
+        // remove minus sign if negative
+        if (isNegative) {
+            nrParts[0] = nrParts[0].slice(1);
+        }
+        const numCountBeforeDot: number = nrParts[0].length;
+        const allowedNumCountBeforeDot: number = precision - scale;
+        if (numCountBeforeDot <= allowedNumCountBeforeDot) {
+            return {isOk: true, nearestOkNr: nrToCheck};
+        } else {
+            // cut a part from the "before decimal number" so that the number is not too big anymore
+            const numCountToRemove: number = numCountBeforeDot - allowedNumCountBeforeDot;
+            // remove the right-most numbers before the decimal dot
+            nrParts[0] = nrParts[0].slice(0, -1 * numCountToRemove);
+            // add minus sign again if it was negative
+            if (isNegative) {
+                nrParts[0] = "-" + nrParts[0];
+            }
+            // build and return composite number again
+            let nearestOkNr: number;
+            if (nrParts[1]) {
+                nearestOkNr = Number(nrParts[0] + "." + nrParts[1]);
+            } else {
+                nearestOkNr = Number(nrParts[0]);
+            }
+            return {isOk: false, nearestOkNr: nearestOkNr};
+        }
+    }
+
+    private static _GetLargestDecimalPrecisionOf(...args: number[]): number {
+        return ArrayUtils.GetMaxCalculatedValue(args, (arg: number) => {
+            return NumberUtils.GetDecimalPlaces(arg);
+        });
+    }
+
+    // Returns given number input as a number that's useable by Javascript. Allows for incoming ',' decimal delimiter.
+    private static _NumberInputToNumberStr(numberInput: string): string {
+        return (numberInput + '').replace(',', '.');
+    }
+}

package/projects/corecomponents/src/lib/core/utils/object-utils.ts

@@ -0,0 +1,205 @@
+import {isNill} from "../function/is-nill.function";
+import {notNill} from "../function/not-nill.function";
+
+// Static utility function holder related to objects.
+export class ObjectUtils {
+
+    /**
+     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
+     * @param values Rest parameters with all objects to check existence for.
+     * @returns True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
+     */
+    public static AllExist(...values: any[]): boolean {
+        let allExist: boolean = true;
+        for (let i: number = 0, len: number = values.length; i < len; i++) {
+            if (isNill(values[i])) {
+                allExist = false;
+                break;
+            }
+        }
+        return allExist;
+    }
+
+    // Returns a shallow clone of the given original object. The clone is a SIMPLE OBJECT with the same properties as the original.
+    public static GetShallowClone(originalObject: any, objectClass?: any): any {
+        let clonedObject: any = undefined;
+
+        if (objectClass) {
+            clonedObject = new objectClass();
+        } else {
+            clonedObject = {};
+        }
+
+        ObjectUtils.ForOwnProperty(originalObject, (value: any, key: string) => {
+            clonedObject[key] = value;
+        });
+
+        return clonedObject;
+    }
+
+    /**
+     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
+     * Does not copy functions, only properties.
+     * @param from The source object from which to copy all properties of to the 'to' object.
+     * @param to The object to which the properties of the 'from' object will be copied.
+     * @param [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
+     */
+    public static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined: boolean = true): T {
+        if (!to) {
+            to = {} as T;
+        }
+        if (!from) {
+            return to;
+        }
+        ObjectUtils.ForOwnProperty(from, (value: any, key: string) => {
+            if (allowUndefined || notNill(value)) {
+                to[key] = value;
+            }
+        });
+        return to;
+    }
+
+    /**
+     * Returns the display value of the given property on the given object, as a string (== the string representation of the property value).
+     * Does not return null or undefined, but returns the given defaultValue instead.
+     */
+    public static GetDisplayValueOfPropertyOn(object: Object, property: string, defaultValue: string = ""): string {
+        if (!object || !property) {
+            return defaultValue;
+        }
+
+        let returnValue: string = defaultValue;
+        let propertyValue: any = object[property];
+        if (propertyValue) {
+            returnValue = propertyValue.toString();
+        }
+
+        return returnValue;
+    }
+
+    // Performs given callback function for each own property of given plain object. Also works on string enums.
+    public static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void {
+        if (ObjectUtils.IsPlainObject(plainObject)) {
+            for (let key in plainObject) {
+                if (plainObject.hasOwnProperty(key) && typeof plainObject[key] !== 'function') {
+                    let response: boolean = callback(plainObject[key], key);
+                    if (response === false) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Returns whether given object is an existing, plain object. That is, it defined, its type if 'object' and it is NOT an array or func.
+    public static IsPlainObject(object: any): boolean {
+        return object !== null && !Array.isArray(object) && typeof object !== 'function' && typeof object === 'object';
+    }
+
+    public static DeepEquals(actual: any, expected: any): boolean {
+        if (actual === expected) {
+            return true;
+        } else if (actual instanceof Date && expected instanceof Date) {
+            return actual.getTime() === expected.getTime();
+        } else if (!actual || !expected || typeof actual !== 'object' && typeof expected !== 'object') {
+            return actual === expected;
+        } else {
+            return this._objEquiv(actual, expected);
+        }
+    }
+
+    private static _objEquiv(a: any, b: any): boolean {
+        let i: number, key: string;
+        if (isNill(a) || isNill(b)) {
+            return false;
+        }
+
+        if (a.prototype !== b.prototype) {
+            return false;
+        }
+
+        if (this._isArguments(a)) {
+            if (!this._isArguments(b)) {
+                return false;
+            }
+            a = Array.prototype.slice.call(a);
+            b = Array.prototype.slice.call(b);
+            return this.DeepEquals(a, b);
+        }
+        if (this._isBuffer(a)) {
+            if (!this._isBuffer(b)) {
+                return false;
+            }
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (i = 0; i < a.length; i++) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        let ka: string[];
+        let kb: string[];
+        try {
+            ka = Object.keys(a);
+            kb = Object.keys(b);
+        } catch (e) {
+            return false;
+        }
+
+        if (ka.length !== kb.length) {
+            return false;
+        }
+
+        ka.sort();
+        kb.sort();
+
+        for (i = ka.length - 1; i >= 0; i--) {
+            if (ka[i] !== kb[i]) {
+                return false;
+            }
+        }
+
+        for (i = ka.length - 1; i >= 0; i--) {
+            key = ka[i];
+            if (!this.DeepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return typeof a === typeof b;
+    }
+
+    private static _isBuffer(x: any): boolean {
+        if (!x || typeof x !== 'object' || typeof x.length !== 'number') {
+            return false;
+        }
+        if (typeof x.copy !== 'function' || typeof x.slice !== 'function') {
+            return false;
+        }
+        return !(x.length > 0 && typeof x[0] !== 'number');
+    }
+
+    private static _isArguments(x: any): boolean {
+        let supportsArgsClass: boolean = this._supportsArgumentsClass();
+        return supportsArgsClass ? this._isArgumentsWhenArgsClassSupported(x) : this._isArgumentsWhenArgsClassNotSupported(x);
+    }
+
+    private static _isArgumentsWhenArgsClassNotSupported(object: any): boolean {
+        return object &&
+            typeof object === 'object' &&
+            typeof object.length === 'number' &&
+            Object.prototype.hasOwnProperty.call(object, 'callee') &&
+            !Object.prototype.propertyIsEnumerable.call(object, 'callee') ||
+            false;
+    }
+
+    private static _isArgumentsWhenArgsClassSupported(object: any): boolean {
+        return Object.prototype.toString.call(object) === '[object Arguments]';
+    }
+
+    private static _supportsArgumentsClass(): boolean {
+        return Object.prototype.toString.call(arguments) === '[object Arguments]';
+    }
+}

package/projects/corecomponents/src/lib/core/utils/parameter-value-conversion-utils.ts

@@ -0,0 +1,116 @@
+import {StringUtils} from "./string-utils";
+import {LogicalOperatorType} from "../enum/logical-operator-type.enum";
+import {ValueComparisonType} from "../enum/value-comparison-type";
+import {NumberUtils} from "./number-utils";
+import {JAVA_MAX_INT} from "../constant/java-max-int";
+
+export class ParameterValueConversionUtils {
+    // A character to indicate the NEXT character should be interpreted as a value comparison type (when not in quotes data-value mode)
+    private static readonly _ComparatorPrefix: string = "?";
+    // The character that's used to separate (user) data values (which are between quotes) from the logical part of the search string markup.
+    private static readonly _QuoteChar: string = "'";
+    private static readonly _OrChar: string = ",";
+    private static readonly _AndChar: string = "&";
+    private static readonly _EqualChar: string = "=";
+    private static readonly _NotEqualChar: string = "!";
+    private static readonly _LargerThanChar: string = ">";
+    private static readonly _SmallerThanChar: string = "<";
+    // The between comparison notation has a slightly different syntax; the '?' is included in the middle of the two values, e.g. '1'<=?<'5'
+    private static readonly _BetweenChars: string = "<=?<=";
+
+    private static readonly _LogicalOperatorChars: Map<LogicalOperatorType, string> = new Map<LogicalOperatorType, string>([
+        [LogicalOperatorType.Or, ParameterValueConversionUtils._OrChar],
+        [LogicalOperatorType.And, ParameterValueConversionUtils._AndChar]
+    ]);
+
+    private static readonly _ValueComparisonTypeChars: Map<ValueComparisonType, string> = new Map<ValueComparisonType, string>([
+        [ValueComparisonType.Equal, ParameterValueConversionUtils._EqualChar],
+        [ValueComparisonType.NotEqual, ParameterValueConversionUtils._NotEqualChar],
+        [ValueComparisonType.LargerThan, ParameterValueConversionUtils._LargerThanChar],
+        [ValueComparisonType.SmallerThan, ParameterValueConversionUtils._SmallerThanChar]
+    ]);
+
+    /**
+     *
+     * @param searchString like ?='1',?='2',?='5', or any other valid search string.
+     * @returns Array with all data values between quotes from given string, like ['1', '2', '4']
+     */
+    public static ExtractDataValuesFromSearchString(searchString: string): string[] {
+        if (!searchString) {
+            return [];
+        }
+        const dataValues: string[] = [];
+        let matches: any[] = searchString.match(/'(.*?)'/g);
+        if (matches) {
+            // remove quotes (if you know an improvement in above regexp that already does this for us, please let me know)
+            matches = matches.map(match => match.substring(1, match.length - 1));
+        }
+        dataValues.push(...matches);
+        return dataValues;
+    }
+
+    // E.g. returns the string "?='1',?='2',?='3'" from a given array [1, 2, 3]. For use in backend search filters strings.
+    public static ArrayValuesToOrList(array: any[], defaultReturnVal: any = null): string {
+        if (!Array.isArray(array) || array.length === 0) {
+            return defaultReturnVal;
+        }
+
+        return ParameterValueConversionUtils.ArrayToComplexSearchFilter(array, LogicalOperatorType.Or);
+    }
+
+    /**
+     * Takes values from given array and returns a complex filter string which represents the following logical filter based on given operator
+     * type: '1 OR 2 OR 3 OR ..' or '1 AND 2 AND 3'.
+     * @returns Complex search filter in string representation, e.g.              "?='1','2','3'"
+     */
+    public static ArrayToComplexSearchFilter<T>(array: T[], logicalOperator: LogicalOperatorType = LogicalOperatorType.Or): string {
+        if (!array) {
+            return undefined;
+        }
+
+        let returnValue: string = "";
+        let logicalOperChar: string = this._LogicalOperatorChars.get(logicalOperator);
+        for (let i: number = 0, len: number = array.length; i < len; i++) {
+            returnValue += this._ComparatorPrefix + this._EqualChar + this._QuoteChar + array[i] + this._QuoteChar + logicalOperChar;
+        }
+        returnValue = StringUtils.RemoveLastChars(returnValue, 1); // last comma
+        return returnValue;
+    }
+
+    /**
+     * Returns [upperBound, lowerBound] num array from given range string. A range string's format is like "1 - 4". NOTE: negative
+     * numbers not supported!
+     * @param rangeString A "range string", formatted like '0 - 1000'.
+     * @returns Numerical bounds as [lower, upper]
+     */
+    public static RangeStringToBounds(rangeString: string): number[] {
+        if (rangeString) {
+            let split: string[] = rangeString.split("-");
+            let lowerBound: number = NumberUtils.ParseFloatKeepPrecision(split[0]);
+            let upperBound: number = NumberUtils.ParseFloatKeepPrecision(split[1]);
+            return [lowerBound, upperBound];
+        } else {
+            return [];
+        }
+    }
+
+    /**
+     * Takes given numerical lower and upper bounds, and returns it as a "range string", fit for use to send to the middle-tier. Not to be
+     * confused with a between-inclusive search string.
+     * @param lowerBound
+     * @param upperBound
+     * @returns A "range string" representation of given bounds, formatted like '0 - 1000'.
+     */
+    public static BoundsToRangeString(lowerBound: number, upperBound: number): string {
+        if (!lowerBound && !upperBound) {
+            return undefined;
+        }
+        if (!lowerBound) {
+            lowerBound = 0;
+        }
+        if (!upperBound) {
+            upperBound = JAVA_MAX_INT;
+        }
+        return "" + lowerBound + " - " + upperBound;
+    }
+}