/*
* 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.
*/
package org.apache.solr.common.util;
import java.io.IOException;
import java.io.OutputStream;
import org.noggit.CharArr;
public class ByteUtils {
/** Maximum number of UTF8 bytes per UTF16 character. */
public static final int MAX_UTF8_BYTES_PER_CHAR = 3;
/** Converts utf8 to utf16 and returns the number of 16 bit Java chars written.
* Full characters are read, even if this reads past the length passed (and can result in
* an ArrayOutOfBoundsException if invalid UTF8 is passed). Explicit checks for valid UTF8 are not performed.
* The char[] out should probably have enough room to hold the worst case of each byte becoming a Java char.
*/
public static int UTF8toUTF16(byte[] utf8, int offset, int len, char[] out, int out_offset) {
int out_start = out_offset;
final int limit = offset + len;
while (offset < limit) {
int b = utf8[offset++]&0xff;
if (b < 0xc0) {
assert b < 0x80;
out[out_offset++] = (char)b;
} else if (b < 0xe0) {
out[out_offset++] = (char)(((b&0x1f)<<6) + (utf8[offset++]&0x3f));
} else if (b < 0xf0) {
out[out_offset++] = (char)(((b&0xf)<<12) + ((utf8[offset]&0x3f)<<6) + (utf8[offset+1]&0x3f));
offset += 2;
} else {
assert b < 0xf8;
int ch = ((b&0x7)<<18) + ((utf8[offset]&0x3f)<<12) + ((utf8[offset+1]&0x3f)<<6) + (utf8[offset+2]&0x3f);
offset += 3;
if (ch < 0xffff) {
out[out_offset++] = (char)ch;
} else {
int chHalf = ch - 0x0010000;
out[out_offset++] = (char) ((chHalf >> 10) + 0xD800);
out[out_offset++] = (char) ((chHalf & 0x3FFL) + 0xDC00);
}
}
}
return out_offset - out_start;
}
/** Convert UTF8 bytes into UTF16 characters. */
public static void UTF8toUTF16(byte[] utf8, int offset, int len, CharArr out) {
// TODO: do in chunks if the input is large
out.reserve(len);
int n = UTF8toUTF16(utf8, offset, len, out.getArray(), out.getEnd());
out.setEnd(out.getEnd() + n);
}
/** Convert UTF8 bytes into a String */
public static String UTF8toUTF16(byte[] utf8, int offset, int len) {
char[] out = new char[len];
int n = UTF8toUTF16(utf8, offset, len, out, 0);
return new String(out,0,n);
}
/** Writes UTF8 into the byte array, starting at offset. The caller should ensure that
* there is enough space for the worst-case scenario.
* @return the number of bytes written
*/
public static int UTF16toUTF8(CharSequence s, int offset, int len, byte[] result, int resultOffset) {
final int end = offset + len;
int upto = resultOffset;
for(int i=offset;i<end;i++) {
final int code = (int) s.charAt(i);
if (code < 0x80)
result[upto++] = (byte) code;
else if (code < 0x800) {
result[upto++] = (byte) (0xC0 | (code >> 6));
result[upto++] = (byte)(0x80 | (code & 0x3F));
} else if (code < 0xD800 || code > 0xDFFF) {
result[upto++] = (byte)(0xE0 | (code >> 12));
result[upto++] = (byte)(0x80 | ((code >> 6) & 0x3F));
result[upto++] = (byte)(0x80 | (code & 0x3F));
} else {
// surrogate pair
// confirm valid high surrogate
if (code < 0xDC00 && (i < end-1)) {
int utf32 = (int) s.charAt(i+1);
// confirm valid low surrogate and write pair
if (utf32 >= 0xDC00 && utf32 <= 0xDFFF) {
utf32 = ((code - 0xD7C0) << 10) + (utf32 & 0x3FF);
i++;
result[upto++] = (byte)(0xF0 | (utf32 >> 18));
result[upto++] = (byte)(0x80 | ((utf32 >> 12) & 0x3F));
result[upto++] = (byte)(0x80 | ((utf32 >> 6) & 0x3F));
result[upto++] = (byte)(0x80 | (utf32 & 0x3F));
continue;
}
}
// replace unpaired surrogate or out-of-order low surrogate
// with substitution character
result[upto++] = (byte) 0xEF;
result[upto++] = (byte) 0xBF;
result[upto++] = (byte) 0xBD;
}
}
return upto - resultOffset;
}
/** Writes UTF8 into the given OutputStream by first writing to the given scratch array
* and then writing the contents of the scratch array to the OutputStream. The given scratch byte array
* is used to buffer intermediate data before it is written to the output stream.
*
* @return the number of bytes written
*/
public static int writeUTF16toUTF8(CharSequence s, int offset, int len, OutputStream fos, byte[] scratch) throws IOException {
final int end = offset + len;
int upto = 0, totalBytes = 0;
for(int i=offset;i<end;i++) {
final int code = (int) s.charAt(i);
if (upto > scratch.length - 4) {
// a code point may take upto 4 bytes and we don't have enough space, so reset
totalBytes += upto;
fos.write(scratch, 0, upto);
upto = 0;
}
if (code < 0x80)
scratch[upto++] = (byte) code;
else if (code < 0x800) {
scratch[upto++] = (byte) (0xC0 | (code >> 6));
scratch[upto++] = (byte)(0x80 | (code & 0x3F));
} else if (code < 0xD800 || code > 0xDFFF) {
scratch[upto++] = (byte)(0xE0 | (code >> 12));
scratch[upto++] = (byte)(0x80 | ((code >> 6) & 0x3F));
scratch[upto++] = (byte)(0x80 | (code & 0x3F));
} else {
// surrogate pair
// confirm valid high surrogate
if (code < 0xDC00 && (i < end-1)) {
int utf32 = (int) s.charAt(i+1);
// confirm valid low surrogate and write pair
if (utf32 >= 0xDC00 && utf32 <= 0xDFFF) {
utf32 = ((code - 0xD7C0) << 10) + (utf32 & 0x3FF);
i++;
scratch[upto++] = (byte)(0xF0 | (utf32 >> 18));
scratch[upto++] = (byte)(0x80 | ((utf32 >> 12) & 0x3F));
scratch[upto++] = (byte)(0x80 | ((utf32 >> 6) & 0x3F));
scratch[upto++] = (byte)(0x80 | (utf32 & 0x3F));
continue;
}
}
// replace unpaired surrogate or out-of-order low surrogate
// with substitution character
scratch[upto++] = (byte) 0xEF;
scratch[upto++] = (byte) 0xBF;
scratch[upto++] = (byte) 0xBD;
}
}
totalBytes += upto;
fos.write(scratch, 0, upto);
return totalBytes;
}
/**
* Calculates the number of UTF8 bytes necessary to write a UTF16 string.
*
* @return the number of bytes written
*/
public static int calcUTF16toUTF8Length(CharSequence s, int offset, int len) {
final int end = offset + len;
int res = 0;
for (int i = offset; i < end; i++) {
final int code = (int) s.charAt(i);
if (code < 0x80)
res++;
else if (code < 0x800) {
res += 2;
} else if (code < 0xD800 || code > 0xDFFF) {
res += 3;
} else {
// surrogate pair
// confirm valid high surrogate
if (code < 0xDC00 && (i < end - 1)) {
int utf32 = (int) s.charAt(i + 1);
// confirm valid low surrogate and write pair
if (utf32 >= 0xDC00 && utf32 <= 0xDFFF) {
i++;
res += 4;
continue;
}
}
res += 3;
}
}
return res;
}
}