@magic-xpa/utils
Version:
magic utils package
214 lines • 21.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
// creates "support classes" that duplicate the original functionality.
//
// Support classes replicate the functionality of the original code, but in some cases they are
// substantially different architecturally. Although every effort is made to preserve the
// original architecture of the application in the converted project, the user should be aware that
// the primary goal of these support classes is to replicate functionality, and that at times
// the architecture of the resulting solution may differ somewhat.
import { StringBuilder, NString, NNumber, DateTime, RefParam } from "@magic-xpa/mscorelib";
/// <summary>
/// Contains conversion support elements such as classes, interfaces and static methods.
/// </summary>
export class Misc {
/// <summary>
/// Writes the exception stack trace to the received stream
/// </summary>
/// <param name="throwable">Exception to obtain information from</param>
/// <param name="stream">Output sream used to write to</param>
/**
* @param {?} throwable
* @return {?}
*/
static WriteStackTrace(throwable) {
console.log(throwable.Message);
console.log(throwable.StackTrace);
}
/// <summary>
/// Receives a byte array and returns it transformed in an byte array
/// </summary>
/// <param name="byteArray">Byte array to process</param>
/// <returns>The transformed array</returns>
/**
* @param {?} byteArray
* @return {?}
*/
static ToSByteArray(byteArray) {
/** @type {?} */
let sbyteArray = null;
if (byteArray !== null) {
sbyteArray = new Int8Array(byteArray.length);
for (let i = 0; i < byteArray.length; i = i + 1) {
sbyteArray[i] = (/** @type {?} */ (byteArray[i]));
}
}
return sbyteArray;
}
/// <summary>
/// Receives sbyte array and returns it transformed in a byte array
/// </summary>
/// <param name="sbyteArray">sbyte array to process</param>
/// <returns>The transformed array</returns>
/**
* @param {?} sbyteArray
* @return {?}
*/
static ToByteArray(sbyteArray) {
/** @type {?} */
let byteArray = null;
if (sbyteArray !== null) {
byteArray = new Uint8Array(sbyteArray.length);
for (let i = 0; i < sbyteArray.length; i = i + 1) {
byteArray[i] = (/** @type {?} */ (sbyteArray[i]));
}
}
return byteArray;
}
/// <summary> Compares number of bytes in two byte arrays</summary>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <param name="numberOfBytes"></param>
/// <returns> boolen true if equal</returns>
/**
* @param {?} source
* @param {?} destination
* @param {?} numberOfBytes
* @return {?}
*/
static CompareByteArray(source, destination, numberOfBytes) {
if (source.length >= numberOfBytes && destination.length >= numberOfBytes) {
for (let len = 0; len < numberOfBytes; len++) {
if (source[len] !== destination[len])
return false;
}
}
else
return false;
return true;
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
// TODO: instead of calling URShift(number, bits), we can use((uint)number) >> bits.
/**
* @param {?} number
* @param {?} bits
* @return {?}
*/
static URShift(number, bits) {
/** @type {?} */
let result;
if (number >= 0) {
result = number >> bits;
}
else {
result = (number >> bits) + (2 << ~bits);
}
return result;
}
/// <summary>
/// get system's time in milliseconds
/// </summary>
/// <returns></returns>
/**
* @return {?}
*/
static getSystemMilliseconds() {
// TODO - check if we need this adjustment
return Math.floor((DateTime.Now.Ticks - 621355968000000000) / 10000);
}
/// <summary>
/// Compares 2 int arrays
/// </summary>
/// <param name="arrayOne"></param>
/// <param name="arrayTwo"></param>
/// <returns>true if arrays are equal else false</returns>
/**
* @param {?} arrayOne
* @param {?} arrayTwo
* @return {?}
*/
static CompareIntArrays(arrayOne, arrayTwo) {
/** @type {?} */
let areEqual = false;
if (arrayOne === arrayTwo) {
areEqual = true;
}
else {
if (arrayOne !== null && arrayTwo !== null) {
if (arrayOne.length === arrayTwo.length) {
for (let i = 0; i < arrayOne.length; i = i + 1) {
if (arrayOne[i] !== arrayTwo[i]) {
break;
}
areEqual = true;
}
}
}
}
return areEqual;
}
/// <summary>
/// Returns the comma separated string for the values passed in int array.
/// </summary>
/// <param name="values">Integer array</param>
/// <returns>comma separated string</returns>
/**
* @param {?} intArray
* @return {?}
*/
static GetCommaSeperatedString(intArray) {
/** @type {?} */
let temp = new StringBuilder();
for (let val = 0; val < intArray.length; val = val + 1) {
/** @type {?} */
let value = intArray[val];
if (temp.Length > 0) {
temp.Append(",");
}
temp.Append(value);
}
return temp.ToString();
}
/// <summary>
/// Returns int array out of comma separated string
/// </summary>
/// <param name="value">comma separated string</param>
/// <returns>Integer array</returns>
/**
* @param {?} commaSeparatedValue
* @return {?}
*/
static GetIntArray(commaSeparatedValue) {
/** @type {?} */
let intArray = new Array(0);
if (!NString.IsNullOrEmpty(commaSeparatedValue)) {
/** @type {?} */
let vals = commaSeparatedValue.split(',');
intArray = new Array(vals.length);
/** @type {?} */
let outInt = new RefParam(0);
for (let iCtr = 0; iCtr < vals.length; iCtr = iCtr + 1) {
/** @type {?} */
let _r = NNumber.TryParse(vals[iCtr], outInt);
intArray[iCtr] = outInt.value;
}
}
return intArray;
}
/**
* @param {?} fileName
* @return {?}
*/
static IsWebUrl(fileName) {
return fileName.toLowerCase().startsWith("http");
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Misc.js","sourceRoot":"ng://@magic-xpa/utils/","sources":["src/Misc.ts"],"names":[],"mappings":"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","sourcesContent":["// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant\r\n// creates \"support classes\" that duplicate the original functionality.\r\n//\r\n// Support classes replicate the functionality of the original code, but in some cases they are\r\n// substantially different architecturally. Although every effort is made to preserve the\r\n// original architecture of the application in the converted project, the user should be aware that\r\n// the primary goal of these support classes is to replicate functionality, and that at times\r\n// the architecture of the resulting solution may differ somewhat.\r\n\r\n\r\nimport {\r\n  Exception, StringBuilder,\r\n  NString, NNumber,\r\n  DateTime, RefParam\r\n} from \"@magic-xpa/mscorelib\";\r\n\r\n\r\n\r\n/// <summary>\r\n/// Contains conversion support elements such as classes, interfaces and static methods.\r\n/// </summary>\r\nexport class Misc {\r\n\r\n  /// <summary>\r\n  /// Writes the exception stack trace to the received stream\r\n  /// </summary>\r\n  /// <param name=\"throwable\">Exception to obtain information from</param>\r\n  /// <param name=\"stream\">Output sream used to write to</param>\r\n  static WriteStackTrace(throwable: Exception): void {\r\n    console.log(throwable.Message);\r\n    console.log(throwable.StackTrace);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Receives a byte array and returns it transformed in an byte array\r\n  /// </summary>\r\n  /// <param name=\"byteArray\">Byte array to process</param>\r\n  /// <returns>The transformed array</returns>\r\n  static ToSByteArray(byteArray: Uint8Array): Int8Array {\r\n    let sbyteArray: Int8Array = null;\r\n    if (byteArray !== null) {\r\n      sbyteArray = new Int8Array(byteArray.length);\r\n      for (let i: number = 0; i < byteArray.length; i = i + 1) {\r\n        sbyteArray[i] = <number>byteArray[i];\r\n      }\r\n    }\r\n    return sbyteArray;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Receives sbyte array and returns it transformed in a byte array\r\n  /// </summary>\r\n  /// <param name=\"sbyteArray\">sbyte array to process</param>\r\n  /// <returns>The transformed array</returns>\r\n  static ToByteArray(sbyteArray: Int8Array): Uint8Array {\r\n    let byteArray: Uint8Array = null;\r\n    if (sbyteArray !== null) {\r\n      byteArray = new Uint8Array(sbyteArray.length);\r\n      for (let i: number = 0; i < sbyteArray.length; i = i + 1) {\r\n        byteArray[i] = <number>sbyteArray[i];\r\n      }\r\n    }\r\n    return byteArray;\r\n  }\r\n\r\n  /// <summary> Compares number of bytes in two byte arrays</summary>\r\n  /// <param name=\"source\"></param>\r\n  /// <param name=\"destination\"></param>\r\n  /// <param name=\"numberOfBytes\"></param>\r\n  /// <returns> boolen true if equal</returns>\r\n  static CompareByteArray(source: Uint8Array, destination: Uint8Array, numberOfBytes: number): boolean {\r\n    if (source.length >= numberOfBytes && destination.length >= numberOfBytes) {\r\n      for (let len: number = 0; len < numberOfBytes; len++) {\r\n        if (source[len] !== destination[len])\r\n          return false;\r\n      }\r\n    }\r\n    else\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Performs an unsigned bitwise right shift with the specified number\r\n  /// </summary>\r\n  /// <param name=\"number\">Number to operate on</param>\r\n  /// <param name=\"bits\">Ammount of bits to shift</param>\r\n  /// <returns>The resulting number from the shift operation</returns>\r\n  // TODO: instead of calling URShift(number, bits), we can use((uint)number) >> bits.\r\n  static URShift(number: number, bits: number): number {\r\n    let result: number;\r\n    if (number >= 0) {\r\n      result = number >> bits;\r\n    }\r\n    else {\r\n      result = (number >> bits) + (2 << ~bits);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// get system's time in milliseconds\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static getSystemMilliseconds(): number {\r\n    // TODO - check if we need this adjustment\r\n    return Math.floor((DateTime.Now.Ticks - 621355968000000000) / 10000);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Compares 2 int arrays\r\n  /// </summary>\r\n  /// <param name=\"arrayOne\"></param>\r\n  /// <param name=\"arrayTwo\"></param>\r\n  /// <returns>true if arrays are equal else false</returns>\r\n  static CompareIntArrays(arrayOne: number[], arrayTwo: number[]): boolean {\r\n    let areEqual: boolean = false;\r\n    if (arrayOne === arrayTwo) {\r\n      areEqual = true;\r\n    }\r\n    else {\r\n      if (arrayOne !== null && arrayTwo !== null) {\r\n        if (arrayOne.length === arrayTwo.length) {\r\n          for (let i: number = 0; i < arrayOne.length; i = i + 1) {\r\n            if (arrayOne[i] !== arrayTwo[i]) {\r\n              break;\r\n            }\r\n            areEqual = true;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return areEqual;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns the comma separated string for the values passed in int array.\r\n  /// </summary>\r\n  /// <param name=\"values\">Integer array</param>\r\n  /// <returns>comma separated string</returns>\r\n  static GetCommaSeperatedString(intArray: number[]): string {\r\n    let temp: StringBuilder = new StringBuilder();\r\n    for (let val: number = 0; val < intArray.length; val = val + 1) {\r\n      let value: number = intArray[val];\r\n      if (temp.Length > 0) {\r\n        temp.Append(\",\");\r\n      }\r\n      temp.Append(value);\r\n    }\r\n    return temp.ToString();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns int array out of comma separated string\r\n  /// </summary>\r\n  /// <param name=\"value\">comma separated string</param>\r\n  /// <returns>Integer array</returns>\r\n  static GetIntArray(commaSeparatedValue: string): number[] {\r\n    let intArray: number[] = new Array<number>(0);\r\n\r\n    if (!NString.IsNullOrEmpty(commaSeparatedValue)) {\r\n      let vals: string[] = commaSeparatedValue.split(',');\r\n      intArray = new Array<number>(vals.length);\r\n\r\n      let outInt: RefParam<number> = new RefParam(0);\r\n      for (let iCtr: number = 0; iCtr < vals.length; iCtr = iCtr + 1) {\r\n        let _r = NNumber.TryParse(vals[iCtr], outInt);\r\n        intArray[iCtr] = outInt.value;\r\n      }\r\n    }\r\n\r\n    return intArray;\r\n  }\r\n\r\n  static IsWebUrl(fileName: string): boolean {\r\n    return fileName.toLowerCase().startsWith(\"http\");\r\n  }\r\n}\r\n"]}