@Override public Map<K, V> decode(byte[] b) { byte[][] escapedElements = split(b); Map<K, V> decodedMap = new HashMap<>(); for (int i = 0; i < escapedElements.length; i += 2) { K key = keyLexicoder.decode(unescape(escapedElements[i])); V value = valueLexicoder.decode(unescape(escapedElements[i + 1])); decodedMap.put(key, value); } return decodedMap; } }
@Override public byte[] encode(Map<K, V> v) { byte[][] elements = new byte[v.size() * 2][]; int index = 0; for (Entry<K, V> entry : v.entrySet()) { elements[index++] = escape(keyLexicoder.encode(entry.getKey())); elements[index++] = escape(valueLexicoder.encode(entry.getValue())); } return concat(elements); }
@Override public <T> T decode(Type type, byte[] value) { return (T) getLexicoder(type).decode(value); }
return getLexicoder(type).encode(toEncode);
@Override public byte[] encode(Date data) { return longEncoder.encode(data.getTime()); }
@Override protected Long decodeUnchecked(byte[] data, int offset, int len) { return super.decodeUnchecked(data, offset, len) ^ 0x8000000000000000L; } }
@Override public byte[] encode(Integer i) { return uil.encode(i ^ 0x80000000); }
@Override protected Integer decodeUnchecked(byte[] data, int offset, int len) { return uil.decodeUnchecked(data, offset, len) ^ 0x80000000; }
@Override public byte[] encode(Long l) { return super.encode(l ^ 0x8000000000000000L); }
private static ListLexicoder getListLexicoder(Type elementType) { ListLexicoder<?> listLexicoder = LIST_LEXICODERS.get(elementType.getTypeSignature()); if (listLexicoder == null) { listLexicoder = new ListLexicoder(getLexicoder(Types.getElementType(elementType))); LIST_LEXICODERS.put(elementType.getTypeSignature(), listLexicoder); } return listLexicoder; }
@Override public List<Long> decode(byte[] b) { // This concrete implementation is provided for binary compatibility with 1.6; it can be // removed in 2.0. See ACCUMULO-3789. return super.decode(b); }
@Override public T decode(byte[] b) { requireNonNull(b, "cannot decode null byte array"); return decodeUnchecked(b, 0, b.length); }
@Override protected Date decodeUnchecked(byte[] data, int offset, int len) { return new Date(longEncoder.decodeUnchecked(data, offset, len)); }
@Override public byte[] encode(T data) { byte[] bytes = escape(lexicoder.encode(data)); byte[] ret = new byte[bytes.length + 1]; for (int i = 0; i < bytes.length; i++) ret[i] = (byte) (0xff - (0xff & bytes[i])); ret[bytes.length] = (byte) 0xff; return ret; }
@Override protected T decodeUnchecked(byte[] data, int offset, int len) { byte ret[] = new byte[len - 1]; int dataIndex; for (int i = 0; i < ret.length; i++) { dataIndex = offset + i; ret[i] = (byte) (0xff - (0xff & data[dataIndex])); } return lexicoder.decode(unescape(ret)); } }
@Override protected Double decodeUnchecked(byte[] data, int offset, int len) { long l = longEncoder.decodeUnchecked(data, offset, len); if (l < 0) l = l ^ 0x8000000000000000L; else l = ~l; return Double.longBitsToDouble(l); }
@Override public byte[] encode(Float f) { int i = Float.floatToRawIntBits(f); if (i < 0) { i = ~i; } else { i = i ^ 0x80000000; } return intEncoder.encode(i); }
@Override protected Float decodeUnchecked(byte[] b, int offset, int len) throws ValueFormatException { int i = intEncoder.decodeUnchecked(b, offset, len); if (i < 0) { i = i ^ 0x80000000; } else { i = ~i; } return Float.intBitsToFloat(i); }
@Override public byte[] encode(Double d) { long l = Double.doubleToRawLongBits(d); if (l < 0) l = ~l; else l = l ^ 0x8000000000000000L; return longEncoder.encode(l); }
@Override protected List<LT> decodeUnchecked(byte[] b, int offset, int len) { byte[][] escapedElements = split(b, offset, len); ArrayList<LT> ret = new ArrayList<>(escapedElements.length); for (byte[] escapedElement : escapedElements) { ret.add(lexicoder.decode(unescape(escapedElement))); } return ret; } }