// Access to create strings from a byte array.

private static final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();

// Analysis has shown that generating the whole array allows the JIT to generate

// better code compared to a slimmed down array, such as one cutting off after 'f'

private static final byte[] DIGITS = {

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1

};

/**

private static final HexFormat HEX_FORMAT =

new HexFormat("", "", "", false);

private static final HexFormat HEX_UPPER_FORMAT =

new HexFormat("", "", "", true);

private static final byte[] EMPTY_BYTES = {};

private final String delimiter;

private final String prefix;

private final String suffix;

private final boolean ucase;

/**

private HexFormat(String delimiter, String prefix, String suffix, boolean ucase) {

this.delimiter = Objects.requireNonNull(delimiter, "delimiter");

this.prefix = Objects.requireNonNull(prefix, "prefix");

this.suffix = Objects.requireNonNull(suffix, "suffix");

this.ucase = ucase;

}

/**

public static HexFormat of() {

return HEX_FORMAT;

}

/**

public static HexFormat ofDelimiter(String delimiter) {

return new HexFormat(delimiter, "", "", false);

}

/**

public HexFormat withDelimiter(String delimiter) {

return new HexFormat(delimiter, this.prefix, this.suffix, this.ucase);

}

/**

public HexFormat withPrefix(String prefix) {

return new HexFormat(this.delimiter, prefix, this.suffix, this.ucase);

}

/**

public HexFormat withSuffix(String suffix) {

return new HexFormat(this.delimiter, this.prefix, suffix, this.ucase);

}

/**

public HexFormat withUpperCase() {

if (this == HEX_FORMAT)

return HEX_UPPER_FORMAT;

return new HexFormat(this.delimiter, this.prefix, this.suffix, true);

}

/**

public HexFormat withLowerCase() {

return new HexFormat(this.delimiter, this.prefix, this.suffix, false);

}

/**

public String delimiter() {

return delimiter;

}

/**

public String prefix() {

return prefix;

}

/**

public String suffix() {

return suffix;

}

/**

public boolean isUpperCase() {

return ucase;

}

/**

public String formatHex(byte[] bytes) {

return formatHex(bytes, 0, bytes.length);

}

/**

public String formatHex(byte[] bytes, int fromIndex, int toIndex) {

Objects.requireNonNull(bytes,"bytes");

Objects.checkFromToIndex(fromIndex, toIndex, bytes.length);

if (toIndex - fromIndex == 0) {

return "";

}

// Format efficiently if possible

String s = formatOptDelimiter(bytes, fromIndex, toIndex);

if (s == null) {

long stride = prefix.length() + 2L + suffix.length() + delimiter.length();

int capacity = checkMaxArraySize((toIndex - fromIndex) * stride - delimiter.length());

StringBuilder sb = new StringBuilder(capacity);

formatHex(sb, bytes, fromIndex, toIndex);

s = sb.toString();

}

return s;

}

/**

public <A extends Appendable> A formatHex(A out, byte[] bytes) {

return formatHex(out, bytes, 0, bytes.length);

}

/**

public <A extends Appendable> A formatHex(A out, byte[] bytes, int fromIndex, int toIndex) {

Objects.requireNonNull(out, "out");

Objects.requireNonNull(bytes, "bytes");

Objects.checkFromToIndex(fromIndex, toIndex, bytes.length);

int length = toIndex - fromIndex;

if (length > 0) {

try {

String s = formatOptDelimiter(bytes, fromIndex, toIndex);

if (s != null) {

out.append(s);

} else {

out.append(prefix);

toHexDigits(out, bytes[fromIndex]);

for (int i = 1; i < length; i++) {

out.append(suffix);

out.append(delimiter);

out.append(prefix);

toHexDigits(out, bytes[fromIndex + i]);

}

out.append(suffix);

}

} catch (IOException ioe) {

throw new UncheckedIOException(ioe.getMessage(), ioe);

}

}

return out;

}

/**

private String formatOptDelimiter(byte[] bytes, int fromIndex, int toIndex) {

char sep;

byte[] rep;

if (!prefix.isEmpty() || !suffix.isEmpty()) {

return null;

}

int length = toIndex - fromIndex;

if (delimiter.isEmpty()) {

// Allocate the byte array and fill in the hex pairs for each byte

rep = new byte[checkMaxArraySize(length * 2L)];

for (int i = 0; i < length; i++) {

short pair = HexDigits.digitPair(bytes[fromIndex + i], ucase);

int pos = i * 2;

rep[pos] = (byte)pair;

rep[pos + 1] = (byte)(pair >>> 8);

}

} else if (delimiter.length() == 1 && (sep = delimiter.charAt(0)) < 256) {

// Allocate the byte array and fill in the characters for the first byte

// Then insert the delimiter and hexadecimal characters for each of the remaining bytes

rep = new byte[checkMaxArraySize(length * 3L - 1L)];

short pair = HexDigits.digitPair(bytes[fromIndex], ucase);

rep[0] = (byte)pair;

rep[1] = (byte)(pair >>> 8);

for (int i = 1; i < length; i++) {

int pos = i * 3;

pair = HexDigits.digitPair(bytes[fromIndex + i], ucase);

rep[pos - 1] = (byte) sep;

rep[pos] = (byte)pair;

rep[pos + 1] = (byte)(pair >>> 8);

}

} else {

// Delimiter formatting not to a single byte

return null;

}

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

private static int checkMaxArraySize(long length) {

if (length > Integer.MAX_VALUE)

throw new OutOfMemoryError("String size " + length +

" exceeds maximum " + Integer.MAX_VALUE);

return (int)length;

}

/**

public byte[] parseHex(CharSequence string) {

return parseHex(string, 0, string.length());

}

/**

public byte[] parseHex(CharSequence string, int fromIndex, int toIndex) {

Objects.requireNonNull(string, "string");

Objects.checkFromToIndex(fromIndex, toIndex, string.length());

if (fromIndex != 0 || toIndex != string.length()) {

string = string.subSequence(fromIndex, toIndex);

}

if (string.isEmpty())

return EMPTY_BYTES;

if (delimiter.isEmpty() && prefix.isEmpty() && suffix.isEmpty())

return parseNoDelimiter(string);

// avoid overflow for max length prefix or suffix

long valueChars = prefix.length() + 2L + suffix.length();

long stride = valueChars + delimiter.length();

if ((string.length() - valueChars) % stride != 0)

throw new IllegalArgumentException("extra or missing delimiters " +

"or values consisting of prefix, two hexadecimal digits, and suffix");

checkLiteral(string, 0, prefix);

checkLiteral(string, string.length() - suffix.length(), suffix);

String between = suffix + delimiter + prefix;

final int len = (int)((string.length() - valueChars) / stride + 1L);

byte[] bytes = new byte[len];

int i, offset;

for (i = 0, offset = prefix.length(); i < len - 1; i++, offset += 2 + between.length()) {

bytes[i] = (byte) fromHexDigits(string, offset);

checkLiteral(string, offset + 2, between);

}

bytes[i] = (byte) fromHexDigits(string, offset);

return bytes;

}

/**

public byte[] parseHex(char[] chars, int fromIndex, int toIndex) {

Objects.requireNonNull(chars, "chars");

Objects.checkFromToIndex(fromIndex, toIndex, chars.length);

CharBuffer cb = CharBuffer.wrap(chars, fromIndex, toIndex - fromIndex);

return parseHex(cb);

}

/**

private static void checkLiteral(CharSequence string, int index, String literal) {

assert index <= string.length() - literal.length() : "pre-checked invariant error";

if (literal.isEmpty() ||

(literal.length() == 1 && literal.charAt(0) == string.charAt(index))) {

return;

}

for (int i = 0; i < literal.length(); i++) {

if (string.charAt(index + i) != literal.charAt(i)) {

throw new IllegalArgumentException(escapeNL("found: \"" +

string.subSequence(index, index + literal.length()) +

"\", expected: \"" + literal + "\", index: " + index +

" ch: " + (int)string.charAt(index + i)));

}

}

}

/**

private static String escapeNL(String string) {

return string.replace("\n", "\\n")

.replace("\r", "\\r");

}

/**

public char toLowHexDigit(int value) {

value = value & 0xf;

if (value < 10) {

return (char)('0' + value);

}

if (!ucase) {

return (char)('a' - 10 + value);

}

return (char)('A' - 10 + value);

}

/**

public char toHighHexDigit(int value) {

value = (value >> 4) & 0xf;

if (value < 10) {

return (char)('0' + value);

}

if (!ucase) {

return (char)('a' - 10 + value);

}

return (char)('A' - 10 + value);

}

/**

public <A extends Appendable> A toHexDigits(A out, byte value) {

try {

out.append(toHighHexDigit(value)); // implicit null-check

out.append(toLowHexDigit(value));

return out;

} catch (IOException ioe) {

throw new UncheckedIOException(ioe.getMessage(), ioe);

}

}

/**

public String toHexDigits(byte value) {

byte[] rep = new byte[2];

rep[0] = (byte)toHighHexDigit(value);

rep[1] = (byte)toLowHexDigit(value);

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

public String toHexDigits(char value) {

return toHexDigits((short)value);

}

/**

public String toHexDigits(short value) {

byte[] rep = new byte[4];

rep[0] = (byte)toHighHexDigit((byte)(value >> 8));

rep[1] = (byte)toLowHexDigit((byte)(value >> 8));

rep[2] = (byte)toHighHexDigit((byte)value);

rep[3] = (byte)toLowHexDigit((byte)value);

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

public String toHexDigits(int value) {

byte[] rep = new byte[8];

rep[0] = (byte)toHighHexDigit((byte)(value >> 24));

rep[1] = (byte)toLowHexDigit((byte)(value >> 24));

rep[2] = (byte)toHighHexDigit((byte)(value >> 16));

rep[3] = (byte)toLowHexDigit((byte)(value >> 16));

rep[4] = (byte)toHighHexDigit((byte)(value >> 8));

rep[5] = (byte)toLowHexDigit((byte)(value >> 8));

rep[6] = (byte)toHighHexDigit((byte)value);

rep[7] = (byte)toLowHexDigit((byte)value);

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

public String toHexDigits(long value) {

byte[] rep = new byte[16];

rep[0] = (byte)toHighHexDigit((byte)(value >>> 56));

rep[1] = (byte)toLowHexDigit((byte)(value >>> 56));

rep[2] = (byte)toHighHexDigit((byte)(value >>> 48));

rep[3] = (byte)toLowHexDigit((byte)(value >>> 48));

rep[4] = (byte)toHighHexDigit((byte)(value >>> 40));

rep[5] = (byte)toLowHexDigit((byte)(value >>> 40));

rep[6] = (byte)toHighHexDigit((byte)(value >>> 32));

rep[7] = (byte)toLowHexDigit((byte)(value >>> 32));

rep[8] = (byte)toHighHexDigit((byte)(value >>> 24));

rep[9] = (byte)toLowHexDigit((byte)(value >>> 24));

rep[10] = (byte)toHighHexDigit((byte)(value >>> 16));

rep[11] = (byte)toLowHexDigit((byte)(value >>> 16));

rep[12] = (byte)toHighHexDigit((byte)(value >>> 8));

rep[13] = (byte)toLowHexDigit((byte)(value >>> 8));

rep[14] = (byte)toHighHexDigit((byte)value);

rep[15] = (byte)toLowHexDigit((byte)value);

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

public String toHexDigits(long value, int digits) {

if (digits < 0 || digits > 16)

throw new IllegalArgumentException("number of digits: " + digits);

if (digits == 0)

return "";

byte[] rep = new byte[digits];

for (int i = rep.length - 1; i >= 0; i--) {

rep[i] = (byte)toLowHexDigit((byte)(value));

value = value >>> 4;

}

return jla.uncheckedNewStringWithLatin1Bytes(rep);

}

/**

private static byte[] parseNoDelimiter(CharSequence string) {

if ((string.length() & 1) != 0)

throw new IllegalArgumentException("string length not even: " +

string.length());

byte[] bytes = new byte[string.length() / 2];

for (int i = 0; i < bytes.length; i++) {

bytes[i] = (byte) fromHexDigits(string, i * 2);

}

return bytes;

}

/**

private static int checkDigitCount(int fromIndex, int toIndex, int limit) {

int length = toIndex - fromIndex;

if (length > limit)

throw new IllegalArgumentException("string length greater than " +

limit + ": " + length);

return length;

}

/**

public static boolean isHexDigit(int ch) {

return ((ch >>> 7) == 0 && DIGITS[ch] >= 0);

}

/**

public static int fromHexDigit(int ch) {

int value;

if ((ch >>> 7) == 0 && (value = DIGITS[ch]) >= 0) {

return value;

}

throw new NumberFormatException("not a hexadecimal digit: \"" + (char) ch + "\" = " + ch);

}

/**

private static int fromHexDigits(CharSequence string, int index) {

int high = fromHexDigit(string.charAt(index));

int low = fromHexDigit(string.charAt(index + 1));

return (high << 4) | low;

}

/**

public static int fromHexDigits(CharSequence string) {

return fromHexDigits(string, 0, string.length());

}

/**

public static int fromHexDigits(CharSequence string, int fromIndex, int toIndex) {

Objects.requireNonNull(string, "string");

Objects.checkFromToIndex(fromIndex, toIndex, string.length());

int length = checkDigitCount(fromIndex, toIndex, 8);

int value = 0;

for (int i = 0; i < length; i++) {

value = (value << 4) + fromHexDigit(string.charAt(fromIndex + i));

}

return value;

}

/**

public static long fromHexDigitsToLong(CharSequence string) {

return fromHexDigitsToLong(string, 0, string.length());

}

/**