475 lines
22 KiB
C#
475 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace XYLEM.Base {
|
|
#region ---- SMS Char Convert ----
|
|
|
|
internal class UniCode {
|
|
internal UInt32 Value { get; set; }
|
|
internal char Ch {
|
|
get { return (char)Value; }
|
|
set { Value = (UInt32)value; }
|
|
}
|
|
|
|
internal string InfoTxt { get; set; }
|
|
public UniCode(UInt32 value, string infoTxt) {
|
|
Value = value;
|
|
InfoTxt = infoTxt;
|
|
}
|
|
|
|
public override string ToString( ) {
|
|
return String.Format( "\"{0}\"=0x{1x} ({2})", (char)Value, Value, InfoTxt );
|
|
}
|
|
}
|
|
|
|
// Look at /DOC/Siemens MC55i GSM-charset.pdf
|
|
// And http://www.unicode.org/Public/MAPPINGS/ETSI/GSM0338.TXT
|
|
static class StringConvertToSMSClass {
|
|
readonly static Dictionary<byte[], UniCode> ConvTable = new Dictionary<byte[], UniCode>( ){
|
|
//{ new Byte[]{0x00}, new UniCode( 0x0040 , "COMMERCIAL AT") }, TMO NOT IN USE
|
|
{ new Byte[]{0x40}, new UniCode( 0x0040, "@ Converted to \"INVERTED EXCLAMATION MARK\", Device then TX \"0x00\"") },
|
|
//{ new Byte[]{0x40}, new UniCode( 0x00A1 , "INVERTED EXCLAMATION MARK") }, TMO NOT IN USE
|
|
{ new Byte[]{0x21,0x2A}, new UniCode( 0x00A1 , "INVERTED EXCLAMATION MARK to \"!*\"") },
|
|
{ new Byte[]{0x00}, new UniCode( 0x0000 , "NULL (see note above)") },
|
|
{ new Byte[]{0x01}, new UniCode( 0x00A3 , "POUND SIGN") },
|
|
{ new Byte[]{0x02}, new UniCode( 0x0024 , "DOLLAR SIGN") },
|
|
{ new Byte[]{0x03}, new UniCode( 0x00A5 , "YEN SIGN") },
|
|
{ new Byte[]{0x04}, new UniCode( 0x00E8 , "LATIN SMALL LETTER E WITH GRAVE") },
|
|
{ new Byte[]{0x05}, new UniCode( 0x00E9 , "LATIN SMALL LETTER E WITH ACUTE") },
|
|
{ new Byte[]{0x06}, new UniCode( 0x00F9 , "LATIN SMALL LETTER U WITH GRAVE") },
|
|
{ new Byte[]{0x07}, new UniCode( 0x00EC , "LATIN SMALL LETTER I WITH GRAVE") },
|
|
{ new Byte[]{0x08}, new UniCode( 0x00F2 , "LATIN SMALL LETTER O WITH GRAVE") },
|
|
{ new Byte[]{0x09}, new UniCode( 0x00E7 , "LATIN SMALL LETTER C WITH CEDILLA") },
|
|
{ new Byte[]{0x09}, new UniCode( 0x00C7 , "LATIN CAPITAL LETTER C WITH CEDILLA (see note above)") },
|
|
{ new Byte[]{0x0A}, new UniCode( 0x000A , "LINE FEED") },
|
|
{ new Byte[]{0x0B}, new UniCode( 0x00D8 , "LATIN CAPITAL LETTER O WITH STROKE") },
|
|
{ new Byte[]{0x0C}, new UniCode( 0x00F8 , "LATIN SMALL LETTER O WITH STROKE") },
|
|
{ new Byte[]{0x0D}, new UniCode( 0x000D , "CARRIAGE RETURN") },
|
|
{ new Byte[]{0x0E}, new UniCode( 0x00C5 , "LATIN CAPITAL LETTER A WITH RING ABOVE") },
|
|
{ new Byte[]{0x0F}, new UniCode( 0x00E5 , "LATIN SMALL LETTER A WITH RING ABOVE") },
|
|
{ new Byte[]{0x10}, new UniCode( 0x0394 , "GREEK CAPITAL LETTER DELTA") },
|
|
{ new Byte[]{0x11}, new UniCode( 0x005F , "LOW LINE") },
|
|
{ new Byte[]{0x12}, new UniCode( 0x03A6 , "GREEK CAPITAL LETTER PHI") },
|
|
{ new Byte[]{0x13}, new UniCode( 0x0393 , "GREEK CAPITAL LETTER GAMMA") },
|
|
{ new Byte[]{0x14}, new UniCode( 0x039B , "GREEK CAPITAL LETTER LAMDA") },
|
|
{ new Byte[]{0x15}, new UniCode( 0x03A9 , "GREEK CAPITAL LETTER OMEGA") },
|
|
{ new Byte[]{0x16}, new UniCode( 0x03A0 , "GREEK CAPITAL LETTER PI") },
|
|
{ new Byte[]{0x17}, new UniCode( 0x03A8 , "GREEK CAPITAL LETTER PSI") },
|
|
{ new Byte[]{0x18}, new UniCode( 0x03A3 , "GREEK CAPITAL LETTER SIGMA") },
|
|
{ new Byte[]{0x19}, new UniCode( 0x0398 , "GREEK CAPITAL LETTER THETA") },
|
|
{ new Byte[]{0x1A}, new UniCode( 0x039E , "GREEK CAPITAL LETTER XI") },
|
|
{ new Byte[]{0x1B}, new UniCode( 0x00A0 , "ESCAPE TO EXTENSION TABLE (or displayed as NBSP, see note above)") },
|
|
{ new Byte[]{0x1B,0x0A}, new UniCode( 0x000C , "FORM FEED") },
|
|
{ new Byte[]{0x1B,0x14}, new UniCode( 0x005E , "CIRCUMFLEX ACCENT") },
|
|
{ new Byte[]{0x1B,0x28}, new UniCode( 0x007B , "LEFT CURLY BRACKET") },
|
|
{ new Byte[]{0x1B,0x29}, new UniCode( 0x007D , "RIGHT CURLY BRACKET") },
|
|
{ new Byte[]{0x1B,0x2F}, new UniCode( 0x005C , "REVERSE SOLIDUS") },
|
|
{ new Byte[]{0x1B,0x3C}, new UniCode( 0x005B , "LEFT SQUARE BRACKET") },
|
|
{ new Byte[]{0x1B,0x3D}, new UniCode( 0x007E , "TILDE") },
|
|
{ new Byte[]{0x1B,0x3E}, new UniCode( 0x005D , "RIGHT SQUARE BRACKET") },
|
|
{ new Byte[]{0x1B,0x40}, new UniCode( 0x007C , "VERTICAL LINE") },
|
|
{ new Byte[]{0x1B,0x65}, new UniCode( 0x20AC , "EURO SIGN") },
|
|
{ new Byte[]{0x1C}, new UniCode( 0x00C6 , "LATIN CAPITAL LETTER AE") },
|
|
{ new Byte[]{0x1D}, new UniCode( 0x00E6 , "LATIN SMALL LETTER AE") },
|
|
{ new Byte[]{0x1E}, new UniCode( 0x00DF , "LATIN SMALL LETTER SHARP S (German)") },
|
|
{ new Byte[]{0x1F}, new UniCode( 0x00C9 , "LATIN CAPITAL LETTER E WITH ACUTE") },
|
|
{ new Byte[]{0x20}, new UniCode( 0x0020 , "SPACE") },
|
|
{ new Byte[]{0x21}, new UniCode( 0x0021 , "EXCLAMATION MARK") },
|
|
{ new Byte[]{0x22}, new UniCode( 0x0022 , "QUOTATION MARK") },
|
|
{ new Byte[]{0x23}, new UniCode( 0x0023 , "NUMBER SIGN") },
|
|
{ new Byte[]{0x24}, new UniCode( 0x00A4 , "CURRENCY SIGN") },
|
|
{ new Byte[]{0x25}, new UniCode( 0x0025 , "PERCENT SIGN") },
|
|
{ new Byte[]{0x26}, new UniCode( 0x0026 , "AMPERSAND") },
|
|
{ new Byte[]{0x27}, new UniCode( 0x0027 , "APOSTROPHE") },
|
|
{ new Byte[]{0x28}, new UniCode( 0x0028 , "LEFT PARENTHESIS") },
|
|
{ new Byte[]{0x29}, new UniCode( 0x0029 , "RIGHT PARENTHESIS") },
|
|
{ new Byte[]{0x2A}, new UniCode( 0x002A , "ASTERISK") },
|
|
{ new Byte[]{0x2B}, new UniCode( 0x002B , "PLUS SIGN") },
|
|
{ new Byte[]{0x2C}, new UniCode( 0x002C , "COMMA") },
|
|
{ new Byte[]{0x2D}, new UniCode( 0x002D , "HYPHEN-MINUS") },
|
|
{ new Byte[]{0x2E}, new UniCode( 0x002E , "FULL STOP") },
|
|
{ new Byte[]{0x2F}, new UniCode( 0x002F , "SOLIDUS") },
|
|
{ new Byte[]{0x30}, new UniCode( 0x0030 , "DIGIT ZERO") },
|
|
{ new Byte[]{0x31}, new UniCode( 0x0031 , "DIGIT ONE") },
|
|
{ new Byte[]{0x32}, new UniCode( 0x0032 , "DIGIT TWO") },
|
|
{ new Byte[]{0x33}, new UniCode( 0x0033 , "DIGIT THREE") },
|
|
{ new Byte[]{0x34}, new UniCode( 0x0034 , "DIGIT FOUR") },
|
|
{ new Byte[]{0x35}, new UniCode( 0x0035 , "DIGIT FIVE") },
|
|
{ new Byte[]{0x36}, new UniCode( 0x0036 , "DIGIT SIX") },
|
|
{ new Byte[]{0x37}, new UniCode( 0x0037 , "DIGIT SEVEN") },
|
|
{ new Byte[]{0x38}, new UniCode( 0x0038 , "DIGIT EIGHT") },
|
|
{ new Byte[]{0x39}, new UniCode( 0x0039 , "DIGIT NINE") },
|
|
{ new Byte[]{0x3A}, new UniCode( 0x003A , "COLON") },
|
|
{ new Byte[]{0x3B}, new UniCode( 0x003B , "SEMICOLON") },
|
|
{ new Byte[]{0x3C}, new UniCode( 0x003C , "LESS-THAN SIGN") },
|
|
{ new Byte[]{0x3D}, new UniCode( 0x003D , "EQUALS SIGN") },
|
|
{ new Byte[]{0x3E}, new UniCode( 0x003E , "GREATER-THAN SIGN") },
|
|
{ new Byte[]{0x3F}, new UniCode( 0x003F , "QUESTION MARK") },
|
|
|
|
{ new Byte[]{0x41}, new UniCode( 0x0041 , "LATIN CAPITAL LETTER A") },
|
|
{ new Byte[]{0x41}, new UniCode( 0x0391 , "GREEK CAPITAL LETTER ALPHA") },
|
|
{ new Byte[]{0x42}, new UniCode( 0x0042 , "LATIN CAPITAL LETTER B") },
|
|
{ new Byte[]{0x42}, new UniCode( 0x0392 , "GREEK CAPITAL LETTER BETA") },
|
|
{ new Byte[]{0x43}, new UniCode( 0x0043 , "LATIN CAPITAL LETTER C") },
|
|
{ new Byte[]{0x44}, new UniCode( 0x0044 , "LATIN CAPITAL LETTER D") },
|
|
{ new Byte[]{0x45}, new UniCode( 0x0045 , "LATIN CAPITAL LETTER E") },
|
|
{ new Byte[]{0x45}, new UniCode( 0x0395 , "GREEK CAPITAL LETTER EPSILON") },
|
|
{ new Byte[]{0x46}, new UniCode( 0x0046 , "LATIN CAPITAL LETTER F") },
|
|
{ new Byte[]{0x47}, new UniCode( 0x0047 , "LATIN CAPITAL LETTER G") },
|
|
{ new Byte[]{0x48}, new UniCode( 0x0048 , "LATIN CAPITAL LETTER H") },
|
|
{ new Byte[]{0x48}, new UniCode( 0x0397 , "GREEK CAPITAL LETTER ETA") },
|
|
{ new Byte[]{0x49}, new UniCode( 0x0049 , "LATIN CAPITAL LETTER I") },
|
|
{ new Byte[]{0x49}, new UniCode( 0x0399 , "GREEK CAPITAL LETTER IOTA") },
|
|
{ new Byte[]{0x4A}, new UniCode( 0x004A , "LATIN CAPITAL LETTER J") },
|
|
{ new Byte[]{0x4B}, new UniCode( 0x004B , "LATIN CAPITAL LETTER K") },
|
|
{ new Byte[]{0x4B}, new UniCode( 0x039A , "GREEK CAPITAL LETTER KAPPA") },
|
|
{ new Byte[]{0x4C}, new UniCode( 0x004C , "LATIN CAPITAL LETTER L") },
|
|
{ new Byte[]{0x4D}, new UniCode( 0x004D , "LATIN CAPITAL LETTER M") },
|
|
{ new Byte[]{0x4D}, new UniCode( 0x039C , "GREEK CAPITAL LETTER MU") },
|
|
{ new Byte[]{0x4E}, new UniCode( 0x004E , "LATIN CAPITAL LETTER N") },
|
|
{ new Byte[]{0x4E}, new UniCode( 0x039D , "GREEK CAPITAL LETTER NU") },
|
|
{ new Byte[]{0x4F}, new UniCode( 0x004F , "LATIN CAPITAL LETTER O") },
|
|
{ new Byte[]{0x4F}, new UniCode( 0x039F , "GREEK CAPITAL LETTER OMICRON") },
|
|
{ new Byte[]{0x50}, new UniCode( 0x0050 , "LATIN CAPITAL LETTER P") },
|
|
{ new Byte[]{0x50}, new UniCode( 0x03A1 , "GREEK CAPITAL LETTER RHO") },
|
|
{ new Byte[]{0x51}, new UniCode( 0x0051 , "LATIN CAPITAL LETTER Q") },
|
|
{ new Byte[]{0x52}, new UniCode( 0x0052 , "LATIN CAPITAL LETTER R") },
|
|
{ new Byte[]{0x53}, new UniCode( 0x0053 , "LATIN CAPITAL LETTER S") },
|
|
{ new Byte[]{0x54}, new UniCode( 0x0054 , "LATIN CAPITAL LETTER T") },
|
|
{ new Byte[]{0x54}, new UniCode( 0x03A4 , "GREEK CAPITAL LETTER TAU") },
|
|
{ new Byte[]{0x55}, new UniCode( 0x0055 , "LATIN CAPITAL LETTER U") },
|
|
{ new Byte[]{0x56}, new UniCode( 0x0056 , "LATIN CAPITAL LETTER V") },
|
|
{ new Byte[]{0x57}, new UniCode( 0x0057 , "LATIN CAPITAL LETTER W") },
|
|
{ new Byte[]{0x58}, new UniCode( 0x0058 , "LATIN CAPITAL LETTER X") },
|
|
{ new Byte[]{0x58}, new UniCode( 0x03A7 , "GREEK CAPITAL LETTER CHI") },
|
|
{ new Byte[]{0x59}, new UniCode( 0x0059 , "LATIN CAPITAL LETTER Y") },
|
|
{ new Byte[]{0x59}, new UniCode( 0x03A5 , "GREEK CAPITAL LETTER UPSILON") },
|
|
{ new Byte[]{0x5A}, new UniCode( 0x005A , "LATIN CAPITAL LETTER Z") },
|
|
{ new Byte[]{0x5A}, new UniCode( 0x0396 , "GREEK CAPITAL LETTER ZETA") },
|
|
{ new Byte[]{0x5B}, new UniCode( 0x00C4 , "LATIN CAPITAL LETTER A WITH DIAERESIS") },
|
|
{ new Byte[]{0x5C}, new UniCode( 0x00D6 , "LATIN CAPITAL LETTER O WITH DIAERESIS") },
|
|
{ new Byte[]{0x5D}, new UniCode( 0x00D1 , "LATIN CAPITAL LETTER N WITH TILDE") },
|
|
{ new Byte[]{0x5E}, new UniCode( 0x00DC , "LATIN CAPITAL LETTER U WITH DIAERESIS") },
|
|
{ new Byte[]{0x5F}, new UniCode( 0x00A7 , "SECTION SIGN") },
|
|
{ new Byte[]{0x60}, new UniCode( 0x00BF , "INVERTED QUESTION MARK") },
|
|
{ new Byte[]{0x61}, new UniCode( 0x0061 , "LATIN SMALL LETTER A") },
|
|
{ new Byte[]{0x62}, new UniCode( 0x0062 , "LATIN SMALL LETTER B") },
|
|
{ new Byte[]{0x63}, new UniCode( 0x0063 , "LATIN SMALL LETTER C") },
|
|
{ new Byte[]{0x64}, new UniCode( 0x0064 , "LATIN SMALL LETTER D") },
|
|
{ new Byte[]{0x65}, new UniCode( 0x0065 , "LATIN SMALL LETTER E") },
|
|
{ new Byte[]{0x66}, new UniCode( 0x0066 , "LATIN SMALL LETTER F") },
|
|
{ new Byte[]{0x67}, new UniCode( 0x0067 , "LATIN SMALL LETTER G") },
|
|
{ new Byte[]{0x68}, new UniCode( 0x0068 , "LATIN SMALL LETTER H") },
|
|
{ new Byte[]{0x69}, new UniCode( 0x0069 , "LATIN SMALL LETTER I") },
|
|
{ new Byte[]{0x6A}, new UniCode( 0x006A , "LATIN SMALL LETTER J") },
|
|
{ new Byte[]{0x6B}, new UniCode( 0x006B , "LATIN SMALL LETTER K") },
|
|
{ new Byte[]{0x6C}, new UniCode( 0x006C , "LATIN SMALL LETTER L") },
|
|
{ new Byte[]{0x6D}, new UniCode( 0x006D , "LATIN SMALL LETTER M") },
|
|
{ new Byte[]{0x6E}, new UniCode( 0x006E , "LATIN SMALL LETTER N") },
|
|
{ new Byte[]{0x6F}, new UniCode( 0x006F , "LATIN SMALL LETTER O") },
|
|
{ new Byte[]{0x70}, new UniCode( 0x0070 , "LATIN SMALL LETTER P") },
|
|
{ new Byte[]{0x71}, new UniCode( 0x0071 , "LATIN SMALL LETTER Q") },
|
|
{ new Byte[]{0x72}, new UniCode( 0x0072 , "LATIN SMALL LETTER R") },
|
|
{ new Byte[]{0x73}, new UniCode( 0x0073 , "LATIN SMALL LETTER S") },
|
|
{ new Byte[]{0x74}, new UniCode( 0x0074 , "LATIN SMALL LETTER T") },
|
|
{ new Byte[]{0x75}, new UniCode( 0x0075 , "LATIN SMALL LETTER U") },
|
|
{ new Byte[]{0x76}, new UniCode( 0x0076 , "LATIN SMALL LETTER V") },
|
|
{ new Byte[]{0x77}, new UniCode( 0x0077 , "LATIN SMALL LETTER W") },
|
|
{ new Byte[]{0x78}, new UniCode( 0x0078 , "LATIN SMALL LETTER X") },
|
|
{ new Byte[]{0x79}, new UniCode( 0x0079 , "LATIN SMALL LETTER Y") },
|
|
{ new Byte[]{0x7A}, new UniCode( 0x007A , "LATIN SMALL LETTER Z") },
|
|
{ new Byte[]{0x7B}, new UniCode( 0x00E4 , "LATIN SMALL LETTER A WITH DIAERESIS") },
|
|
{ new Byte[]{0x7C}, new UniCode( 0x00F6 , "LATIN SMALL LETTER O WITH DIAERESIS") },
|
|
{ new Byte[]{0x7D}, new UniCode( 0x00F1 , "LATIN SMALL LETTER N WITH TILDE") },
|
|
{ new Byte[]{0x7E}, new UniCode( 0x00FC , "LATIN SMALL LETTER U WITH DIAERESIS") },
|
|
{ new Byte[]{0x7F}, new UniCode( 0x00E0 , "LATIN SMALL LETTER A WITH GRAVE") },
|
|
};
|
|
|
|
readonly static string[][] ConvertCh = new string[][]{
|
|
new string[]{ "\r", ""},
|
|
new string[]{ Environment.NewLine, "\n"},
|
|
};
|
|
|
|
internal static string RemoveIllegalATCh(this string value) {
|
|
string ret = value;
|
|
foreach (string[] replaceTxt in ConvertCh) {
|
|
if (!String.IsNullOrEmpty( replaceTxt[ 0 ] )) {
|
|
ret = ret.Replace( replaceTxt[ 0 ], "" );
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
internal static string ReplaceIllegalATCh(this string value) {
|
|
string ret = value;
|
|
foreach (string[] replaceTxt in ConvertCh) {
|
|
if (!String.IsNullOrEmpty( replaceTxt[ 0 ] )) {
|
|
ret = ret.Replace( replaceTxt[ 0 ], replaceTxt[ 1 ] );
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
internal static UniCode[] GetUniCodes(this byte[] data) {
|
|
try {
|
|
List<UniCode> list = new List<UniCode>( );
|
|
for (int offset = 0; offset < data.Length; offset++) {
|
|
bool found = false;
|
|
// check if byte sequens is in convert table
|
|
foreach (var code in ConvTable) {
|
|
if (data[ offset ] == code.Key.First( )) {
|
|
if (code.Key.Length == 1) {
|
|
list.Add( code.Value );
|
|
found = true;
|
|
break;
|
|
// Check if it is a combination of to bytes
|
|
} else if ((code.Key.Length == 2) && (offset + 1 < data.Length) && (data[ offset + 1 ] == code.Key[ 1 ])) {
|
|
offset++;
|
|
list.Add( code.Value );
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
list.Add( new UniCode( data[ offset ], "(The Same)" ) );
|
|
}
|
|
}
|
|
return list.ToArray( );
|
|
} catch (Exception ex) {
|
|
throw new Exception( "Unable to convert data to " + typeof( UniCode ).ToString( ), ex );
|
|
}
|
|
}
|
|
|
|
|
|
internal static string ToPcChFromSmsTxt(this byte[] data) {
|
|
string txt = "";
|
|
try {
|
|
for (int offset = 0; offset < data.Length; offset++) {
|
|
bool found = false;
|
|
// check if byte sequens is in convert table
|
|
foreach (var code in ConvTable) {
|
|
if (data[ offset ] == code.Key.First( )) {
|
|
if (code.Key.Length == 1) {
|
|
txt += code.Value.Ch;
|
|
found = true;
|
|
break;
|
|
// Check if it is a combination of to bytes
|
|
} else if ((code.Key.Length == 2) && (offset + 1 < data.Length) && (data[ offset + 1 ] == code.Key[ 1 ])) {
|
|
offset++;
|
|
txt += code.Value.Ch;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!found) {
|
|
txt += (char)data[ offset ];
|
|
}
|
|
}
|
|
return txt.Replace( "\n", Environment.NewLine );
|
|
} catch (Exception ex) {
|
|
throw new Exception( "Unable to convert char after this \"" + txt + "\"", ex );
|
|
}
|
|
}
|
|
|
|
internal static byte[] ToByteFromPcChSMS(this String Txt) {
|
|
List<byte> ret = new List<byte>( );
|
|
try {
|
|
foreach (var ch in Txt.ReplaceIllegalATCh( )) {
|
|
bool found = false;
|
|
// check if byte sequens is in convert table
|
|
foreach (var code in ConvTable) {
|
|
if (ch == code.Value.Ch) {
|
|
ret.AddRange( code.Key );
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
ret.AddRange( ASCIIEncoding.Default.GetBytes( ch.ToString( ) ) );
|
|
}
|
|
}
|
|
return ret.ToArray( );
|
|
} catch (Exception ex) {
|
|
throw new Exception( "Unable to convert char after this \"" + (ret.Count > 0 ? ret.ToArray( ).ToPcChFromSmsTxt( ) : "None, Is Empty!!") + "\"", ex );
|
|
}
|
|
}
|
|
|
|
internal static string ToStringFromPcChSMS(this String Txt) {
|
|
string ret = "";
|
|
try {
|
|
foreach (var ch in Txt.ReplaceIllegalATCh( )) {
|
|
bool found = false;
|
|
// check if byte sequens is in convert table
|
|
foreach (var code in ConvTable) {
|
|
if (ch == code.Value.Ch) {
|
|
foreach (var cdByte in code.Key) {
|
|
ret += (char)cdByte;
|
|
}
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
foreach (var cdByte in ASCIIEncoding.Default.GetBytes( ch.ToString( ) )) {
|
|
ret += (char)cdByte;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
} catch (Exception ex) {
|
|
throw new Exception( "Unable to convert char after this \"" + ret + "\"", ex );
|
|
}
|
|
}
|
|
|
|
|
|
#region ---- To String ----
|
|
private static string ToInfoTxt(byte[] data, UniCode unicode) {
|
|
return string.Format( "SMS Ch = 0x{0x}{1} \t\t unicode Ch = {2}",
|
|
data.First( ), // 0
|
|
((data.Length > 1) ? string.Format( "0x{0x}", data[ 0 ] ) : ""), //1
|
|
unicode.ToString( ) ); // 2
|
|
}
|
|
|
|
public static string GetInfoTable( ) {
|
|
string txt = "";
|
|
foreach (var data in ConvTable) {
|
|
txt += ToInfoTxt( data.Key, data.Value ) + Environment.NewLine;
|
|
}
|
|
return txt;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
internal static class StringConvert {
|
|
/// <summary>
|
|
/// Combine string array to a single text
|
|
/// </summary>
|
|
/// <param name="array">items that is null or empty will be removed</param>
|
|
/// <param name="joinWithText">inset string to join between to items (set to null if none)</param>
|
|
/// <returns></returns>
|
|
internal static string ToSingleString(this string[] array, string joinWithText) {
|
|
string ret = "";
|
|
if (array != null) {
|
|
ret = array.Select( item => (String.IsNullOrEmpty( item ) ? "" : item) ).Aggregate( (current, next) => current + ((joinWithText != null) ? joinWithText : "") + next );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Combine string array to a single text
|
|
/// </summary>
|
|
/// <param name="array">items that is null or empty will be removed</param>
|
|
/// <param name="addNewLine"> new line or a single space is use to join between to item</param>
|
|
/// <returns></returns>
|
|
internal static string ToSingleString(this string[] array, bool addNewLine) {
|
|
return ToSingleString( array, (addNewLine ? Environment.NewLine : " ") );
|
|
}
|
|
|
|
|
|
internal static string ToSingleString(this List<string> list, bool addNewLine) {
|
|
return ToSingleString( list.ToArray( ), addNewLine );
|
|
}
|
|
|
|
internal static string ToSingleString(this IEnumerable<string> list, bool addNewLine) {
|
|
return ToSingleString( list.ToArray( ), addNewLine );
|
|
}
|
|
|
|
internal static byte[] ToBytes(this string value) {
|
|
return ASCIIEncoding.Default.GetBytes( value );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert PC string to at AT OK string (No new line)
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
internal static byte[] ToBytesOkATCh(this string value) {
|
|
return ASCIIEncoding.Default.GetBytes( value.RemoveIllegalATCh( ) );
|
|
}
|
|
|
|
internal static string ToPcCh(this byte[] value) {
|
|
return ASCIIEncoding.Default.GetString( value );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert and remove all none printable char
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
internal static string ToPcPrintableCh(this byte[] value) {
|
|
return ToPcPrintableCh( value as IEnumerable<byte> );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert and remove all none printable char
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
internal static string ToPcPrintableCh(this IEnumerable<byte> value) {
|
|
string ret = "";
|
|
if (value != null) {
|
|
foreach (var b in value) {
|
|
if (b >= 32) {
|
|
ret += ASCIIEncoding.Default.GetString( new byte[] { b } );
|
|
} else if (b == '\r') {
|
|
ret += Environment.NewLine;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
internal static string ToPcChFromATCh(this byte[] value) {
|
|
return ASCIIEncoding.Default.GetString( value ).Replace( "\r", "" ).Replace( "\n", Environment.NewLine );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get all digit sequence in a string and return it as strings
|
|
/// </summary>
|
|
/// <param name="values"></param>
|
|
/// <returns></returns>
|
|
internal static string[] GetDecValues(this string values) {
|
|
//http://regexhero.net/tester/
|
|
//COM8.45 78.463 -676,67 6.454.54.45,4545,4545 (Selecting only the values)
|
|
//
|
|
MatchCollection matches = Regex.Matches( values, @"[-]|[.]|[-.]|[0-9][0-9]*[.]|[,]*[0-9]+" ); // ([0,1]|([0,1]?\.[0-9]+)) or "^[0-9]*[.]?[0-9]+$"
|
|
if (matches.Count != 0) {
|
|
List<string> ret = new List<string>( );
|
|
foreach (Match value in matches) {
|
|
ret.Add( value.Value );
|
|
}
|
|
return ret.ToArray( );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get first digit sequence in a string and return it as strings
|
|
/// </summary>
|
|
/// <param name="values"></param>
|
|
/// <returns></returns>
|
|
internal static string GetDecValue(this string value) {
|
|
string[] values = GetDecValues( value );
|
|
if (values != null) {
|
|
return values.First( );
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static string RemoveZeroTerm(this string value) {
|
|
if (!string.IsNullOrEmpty( value ) && value.Contains( '\0' )) {
|
|
return value.Remove( value.IndexOf( '\0' ) );
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
}
|