|
/* ====================================================================
|
Licensed to the Apache Software Foundation (ASF) under one or more
|
contributor license agreements. See the NOTICE file distributed with
|
this work for additional information regarding copyright ownership.
|
The ASF licenses this file to You under the Apache License, Version 2.0
|
(the "License"); you may not use this file except in compliance with
|
the License. You may obtain a copy of the License at
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
Unless required by applicable law or agreed to in writing, software
|
distributed under the License is distributed on an "AS IS" BASIS,
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
See the License for the specific language governing permissions and
|
limitations under the License.
|
==================================================================== */
|
|
/* ================================================================
|
* About NPOI
|
* Author: Tony Qu
|
* Author's email: tonyqus (at) gmail.com
|
* Author's Blog: tonyqus.wordpress.com.cn (wp.tonyqus.cn)
|
* HomePage: http://www.codeplex.com/npoi
|
* Contributors:
|
*
|
* ==============================================================*/
|
|
using System;
|
using System.Collections;
|
using System.Text;
|
|
|
|
namespace HH.WMS.Utils.NPOI.Util
|
{
|
/// <summary>
|
/// Title: String Utility Description: Collection of string handling utilities
|
/// @author Andrew C. Oliver
|
/// @author Sergei Kozello (sergeikozello at mail.ru)
|
/// @author Toshiaki Kamoshida (kamoshida.toshiaki at future dot co dot jp)
|
/// @since May 10, 2002
|
/// @version 1.0
|
/// </summary>
|
public class StringUtil {
|
private const String ENCODING = "ISO-8859-1";
|
/**
|
* Constructor for the StringUtil object
|
*/
|
private StringUtil() {
|
}
|
|
/// <summary>
|
/// Given a byte array of 16-bit unicode characters in Little Endian
|
/// Format (most important byte last), return a Java String representation
|
/// of it.
|
/// { 0x16, 0x00 } -0x16
|
/// </summary>
|
/// <param name="str">the byte array to be converted</param>
|
/// <param name="offset">the initial offset into the
|
/// byte array. it is assumed that string[ offset ] and string[ offset + 1 ] contain the first 16-bit unicode character</param>
|
/// <param name="len">the Length of the string</param>
|
/// <returns>the converted string</returns>
|
public static String GetFromUnicodeLE(
|
byte[] str,
|
int offset,
|
int len){
|
if ((offset < 0) || (offset >= str.Length)) {
|
throw new IndexOutOfRangeException("Illegal offset");
|
}
|
if ((len < 0) || (((str.Length - offset) / 2) < len)) {
|
throw new ArgumentException("Illegal Length");
|
}
|
|
return Encoding.Unicode.GetString(str, offset, len * 2);
|
}
|
|
/// <summary>
|
/// Given a byte array of 16-bit unicode characters in little endian
|
/// Format (most important byte last), return a Java String representation
|
/// of it.
|
///{ 0x16, 0x00 } -0x16
|
/// </summary>
|
/// <param name="str">the byte array to be converted</param>
|
/// <returns>the converted string</returns>
|
public static String GetFromUnicodeLE(byte[] str) {
|
if(str.Length == 0) { return ""; }
|
return GetFromUnicodeLE(str, 0, str.Length / 2);
|
}
|
|
/// <summary>
|
/// Given a byte array of 16-bit unicode characters in big endian
|
/// Format (most important byte first), return a Java String representation
|
/// of it.
|
/// { 0x00, 0x16 } -0x16
|
/// </summary>
|
/// <param name="str">the byte array to be converted</param>
|
/// <param name="offset">the initial offset into the
|
/// byte array. it is assumed that string[ offset ] and string[ offset + 1 ] contain the first 16-bit unicode character</param>
|
/// <param name="len">the Length of the string</param>
|
/// <returns> the converted string</returns>
|
public static String GetFromUnicodeBE(
|
byte[] str,
|
int offset,
|
int len)
|
{
|
if ((offset < 0) || (offset >= str.Length)) {
|
throw new IndexOutOfRangeException("Illegal offset");
|
}
|
if ((len < 0) || (((str.Length - offset) / 2) < len)) {
|
throw new ArgumentException("Illegal Length");
|
}
|
try {
|
return Encoding.GetEncoding("UTF-16BE").GetString(str, offset, len * 2);
|
} catch {
|
throw new InvalidOperationException(); /*unreachable*/
|
}
|
}
|
|
/// <summary>
|
/// Given a byte array of 16-bit unicode characters in big endian
|
/// Format (most important byte first), return a Java String representation
|
/// of it.
|
/// { 0x00, 0x16 } -0x16
|
/// </summary>
|
/// <param name="str">the byte array to be converted</param>
|
/// <returns>the converted string</returns>
|
public static String GetFromUnicodeBE(byte[] str) {
|
if(str.Length == 0) { return ""; }
|
return GetFromUnicodeBE(str, 0, str.Length / 2);
|
}
|
|
/// <summary>
|
/// Read 8 bit data (in IsO-8859-1 codepage) into a (unicode) Java
|
/// String and return.
|
/// (In Excel terms, read compressed 8 bit unicode as a string)
|
/// </summary>
|
/// <param name="str">byte array to read</param>
|
/// <param name="offset">offset to read byte array</param>
|
/// <param name="len">Length to read byte array</param>
|
/// <returns>generated String instance by reading byte array</returns>
|
public static String GetFromCompressedUnicode(
|
byte[] str,
|
int offset,
|
int len) {
|
try {
|
int len_to_use = Math.Min(len, str.Length - offset);
|
return Encoding.GetEncoding(ENCODING).GetString(str, offset, len_to_use);
|
} catch {
|
throw new InvalidOperationException(); /* unreachable */
|
}
|
}
|
|
/// <summary>
|
/// Takes a unicode (java) string, and returns it as 8 bit data (in IsO-8859-1
|
/// codepage).
|
/// (In Excel terms, write compressed 8 bit unicode)
|
/// </summary>
|
/// <param name="input">the String containing the data to be written</param>
|
/// <param name="output">the byte array to which the data Is to be written</param>
|
/// <param name="offset">an offset into the byte arrat at which the data Is start when written</param>
|
public static void PutCompressedUnicode(
|
String input,
|
byte[] output,
|
int offset) {
|
try {
|
byte[] bytes = Encoding.GetEncoding(ENCODING).GetBytes(input);
|
Array.Copy(bytes, 0, output, offset, bytes.Length);
|
} catch{
|
throw;
|
}
|
}
|
public static void PutCompressedUnicode(String input, ILittleEndianOutput out1)
|
{
|
byte[] bytes;
|
try
|
{
|
bytes = Encoding.GetEncoding(ENCODING).GetBytes(input);
|
}
|
catch (EncoderFallbackException)
|
{
|
throw;
|
}
|
out1.Write(bytes);
|
}
|
|
|
/// <summary>
|
/// Takes a unicode string, and returns it as little endian (most
|
/// important byte last) bytes in the supplied byte array.
|
/// (In Excel terms, write uncompressed unicode)
|
/// </summary>
|
/// <param name="input">the String containing the unicode data to be written</param>
|
/// <param name="output">the byte array to hold the uncompressed unicode, should be twice the Length of the String</param>
|
/// <param name="offset">the offset to start writing into the byte array</param>
|
public static void PutUnicodeLE(String input, byte[] output, int offset)
|
{
|
byte[] bytes = Encoding.GetEncoding("UTF-16LE").GetBytes(input);
|
Array.Copy(bytes, 0, output, offset, bytes.Length);
|
}
|
public static void PutUnicodeLE(String input, ILittleEndianOutput out1)
|
{
|
byte[] bytes;
|
try
|
{
|
bytes = Encoding.GetEncoding("UTF-16LE").GetBytes(input);
|
}
|
catch (EncoderFallbackException)
|
{
|
throw;
|
}
|
out1.Write(bytes);
|
}
|
|
|
|
/// <summary>
|
/// Takes a unicode string, and returns it as big endian (most
|
/// important byte first) bytes in the supplied byte array.
|
/// (In Excel terms, write uncompressed unicode)
|
/// </summary>
|
/// <param name="input">the String containing the unicode data to be written</param>
|
/// <param name="output">the byte array to hold the uncompressed unicode, should be twice the Length of the String.</param>
|
/// <param name="offset">the offset to start writing into the byte array</param>
|
public static void PutUnicodeBE(
|
String input,
|
byte[] output,
|
int offset)
|
{
|
try
|
{
|
byte[] bytes = Encoding.GetEncoding("UTF-16BE").GetBytes(input);
|
Array.Copy(bytes, 0, output, offset, bytes.Length);
|
}
|
catch
|
{
|
throw new InvalidOperationException(); /*unreachable*/
|
}
|
}
|
|
|
/// <summary>
|
/// Gets the preferred encoding.
|
/// </summary>
|
/// <returns>the encoding we want to use, currently hardcoded to IsO-8859-1</returns>
|
public static String GetPreferredEncoding()
|
{
|
return ENCODING;
|
}
|
|
/// <summary>
|
/// check the parameter Has multibyte character
|
/// </summary>
|
/// <param name="value"> string to check</param>
|
/// <returns>
|
/// <c>true</c> if Has at least one multibyte character; otherwise, <c>false</c>.
|
/// </returns>
|
public static bool HasMultibyte(String value)
|
{
|
if (value == null) return false;
|
for (int i = 0; i < value.Length; i++)
|
{
|
char c = value[i];
|
if (c > 0xFF) return true;
|
}
|
return false;
|
}
|
|
public static String ReadCompressedUnicode(ILittleEndianInput in1, int nChars)
|
{
|
char[] buf = new char[nChars];
|
for (int i = 0; i < buf.Length; i++)
|
{
|
buf[i] = (char)in1.ReadUByte();
|
}
|
return new String(buf);
|
}
|
public static String ReadUnicodeLE(ILittleEndianInput in1, int nChars)
|
{
|
char[] buf = new char[nChars];
|
for (int i = 0; i < buf.Length; i++)
|
{
|
buf[i] = (char)in1.ReadUShort();
|
}
|
return new String(buf);
|
}
|
|
/**
|
* InputStream <c>in</c> is expected to contain:
|
* <ol>
|
* <li>ushort nChars</li>
|
* <li>byte is16BitFlag</li>
|
* <li>byte[]/char[] characterData</li>
|
* </ol>
|
* For this encoding, the is16BitFlag is always present even if nChars==0.
|
*/
|
public static String ReadUnicodeString(ILittleEndianInput in1)
|
{
|
|
int nChars = in1.ReadUShort();
|
byte flag = (byte)in1.ReadByte();
|
if ((flag & 0x01) == 0)
|
{
|
return ReadCompressedUnicode(in1, nChars);
|
}
|
return ReadUnicodeLE(in1, nChars);
|
}
|
/**
|
* InputStream <c>in</c> is expected to contain:
|
* <ol>
|
* <li>byte is16BitFlag</li>
|
* <li>byte[]/char[] characterData</li>
|
* </ol>
|
* For this encoding, the is16BitFlag is always present even if nChars==0.
|
* <br/>
|
* This method should be used when the nChars field is <em>not</em> stored
|
* as a ushort immediately before the is16BitFlag. Otherwise, {@link
|
* #readUnicodeString(LittleEndianInput)} can be used.
|
*/
|
public static String ReadUnicodeString(ILittleEndianInput in1, int nChars)
|
{
|
byte is16Bit = (byte)in1.ReadByte();
|
if ((is16Bit & 0x01) == 0)
|
{
|
return ReadCompressedUnicode(in1, nChars);
|
}
|
return ReadUnicodeLE(in1, nChars);
|
}
|
/**
|
* OutputStream <c>out</c> will get:
|
* <ol>
|
* <li>ushort nChars</li>
|
* <li>byte is16BitFlag</li>
|
* <li>byte[]/char[] characterData</li>
|
* </ol>
|
* For this encoding, the is16BitFlag is always present even if nChars==0.
|
*/
|
public static void WriteUnicodeString(ILittleEndianOutput out1, String value)
|
{
|
|
int nChars = value.Length;
|
out1.WriteShort(nChars);
|
bool is16Bit = HasMultibyte(value);
|
out1.WriteByte(is16Bit ? 0x01 : 0x00);
|
if (is16Bit)
|
{
|
PutUnicodeLE(value, out1);
|
}
|
else
|
{
|
PutCompressedUnicode(value, out1);
|
}
|
}
|
/**
|
* OutputStream <c>out</c> will get:
|
* <ol>
|
* <li>byte is16BitFlag</li>
|
* <li>byte[]/char[] characterData</li>
|
* </ol>
|
* For this encoding, the is16BitFlag is always present even if nChars==0.
|
* <br/>
|
* This method should be used when the nChars field is <em>not</em> stored
|
* as a ushort immediately before the is16BitFlag. Otherwise, {@link
|
* #writeUnicodeString(LittleEndianOutput, String)} can be used.
|
*/
|
public static void WriteUnicodeStringFlagAndData(ILittleEndianOutput out1, String value)
|
{
|
bool is16Bit = HasMultibyte(value);
|
out1.WriteByte(is16Bit ? 0x01 : 0x00);
|
if (is16Bit)
|
{
|
PutUnicodeLE(value, out1);
|
}
|
else
|
{
|
PutCompressedUnicode(value, out1);
|
}
|
}
|
/// <summary>
|
/// Gets the number of bytes that would be written by WriteUnicodeString(LittleEndianOutput, String)
|
/// </summary>
|
/// <param name="value">The value.</param>
|
/// <returns></returns>
|
public static int GetEncodedSize(String value)
|
{
|
int result = 2 + 1;
|
result += value.Length * (StringUtil.HasMultibyte(value) ? 2 : 1);
|
return result;
|
}
|
|
/// <summary>
|
/// Checks to see if a given String needs to be represented as Unicode
|
/// </summary>
|
/// <param name="value">The value.</param>
|
/// <returns>
|
/// <c>true</c> if string needs Unicode to be represented.; otherwise, <c>false</c>.
|
/// </returns>
|
///<remarks>Tony Qu change the logic</remarks>
|
public static bool IsUnicodeString(String value) {
|
try{
|
return !value.Equals(Encoding.GetEncoding(ENCODING).GetString(Encoding.GetEncoding(ENCODING).GetBytes(value)));
|
} catch {
|
return true;
|
}
|
}
|
/// <summary>
|
/// Encodes non-US-ASCII characters in a string, good for encoding file names for download
|
/// http://www.acriticsreview.com/List.aspx?listid=42
|
/// </summary>
|
/// <param name="s"></param>
|
/// <returns></returns>
|
public static string ToHexString(string s)
|
{
|
char[] chars = s.ToCharArray();
|
StringBuilder builder = new StringBuilder();
|
for (int index = 0; index < chars.Length; index++)
|
{
|
bool needToEncode = NeedToEncode(chars[index]);
|
if (needToEncode)
|
{
|
string encodedString = ToHexString(chars[index]);
|
builder.Append(encodedString);
|
}
|
else
|
{
|
builder.Append(chars[index]);
|
}
|
}
|
|
return builder.ToString();
|
}
|
/// <summary>
|
/// Encodes a non-US-ASCII character.
|
/// </summary>
|
/// <param name="chr"></param>
|
/// <returns></returns>
|
public static string ToHexString(char chr)
|
{
|
//UTF8Encoding utf8 = new UTF8Encoding();
|
//byte[] encodedBytes = utf8.GetBytes(((int)chr).ToString());
|
//StringBuilder builder = new StringBuilder();
|
//for (int index = 0; index < encodedBytes.Length; index++)
|
//{
|
// builder.AppendFormat("{0}", Convert.ToString(encodedBytes[index], 16));
|
//}
|
|
//return builder.ToString();
|
|
return Convert.ToString((int)chr, 16);
|
}
|
|
/// <summary>
|
/// Encodes a non-US-ASCII character.
|
/// </summary>
|
/// <param name="chr"></param>
|
/// <returns></returns>
|
public static string ToHexString(short chr)
|
{
|
return ToHexString((char)chr);
|
}
|
|
/// <summary>
|
/// Encodes a non-US-ASCII character.
|
/// </summary>
|
/// <param name="chr"></param>
|
/// <returns></returns>
|
public static string ToHexString(int chr)
|
{
|
return ToHexString((char)chr);
|
}
|
/// <summary>
|
/// Encodes a non-US-ASCII character.
|
/// </summary>
|
/// <param name="chr"></param>
|
/// <returns></returns>
|
public static string ToHexString(long chr)
|
{
|
return ToHexString((char)chr);
|
}
|
/// <summary>
|
/// Determines if the character needs to be encoded.
|
/// http://www.acriticsreview.com/List.aspx?listid=42
|
/// </summary>
|
/// <param name="chr"></param>
|
/// <returns></returns>
|
private static bool NeedToEncode(char chr)
|
{
|
string reservedChars = "$-_.+!*'(),@=&";
|
|
if (chr > 127)
|
return true;
|
if (char.IsLetterOrDigit(chr) || reservedChars.IndexOf(chr) >= 0)
|
return false;
|
|
return true;
|
}
|
}
|
}
|
