@magic-xpa/utils
Version:
magic utils package
1,192 lines (1,190 loc) • 1.02 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@magic-xpa/mscorelib'), require('xml2js'), require('util')) :
typeof define === 'function' && define.amd ? define('@magic-xpa/utils', ['exports', '@magic-xpa/mscorelib', 'xml2js', 'util'], factory) :
(factory((global['magic-xpa'] = global['magic-xpa'] || {}, global['magic-xpa'].utils = {}),null,null,null));
}(this, (function (exports,mscorelib,xml2js,util) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var UtilStrByteMode = (function () {
function UtilStrByteMode() {
}
/// <summary> Checks the environment whether it is running on DBCS environment
/// Returns true if the language code for the current default Locale is
/// DBCS language (in non-Unicode encoding).
///
/// </summary>
/// <returns> true if DBCS, or false if SBCS
/// </returns>
/// <summary> Checks the environment whether it is running on DBCS environment
/// Returns true if the language code for the current default Locale is
/// DBCS language (in non-Unicode encoding).
///
/// </summary>
/// <returns> true if DBCS, or false if SBCS
/// </returns>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangDBCS =
/// <summary> Checks the environment whether it is running on DBCS environment
/// Returns true if the language code for the current default Locale is
/// DBCS language (in non-Unicode encoding).
///
/// </summary>
/// <returns> true if DBCS, or false if SBCS
/// </returns>
/**
* @return {?}
*/
function () {
return UtilStrByteMode._bLocaleDefLangJPN || UtilStrByteMode._bLocaleDefLangCHN || UtilStrByteMode._bLocaleDefLangKOR;
};
/// <summary> Checks whether the language code for the current default Locale
/// is JAPANESE.
///
/// </summary>
/// <returns> true if JAPANESE, or false if not
/// </returns>
/// <summary> Checks whether the language code for the current default Locale
/// is JAPANESE.
///
/// </summary>
/// <returns> true if JAPANESE, or false if not
/// </returns>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangJPN =
/// <summary> Checks whether the language code for the current default Locale
/// is JAPANESE.
///
/// </summary>
/// <returns> true if JAPANESE, or false if not
/// </returns>
/**
* @return {?}
*/
function () {
return UtilStrByteMode._bLocaleDefLangJPN;
};
/// <summary> Checks whether the language code for the current default Locale
/// is KOREAN.
///
/// </summary>
/// <returns> true if KOREAN, or false if not
/// </returns>
/// <summary> Checks whether the language code for the current default Locale
/// is KOREAN.
///
/// </summary>
/// <returns> true if KOREAN, or false if not
/// </returns>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangKOR =
/// <summary> Checks whether the language code for the current default Locale
/// is KOREAN.
///
/// </summary>
/// <returns> true if KOREAN, or false if not
/// </returns>
/**
* @return {?}
*/
function () {
return UtilStrByteMode._bLocaleDefLangKOR;
};
/**
* @param {?} c
* @return {?}
*/
UtilStrByteMode.isKoreanCharacter = /**
* @param {?} c
* @return {?}
*/
function (c) {
return (44032 <= /*'가'*/ c && c <= 55203 /*'힣'*/) || (4352 <= /*'ᄀ'*/ c && c <= 4607 /*'ᇿ'*/) || (12592 <= /*''*/ c && c <= 12687 /*''*/) || (43360 <= /*'ꥠ'*/ c && c <= 43391 /*''*/) || (55216 <= /*'ힰ'*/ c && c <= 55295 /*''*/);
};
/// <summary> Length of String
/// Returns the number of bytes (in default encoding).
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <returns> the number of bytes (in default encoding)
///
/// Example: lenB("abXYc")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 7.
/// </returns>
/// <summary> Length of String
/// Returns the number of bytes (in default encoding).
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <returns> the number of bytes (in default encoding)
///
/// Example: lenB("abXYc")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 7.
/// </returns>
/**
* @param {?} strVal
* @return {?}
*/
UtilStrByteMode.lenB =
/// <summary> Length of String
/// Returns the number of bytes (in default encoding).
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <returns> the number of bytes (in default encoding)
///
/// Example: lenB("abXYc")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 7.
/// </returns>
/**
* @param {?} strVal
* @return {?}
*/
function (strVal) {
// convert to byte[] by default-encoding
return UtilStrByteMode.Encoding.GetByteCount(strVal);
};
/// <summary> Substring of String
/// Extracts a specified number of characters (a substring) from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">starting position (byte) of the substring
/// </param>
/// <param name="len:">number of bytes to be extracted (i.e. bytes of substring)
/// </param>
/// <returns> substring
///
/// Example: midB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "bX ".
/// </returns>
/// <summary> Substring of String
/// Extracts a specified number of characters (a substring) from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">starting position (byte) of the substring
/// </param>
/// <param name="len:">number of bytes to be extracted (i.e. bytes of substring)
/// </param>
/// <returns> substring
///
/// Example: midB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "bX ".
/// </returns>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.midB =
/// <summary> Substring of String
/// Extracts a specified number of characters (a substring) from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">starting position (byte) of the substring
/// </param>
/// <param name="len:">number of bytes to be extracted (i.e. bytes of substring)
/// </param>
/// <returns> substring
///
/// Example: midB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "bX ".
/// </returns>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strVal, ofs, len) {
/** @type {?} */
var intValidMaxIndex = -1;
// param #1 of substring
/** @type {?} */
var intValidMinIndex = -1;
// param #2 of substring
/** @type {?} */
var bHeadSpace = false;
// flag: need to add space
/** @type {?} */
var bEndSpace = false;
// flag: need to add space
/** @type {?} */
var strRet;
// check and modify ofs & len
if (len <= 0)
return "";
if (ofs <= 0) {
ofs = 0;
intValidMinIndex = 0;
bHeadSpace = false;
}
/** @type {?} */
var intByteLength = UtilStrByteMode.lenB(strVal);
if (intByteLength < ofs)
return "";
/** @type {?} */
var LenMax = intByteLength - ofs;
if (LenMax < len)
len = LenMax;
// set MinIndex and MaxIndex for substring
intByteLength = 0;
for (var intIndex = 0; intIndex < strVal.length; intIndex = intIndex + 1) {
/** @type {?} */
var s = strVal.substr(intIndex, 1);
intByteLength = intByteLength + UtilStrByteMode.Encoding.GetByteCount(s);
if (intValidMinIndex === -1) {
if (intByteLength === ofs) {
intValidMinIndex = intIndex + 1;
bHeadSpace = false;
}
else if (intByteLength > ofs) {
intValidMinIndex = intIndex + 1;
bHeadSpace = true;
}
}
if (intValidMaxIndex === -1) {
if (intByteLength === ofs + len) {
intValidMaxIndex = intIndex;
bEndSpace = false;
break;
}
else if (intByteLength > ofs + len) {
intValidMaxIndex = intIndex - 1;
bEndSpace = true;
break;
}
}
}
// prepare for substring
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder(len);
// execute Mid
if (bHeadSpace) {
strbufAddingBuf.Append(' ');
}
if (intValidMinIndex <= intValidMaxIndex) {
strbufAddingBuf.Append(strVal.substr(intValidMinIndex, intValidMaxIndex + 1 - intValidMinIndex));
}
if (bEndSpace) {
strbufAddingBuf.Append(' ');
}
strRet = strbufAddingBuf.ToString();
strbufAddingBuf = null;
return strRet;
};
/// <summary> Get Characters from Left of String
/// Returns a specified number of bytes from the left side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: leftB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "abX".
/// </returns>
/// <summary> Get Characters from Left of String
/// Returns a specified number of bytes from the left side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: leftB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "abX".
/// </returns>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
UtilStrByteMode.leftB =
/// <summary> Get Characters from Left of String
/// Returns a specified number of bytes from the left side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: leftB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "abX".
/// </returns>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
function (strVal, len) {
return UtilStrByteMode.midB(strVal, 0, len);
};
/// <summary> Get Characters from Right of String
/// Returns a specified number of bytes from the right side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: rightB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// " Yc".
/// </returns>
/// <summary> Get Characters from Right of String
/// Returns a specified number of bytes from the right side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: rightB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// " Yc".
/// </returns>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
UtilStrByteMode.rightB =
/// <summary> Get Characters from Right of String
/// Returns a specified number of bytes from the right side of a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="len:">number of bytes to be retured
/// </param>
/// <returns> output string
///
/// Example: rightB("abXYc", 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// " Yc".
/// </returns>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
function (strVal, len) {
/** @type {?} */
var byteFldsValLen = UtilStrByteMode.lenB(strVal);
if (len < 0) {
len = 0;
}
/** @type {?} */
var ofs = byteFldsValLen - len;
if (ofs < 0) {
ofs = 0;
}
return UtilStrByteMode.midB(strVal, ofs, len);
};
/// <summary> Insert String
/// Inserts one string into another.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">A string that represents the target string.
/// </param>
/// <param name="strSource:">A string that represents the source string.
/// </param>
/// <param name="ofs:">A number that represents the starting position (byte) in
/// the target.
/// </param>
/// <param name="len:">A number that represents the number of bytes from the
/// source that will be inserted into the target.
/// </param>
/// <returns> output string
///
/// Example: insB("abXYc", "de", 4, 1)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab d Yc".
/// </returns>
/// <summary> Insert String
/// Inserts one string into another.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">A string that represents the target string.
/// </param>
/// <param name="strSource:">A string that represents the source string.
/// </param>
/// <param name="ofs:">A number that represents the starting position (byte) in
/// the target.
/// </param>
/// <param name="len:">A number that represents the number of bytes from the
/// source that will be inserted into the target.
/// </param>
/// <returns> output string
///
/// Example: insB("abXYc", "de", 4, 1)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab d Yc".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strSource
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.insB =
/// <summary> Insert String
/// Inserts one string into another.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">A string that represents the target string.
/// </param>
/// <param name="strSource:">A string that represents the source string.
/// </param>
/// <param name="ofs:">A number that represents the starting position (byte) in
/// the target.
/// </param>
/// <param name="len:">A number that represents the number of bytes from the
/// source that will be inserted into the target.
/// </param>
/// <returns> output string
///
/// Example: insB("abXYc", "de", 4, 1)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab d Yc".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strSource
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strSource, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
/** @type {?} */
var intTargetLenB = UtilStrByteMode.lenB(strTarget);
/** @type {?} */
var intSourceLenB = UtilStrByteMode.lenB(strSource);
/** @type {?} */
var strbufRetVal = new mscorelib.StringBuilder(ofs + len);
strbufRetVal.Append(UtilStrByteMode.leftB(strTarget, ofs));
for (var intAddSpaceLen = ofs - intTargetLenB; intAddSpaceLen > 0; intAddSpaceLen = intAddSpaceLen - 1) {
strbufRetVal.Append(' ');
}
strbufRetVal.Append(UtilStrByteMode.leftB(strSource, len));
for (var i = len - intSourceLenB; i > 0; i = i - 1) {
strbufRetVal.Append(' ');
}
strbufRetVal.Append(UtilStrByteMode.rightB(strTarget, intTargetLenB - ofs));
return strbufRetVal.ToString();
};
/// <summary> Delete Characters
/// Delete characters from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">The position (byte) of the first character to be deleted.
/// </param>
/// <param name="len:">The number of characters to be deleted, beginning with
/// position start and proceeding rightward.
/// </param>
/// <returns> output string
///
/// Example: delB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "a c".
/// </returns>
/// <summary> Delete Characters
/// Delete characters from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">The position (byte) of the first character to be deleted.
/// </param>
/// <param name="len:">The number of characters to be deleted, beginning with
/// position start and proceeding rightward.
/// </param>
/// <returns> output string
///
/// Example: delB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "a c".
/// </returns>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.delB =
/// <summary> Delete Characters
/// Delete characters from a string.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <param name="ofs:">The position (byte) of the first character to be deleted.
/// </param>
/// <param name="len:">The number of characters to be deleted, beginning with
/// position start and proceeding rightward.
/// </param>
/// <returns> output string
///
/// Example: delB("abXYc", 2, 4)
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// "a c".
/// </returns>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strVal, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
/** @type {?} */
var intValLenB = UtilStrByteMode.lenB(strVal);
if (ofs + len > intValLenB) {
len = intValLenB - ofs;
}
/** @type {?} */
var strRet;
if (len <= 0) {
strRet = strVal;
}
else {
/** @type {?} */
var intRightSideLenB = intValLenB - ofs - len;
if (intRightSideLenB < 0) {
strRet = strVal;
}
else {
/** @type {?} */
var strbufRetVal = new mscorelib.StringBuilder(ofs + intRightSideLenB);
strbufRetVal.Append(UtilStrByteMode.leftB(strVal, ofs));
strbufRetVal.Append(UtilStrByteMode.rightB(strVal, intRightSideLenB));
strRet = strbufRetVal.ToString();
}
}
return strRet;
};
/// <summary> In-String Search
/// Returns a number that represents the first position (byte) of a
/// substring within a string.
///
/// </summary>
/// <param name="strTarget:">string (in Unicode)
/// </param>
/// <param name="strSearch:">string which will be the search argument in string
/// </param>
/// <returns> number, 0 if not found
///
/// Example: instrB("abXYc", "Y")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 5.
/// </returns>
/// <summary> In-String Search
/// Returns a number that represents the first position (byte) of a
/// substring within a string.
///
/// </summary>
/// <param name="strTarget:">string (in Unicode)
/// </param>
/// <param name="strSearch:">string which will be the search argument in string
/// </param>
/// <returns> number, 0 if not found
///
/// Example: instrB("abXYc", "Y")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 5.
/// </returns>
/**
* @param {?} strTarget
* @param {?} strSearch
* @return {?}
*/
UtilStrByteMode.instrB =
/// <summary> In-String Search
/// Returns a number that represents the first position (byte) of a
/// substring within a string.
///
/// </summary>
/// <param name="strTarget:">string (in Unicode)
/// </param>
/// <param name="strSearch:">string which will be the search argument in string
/// </param>
/// <returns> number, 0 if not found
///
/// Example: instrB("abXYc", "Y")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 5.
/// </returns>
/**
* @param {?} strTarget
* @param {?} strSearch
* @return {?}
*/
function (strTarget, strSearch) {
if (strSearch.length === 0) {
// nothing to look for
return 0;
}
/** @type {?} */
var ofs = strTarget.indexOf(strSearch);
if (ofs < 0) {
// not found
return 0;
}
return UtilStrByteMode.lenB(strTarget.substr(0, ofs)) + 1;
};
/// <summary> Replace Substring Within a String (Byte Mode)
/// Replaces a substring within a string with another substring.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (byte) in the target string that will
/// receive the substring from origin.
/// </param>
/// <param name="len:">the number of bytes that will be moved from origin to
/// target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab de c".
/// </returns>
/// <summary> Replace Substring Within a String (Byte Mode)
/// Replaces a substring within a string with another substring.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (byte) in the target string that will
/// receive the substring from origin.
/// </param>
/// <param name="len:">the number of bytes that will be moved from origin to
/// target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab de c".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.repB =
/// <summary> Replace Substring Within a String (Byte Mode)
/// Replaces a substring within a string with another substring.
/// If a DBCS character is divided in two, it will be replace to a space.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (byte) in the target string that will
/// receive the substring from origin.
/// </param>
/// <param name="len:">the number of bytes that will be moved from origin to
/// target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
/// it returns "ab de c".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strOrigin, ofs, len) {
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder();
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
strbufAddingBuf.Append(UtilStrByteMode.leftB(strTarget, ofs));
/** @type {?} */
var intAddSpaceLen = ofs - UtilStrByteMode.lenB(strTarget);
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(UtilStrByteMode.leftB(strOrigin, len));
/** @type {?} */
var intRightLen = UtilStrByteMode.lenB(strTarget) - (ofs + len);
if (intRightLen > 0) {
strbufAddingBuf.Append(UtilStrByteMode.rightB(strTarget, intRightLen));
}
// add blanks to the end
intAddSpaceLen = len - UtilStrByteMode.lenB(strOrigin);
for (; intAddSpaceLen > 0; intAddSpaceLen--) {
strbufAddingBuf.Append(' ');
}
return strbufAddingBuf.ToString();
};
/// <summary> Replace Substring Within a String (Character Mode)
/// Replaces a substring within a string with another substring.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (character) in the target string that
/// will receive the substring from origin.
/// </param>
/// <param name="len:">the number of characters that will be moved from origin
/// to target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Whether each character is SBCS or DBCS, it returns "abXde".
/// </returns>
/// <summary> Replace Substring Within a String (Character Mode)
/// Replaces a substring within a string with another substring.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (character) in the target string that
/// will receive the substring from origin.
/// </param>
/// <param name="len:">the number of characters that will be moved from origin
/// to target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Whether each character is SBCS or DBCS, it returns "abXde".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.repC =
/// <summary> Replace Substring Within a String (Character Mode)
/// Replaces a substring within a string with another substring.
///
/// </summary>
/// <param name="strTarget:">target string where the replacement will take place.
/// </param>
/// <param name="strOrigin:">string that provides the substring to be copied to
/// target.
/// </param>
/// <param name="ofs:">the first position (character) in the target string that
/// will receive the substring from origin.
/// </param>
/// <param name="len:">the number of characters that will be moved from origin
/// to target, starting from the leftmost character of origin.
/// </param>
/// <returns> string containing modified target string
///
/// Example: repB("abXYc", "de", 4, 2)
/// Whether each character is SBCS or DBCS, it returns "abXde".
/// </returns>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strOrigin, ofs, len) {
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder();
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
strbufAddingBuf.Append(strTarget.substr(0, ofs));
// add blanks between strTarget and strOrigin
/** @type {?} */
var intAddSpaceLen = ofs - strTarget.length;
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(strOrigin.substr(0, len));
/** @type {?} */
var intRightLen = strTarget.length - (ofs + len);
if (intRightLen > 0) {
strbufAddingBuf.Append(strTarget.substr(ofs + len));
}
for (var i = len - strOrigin.length; i > 0; i = i - 1) {
strbufAddingBuf.Append(' ');
}
return strbufAddingBuf.ToString();
};
/// <summary> Checks whether a character is 1 byte (halfwidth) or not (fullwidth)
/// Returns true if the character is represented by 1 byte in non-Unicode
/// encoding.
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth (SBCS), or false if it is
/// fullwidth (DBCS).
/// </returns>
/// <summary> Checks whether a character is 1 byte (halfwidth) or not (fullwidth)
/// Returns true if the character is represented by 1 byte in non-Unicode
/// encoding.
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth (SBCS), or false if it is
/// fullwidth (DBCS).
/// </returns>
/**
* @param {?} str
* @return {?}
*/
UtilStrByteMode.isHalfWidth =
/// <summary> Checks whether a character is 1 byte (halfwidth) or not (fullwidth)
/// Returns true if the character is represented by 1 byte in non-Unicode
/// encoding.
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth (SBCS), or false if it is
/// fullwidth (DBCS).
/// </returns>
/**
* @param {?} str
* @return {?}
*/
function (str) {
/** @type {?} */
var letter = str.charCodeAt(0);
if (32 <= /*' '*/ letter && letter <= 126 /*'~'*/) {
return true;
}
else {
/** @type {?} */
var len = UtilStrByteMode.lenB(str);
if (len === 1)
return true;
}
return false;
};
/// <summary> Checks whether a character is halfwidth digit letter
/// Do not use "Character.isDigit" which cannot distinguish between
/// halfwidth digit letter(SBCS) and fullwidth difit letter(DBCS).
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/// <summary> Checks whether a character is halfwidth digit letter
/// Do not use "Character.isDigit" which cannot distinguish between
/// halfwidth digit letter(SBCS) and fullwidth difit letter(DBCS).
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/**
* @param {?} letter
* @return {?}
*/
UtilStrByteMode.isDigit =
/// <summary> Checks whether a character is halfwidth digit letter
/// Do not use "Character.isDigit" which cannot distinguish between
/// halfwidth digit letter(SBCS) and fullwidth difit letter(DBCS).
/// </summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/**
* @param {?} letter
* @return {?}
*/
function (letter) {
return 48 <= /*'0'*/ letter.charCodeAt(0) && letter.charCodeAt(0) <= 57 /*'9'*/;
};
/// <summary>Checks whether a character is one of those supported for # Alpha Mask</summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/// <summary>Checks whether a character is one of those supported for # Alpha Mask</summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/**
* @param {?} letter
* @return {?}
*/
UtilStrByteMode.asNumeric =
/// <summary>Checks whether a character is one of those supported for # Alpha Mask</summary>
/// <param name="letter:">a character to be checked.
/// </param>
/// <returns> true if the character is halfwidth digit letter, or
/// false if it is DBCS or not digit letter.
/// </returns>
/**
* @param {?} letter
* @return {?}
*/
function (letter) {
/** @type {?} */
var result;
switch (letter.charCodeAt(0)) {
case 42: /*'*'*/
case 43: /*'+'*/
case 44: /*','*/
case 45: /*'-'*/
case 46: /*'.'*/
case 47:/*'/'*/
result = true;
break;
default:
result = false;
break;
}
return result;
};
/// <summary> Converts a position for the 1st string (Source) to a position for
/// the 2nd string (Dest).
/// If a double byte character exists in the strings, the position for the
/// Source could be different from the position for the Dest.
/// (DBCS Support)
///
/// </summary>
/// <param name="strSource:">Source string
/// </param>
/// <param name="strDest:">Dest string
/// </param>
/// <param name="pos:">position in the Source string
/// </param>
/// <param name="isAdvance:">advance or retreat the ret pos if a DBCS char is split
/// </param>
/// <returns> position in the Dest string
///
/// Example: convPos("abcYZ", "YZabc", 4)
/// It returns 4, if the all characters in the strings are SBCS.
///
/// If 'a', 'b' and 'c' are SBCS, and 'Y' and 'Z' are DBCS, it
/// returns 3.
/// pos
/// Unicode index 0 1 2 3 [4]
/// +-------------+
/// Source string |a|b|c| Y | Z |
/// +-------------+
/// ANSI index 0 1 2 3 4[5]6
/// +-------------+
/// Dest string | Y | Z |a|b|c|
/// +-------------+
/// Unicode index 0 1 2[3]4
/// ret
/// </returns>
/// <summary> Converts a position for the 1st string (Source) to a position for
/// the 2nd string (Dest).
/// If a double byte character exists in the strings, the position for the
/// Source could be different from the position for the Dest.
/// (DBCS Support)
///
/// </summary>
/// <param name="strSource:">Source string
/// </param>
/// <param name="strDest:">Dest string
/// </param>
/// <param name="pos:">position in the Source string
/// </param>
/// <param name="isAdvance:">advance or retreat the ret pos if a DBCS char is split
/// </param>
/// <returns> position in the Dest string
///
/// Example: convPos("abcYZ", "YZabc", 4)
/// It returns 4, if the all characters in the strings are SBCS.
///
/// If 'a', 'b' and 'c' are SBCS, and 'Y' and 'Z' are DBCS, it
/// returns 3.
/// pos
/// Unicode index 0 1 2 3 [4]
/// +-------------+
/// Source string |a|b|c| Y | Z |
/// +-------------+
/// ANSI index 0 1 2 3 4[5]6
/// +-------------+
/// Dest string | Y | Z |a|b|c|
/// +-------------+
/// Unicode index 0 1 2[3]4
/// ret
/// </returns>
/**
* @param {?} strSource
* @param {?} strDest
* @param {?} pos
* @param {?} isAdvance
* @return {?}
*/
UtilStrByteMode.convPos =
/// <summary> Converts a position for the 1st string (Source) to a position for
/// the 2nd string (Dest).
/// If a double byte character exists in the strings, the position for the
/// Source could be different from the position for the Dest.
/// (DBCS Support)
///
/// </summary>
/// <param name="strSource:">Source string
/// </param>
/// <param name="strDest:">Dest string
/// </param>
/// <param name="pos:">position in the Source string
/// </param>
/// <param name="isAdvance:">advance or retreat the ret pos if a DBCS char is split
/// </param>
/// <returns> position in the Dest string
///
/// Example: convPos("abcYZ", "YZabc", 4)
/// It returns 4, if the all characters in the strings are SBCS.
///
/// If 'a', 'b' and 'c' are SBCS, and 'Y' and 'Z' are DBCS, it
/// returns 3.
/// pos
/// Unicode index 0 1 2 3 [4]
/// +-------------+
/// Source string |a|b|c| Y | Z |
/// +-------------+
/// ANSI index 0 1 2 3 4[5]6
/// +-------------+
/// Dest string | Y | Z |a|b|c|
/// +-------------+
/// Unicode index 0 1 2[3]4
/// ret
/// </returns>
/**
* @param {?} strSource
* @param {?} strDest
* @param {?} pos
* @param {?} isAdvance
* @return {?}
*/
function (strSource, strDest, pos, isAdvance) {
/** @type {?} */
var retPos;
if (pos < 0)
return 0;
if (pos > strSource.length)
pos = strSource.length;
// add blanks to the Dest string if it is shorter than the Src string
/** @type {?} */
var diffLen = UtilStrByteMode.lenB(strSource) - UtilStrByteMode.lenB(strDest);
if (diffLen > 0) {
/** @type {?} */
var stringBuilder = new mscorelib.StringBuilder(strDest);
for (; diffLen > 0; diffLen--)