datavec/datavec-api/src/main/java/org/datavec/api/records/IOUtils.java
/*
* ******************************************************************************
* *
* *
* * This program and the accompanying materials are made available under the
* * terms of the Apache License, Version 2.0 which is available at
* * https://www.apache.org/licenses/LICENSE-2.0.
* *
* * See the NOTICE file distributed with this work for additional
* * information regarding copyright ownership.
* * 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.
* *
* * SPDX-License-Identifier: Apache-2.0
* *****************************************************************************
*/
package org.datavec.api.records;
import org.datavec.api.io.WritableComparator;
import org.datavec.api.io.WritableUtils;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
public class IOUtils {
/** Cannot create a new instance of IOUtils */
private IOUtils() {}
public static final char[] hexchars =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
/**
*
* @param s
* @return
*/
static String toXMLString(String s) {
StringBuilder sb = new StringBuilder();
for (int idx = 0; idx < s.length(); idx++) {
char ch = s.charAt(idx);
if (ch == '<') {
sb.append("<");
} else if (ch == '&') {
sb.append("&");
} else if (ch == '%') {
sb.append("%0025");
} else if (ch < 0x20 || (ch > 0xD7FF && ch < 0xE000) || (ch > 0xFFFD)) {
sb.append("%");
sb.append(hexchars[(ch & 0xF000) >> 12]);
sb.append(hexchars[(ch & 0x0F00) >> 8]);
sb.append(hexchars[(ch & 0x00F0) >> 4]);
sb.append(hexchars[(ch & 0x000F)]);
} else {
sb.append(ch);
}
}
return sb.toString();
}
static private int h2c(char ch) {
if (ch >= '0' && ch <= '9') {
return ch - '0';
} else if (ch >= 'A' && ch <= 'F') {
return ch - 'A' + 10;
} else if (ch >= 'a' && ch <= 'f') {
return ch - 'a' + 10;
}
return 0;
}
/**
*
* @param s
* @return
*/
static String fromXMLString(String s) {
StringBuilder sb = new StringBuilder();
for (int idx = 0; idx < s.length();) {
char ch = s.charAt(idx++);
if (ch == '%') {
int ch1 = h2c(s.charAt(idx++)) << 12;
int ch2 = h2c(s.charAt(idx++)) << 8;
int ch3 = h2c(s.charAt(idx++)) << 4;
int ch4 = h2c(s.charAt(idx++));
char res = (char) (ch1 | ch2 | ch3 | ch4);
sb.append(res);
} else {
sb.append(ch);
}
}
return sb.toString();
}
/**
*
* @param s
* @return
*/
static String toCSVString(String s) {
StringBuilder sb = new StringBuilder(s.length() + 1);
sb.append('\'');
int len = s.length();
for (int i = 0; i < len; i++) {
char c = s.charAt(i);
switch (c) {
case '\0':
sb.append("%00");
break;
case '\n':
sb.append("%0A");
break;
case '\r':
sb.append("%0D");
break;
case ',':
sb.append("%2C");
break;
case '}':
sb.append("%7D");
break;
case '%':
sb.append("%25");
break;
default:
sb.append(c);
}
}
return sb.toString();
}
/**
*
* @param s
* @throws java.io.IOException
* @return
*/
static String fromCSVString(String s) throws IOException {
if (s.charAt(0) != '\'') {
throw new IOException("Error deserializing string.");
}
int len = s.length();
StringBuilder sb = new StringBuilder(len - 1);
for (int i = 1; i < len; i++) {
char c = s.charAt(i);
if (c == '%') {
char ch1 = s.charAt(i + 1);
char ch2 = s.charAt(i + 2);
i += 2;
if (ch1 == '0' && ch2 == '0') {
sb.append('\0');
} else if (ch1 == '0' && ch2 == 'A') {
sb.append('\n');
} else if (ch1 == '0' && ch2 == 'D') {
sb.append('\r');
} else if (ch1 == '2' && ch2 == 'C') {
sb.append(',');
} else if (ch1 == '7' && ch2 == 'D') {
sb.append('}');
} else if (ch1 == '2' && ch2 == '5') {
sb.append('%');
} else {
throw new IOException("Error deserializing string.");
}
} else {
sb.append(c);
}
}
return sb.toString();
}
/**
*
* @param s
* @return
*/
static String toXMLBuffer(Buffer s) {
return s.toString();
}
/**
*
* @param s
* @throws java.io.IOException
* @return
*/
static Buffer fromXMLBuffer(String s) throws IOException {
if (s.length() == 0) {
return new Buffer();
}
int blen = s.length() / 2;
byte[] barr = new byte[blen];
for (int idx = 0; idx < blen; idx++) {
char c1 = s.charAt(2 * idx);
char c2 = s.charAt(2 * idx + 1);
barr[idx] = (byte) Integer.parseInt("" + c1 + c2, 16);
}
return new Buffer(barr);
}
/**
*
* @param buf
* @return
*/
static String toCSVBuffer(Buffer buf) {
StringBuilder sb = new StringBuilder("#");
sb.append(buf.toString());
return sb.toString();
}
/**
* Converts a CSV-serialized representation of buffer to a new
* Buffer
* @param s CSV-serialized representation of buffer
* @throws java.io.IOException
* @return Deserialized Buffer
*/
static Buffer fromCSVBuffer(String s) throws IOException {
if (s.charAt(0) != '#') {
throw new IOException("Error deserializing buffer.");
}
if (s.length() == 1) {
return new Buffer();
}
int blen = (s.length() - 1) / 2;
byte[] barr = new byte[blen];
for (int idx = 0; idx < blen; idx++) {
char c1 = s.charAt(2 * idx + 1);
char c2 = s.charAt(2 * idx + 2);
barr[idx] = (byte) Integer.parseInt("" + c1 + c2, 16);
}
return new Buffer(barr);
}
private static int utf8LenForCodePoint(final int cpt) throws IOException {
if (cpt >= 0 && cpt <= 0x7F) {
return 1;
}
if (cpt >= 0x80 && cpt <= 0x07FF) {
return 2;
}
if ((cpt >= 0x0800 && cpt < 0xD800) || (cpt > 0xDFFF && cpt <= 0xFFFD)) {
return 3;
}
if (cpt >= 0x10000 && cpt <= 0x10FFFF) {
return 4;
}
throw new IOException("Illegal Unicode Codepoint " + Integer.toHexString(cpt) + " in string.");
}
private static final int B10 = Integer.parseInt("10000000", 2);
private static final int B110 = Integer.parseInt("11000000", 2);
private static final int B1110 = Integer.parseInt("11100000", 2);
private static final int B11110 = Integer.parseInt("11110000", 2);
private static final int B11 = Integer.parseInt("11000000", 2);
private static final int B111 = Integer.parseInt("11100000", 2);
private static final int B1111 = Integer.parseInt("11110000", 2);
private static final int B11111 = Integer.parseInt("11111000", 2);
private static int writeUtf8(int cpt, final byte[] bytes, final int offset) throws IOException {
if (cpt >= 0 && cpt <= 0x7F) {
bytes[offset] = (byte) cpt;
return 1;
}
if (cpt >= 0x80 && cpt <= 0x07FF) {
bytes[offset + 1] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset] = (byte) (B110 | (cpt & 0x1F));
return 2;
}
if ((cpt >= 0x0800 && cpt < 0xD800) || (cpt > 0xDFFF && cpt <= 0xFFFD)) {
bytes[offset + 2] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset + 1] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset] = (byte) (B1110 | (cpt & 0x0F));
return 3;
}
if (cpt >= 0x10000 && cpt <= 0x10FFFF) {
bytes[offset + 3] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset + 2] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset + 1] = (byte) (B10 | (cpt & 0x3F));
cpt = cpt >> 6;
bytes[offset] = (byte) (B11110 | (cpt & 0x07));
return 4;
}
throw new IOException("Illegal Unicode Codepoint " + Integer.toHexString(cpt) + " in string.");
}
static void toBinaryString(final DataOutput out, final String str) throws IOException {
final int strlen = str.length();
byte[] bytes = new byte[strlen * 4]; // Codepoints expand to 4 bytes max
int utf8Len = 0;
int idx = 0;
while (idx < strlen) {
final int cpt = str.codePointAt(idx);
idx += Character.isSupplementaryCodePoint(cpt) ? 2 : 1;
utf8Len += writeUtf8(cpt, bytes, utf8Len);
}
writeVInt(out, utf8Len);
out.write(bytes, 0, utf8Len);
}
static boolean isValidCodePoint(int cpt) {
return !((cpt > 0x10FFFF) || (cpt >= 0xD800 && cpt <= 0xDFFF) || (cpt >= 0xFFFE && cpt <= 0xFFFF));
}
private static int utf8ToCodePoint(int b1, int b2, int b3, int b4) {
int cpt;
cpt = (((b1 & ~B11111) << 18) | ((b2 & ~B11) << 12) | ((b3 & ~B11) << 6) | (b4 & ~B11));
return cpt;
}
private static int utf8ToCodePoint(int b1, int b2, int b3) {
int cpt = 0;
cpt = (((b1 & ~B1111) << 12) | ((b2 & ~B11) << 6) | (b3 & ~B11));
return cpt;
}
private static int utf8ToCodePoint(int b1, int b2) {
int cpt = 0;
cpt = (((b1 & ~B111) << 6) | (b2 & ~B11));
return cpt;
}
private static void checkB10(int b) throws IOException {
if ((b & B11) != B10) {
throw new IOException("Invalid UTF-8 representation.");
}
}
static String fromBinaryString(final DataInput din) throws IOException {
final int utf8Len = readVInt(din);
final byte[] bytes = new byte[utf8Len];
din.readFully(bytes);
int len = 0;
// For the most commmon case, i.e. ascii, numChars = utf8Len
StringBuilder sb = new StringBuilder(utf8Len);
while (len < utf8Len) {
int cpt;
final int b1 = bytes[len++] & 0xFF;
if (b1 <= 0x7F) {
cpt = b1;
} else if ((b1 & B11111) == B11110) {
int b2 = bytes[len++] & 0xFF;
checkB10(b2);
int b3 = bytes[len++] & 0xFF;
checkB10(b3);
int b4 = bytes[len++] & 0xFF;
checkB10(b4);
cpt = utf8ToCodePoint(b1, b2, b3, b4);
} else if ((b1 & B1111) == B1110) {
int b2 = bytes[len++] & 0xFF;
checkB10(b2);
int b3 = bytes[len++] & 0xFF;
checkB10(b3);
cpt = utf8ToCodePoint(b1, b2, b3);
} else if ((b1 & B111) == B110) {
int b2 = bytes[len++] & 0xFF;
checkB10(b2);
cpt = utf8ToCodePoint(b1, b2);
} else {
throw new IOException("Invalid UTF-8 byte " + Integer.toHexString(b1) + " at offset " + (len - 1)
+ " in length of " + utf8Len);
}
if (!isValidCodePoint(cpt)) {
throw new IOException("Illegal Unicode Codepoint " + Integer.toHexString(cpt) + " in stream.");
}
sb.appendCodePoint(cpt);
}
return sb.toString();
}
/** Parse a float from a byte array. */
public static float readFloat(byte[] bytes, int start) {
return WritableComparator.readFloat(bytes, start);
}
/** Parse a double from a byte array. */
public static double readDouble(byte[] bytes, int start) {
return WritableComparator.readDouble(bytes, start);
}
/**
* Reads a zero-compressed encoded long from a byte array and returns it.
* @param bytes byte array with decode long
* @param start starting index
* @throws java.io.IOException
* @return deserialized long
*/
public static long readVLong(byte[] bytes, int start) throws IOException {
return WritableComparator.readVLong(bytes, start);
}
/**
* Reads a zero-compressed encoded integer from a byte array and returns it.
* @param bytes byte array with the encoded integer
* @param start start index
* @throws java.io.IOException
* @return deserialized integer
*/
public static int readVInt(byte[] bytes, int start) throws IOException {
return WritableComparator.readVInt(bytes, start);
}
/**
* Reads a zero-compressed encoded long from a stream and return it.
* @param in input stream
* @throws java.io.IOException
* @return deserialized long
*/
public static long readVLong(DataInput in) throws IOException {
return WritableUtils.readVLong(in);
}
/**
* Reads a zero-compressed encoded integer from a stream and returns it.
* @param in input stream
* @throws java.io.IOException
* @return deserialized integer
*/
public static int readVInt(DataInput in) throws IOException {
return WritableUtils.readVInt(in);
}
/**
* Get the encoded length if an integer is stored in a variable-length format
* @return the encoded length
*/
public static int getVIntSize(long i) {
return WritableUtils.getVIntSize(i);
}
/**
* Serializes a long to a binary stream with zero-compressed encoding.
* For -112 <= i <= 127, only one byte is used with the actual value.
* For other values of i, the first byte value indicates whether the
* long is positive or negative, and the number of bytes that follow.
* If the first byte value v is between -113 and -120, the following long
* is positive, with number of bytes that follow are -(v+112).
* If the first byte value v is between -121 and -128, the following long
* is negative, with number of bytes that follow are -(v+120). Bytes are
* stored in the high-non-zero-byte-first order.
*
* @param stream Binary output stream
* @param i Long to be serialized
* @throws java.io.IOException
*/
public static void writeVLong(DataOutput stream, long i) throws IOException {
WritableUtils.writeVLong(stream, i);
}
/**
* Serializes an int to a binary stream with zero-compressed encoding.
*
* @param stream Binary output stream
* @param i int to be serialized
* @throws java.io.IOException
*/
public static void writeVInt(DataOutput stream, int i) throws IOException {
WritableUtils.writeVInt(stream, i);
}
/** Lexicographic order of binary data. */
public static int compareBytes(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
return WritableComparator.compareBytes(b1, s1, l1, b2, s2, l2);
}
}