@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); }
@Override public Iterator<? extends Map.Entry<Key, Value>> apply(Key k, Value v) { // log.info("keyretainonlyapply see "+k.toStringNoTime()+" -> "+INTEGER_LEXICODER.decode(v.get())); final int i = INTEGER_LEXICODER.decode(v.get()); final int inew = i % 2 == 0 ? (i/2)*(i-1) : ((i-1)/2)*i; // try to avoi overflow final Value vnew = new Value(INTEGER_LEXICODER.encode(inew)); return Iterators.singletonIterator(new AbstractMap.SimpleImmutableEntry<>(k, vnew)); }
break; case LEX_LONG: Anum = lex.decode(Aval.get()); Bnum = lex.decode(Bval.get()); break; default: throw new AssertionError(); case DOUBLE: vnew = Double.toString(nnew.doubleValue()).getBytes(StandardCharsets.UTF_8); break; case BIGDECIMAL: vnew = nnew.toString().getBytes(StandardCharsets.UTF_8); break; case LEX_LONG: vnew = lex.encode(nnew.longValue()); break; default: throw new AssertionError();
return getLexicoder(type).encode(toEncode);
@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(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)); } }
/** * {@inheritDoc} * * @return a byte array containing the concatenation of each element in the list encoded. */ @Override public byte[] encode(List<LT> v) { byte[][] encElements = new byte[v.size()][]; int index = 0; for (LT element : v) { encElements[index++] = escape(lexicoder.encode(element)); } return concat(encElements); }
@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; } }
@Override protected ComparablePair<A,B> decodeUnchecked(byte[] data, int offset, int len) { byte[][] fields = split(data, offset, len); if (fields.length != 2) { throw new RuntimeException("Data does not have 2 fields, it has " + fields.length); } return new ComparablePair<>(firstLexicoder.decode(unescape(fields[0])), secondLexicoder.decode(unescape(fields[1]))); }
@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)); } }
private static byte[] transformVal(final String str) { if( D4mDbInsert.isIntEncodeValueAndDropEmpty() || D4mDbInsert.isIntEncodeKeyAndPrependLastByteRev()) return str.equals("1") ? EMPTY_BYTES : LEX.encode(Integer.parseInt(str)); else return str.getBytes(StandardCharsets.UTF_8); } private static final byte[] EMPTY_BYTES = new byte[0];
@Override public void update(Key k, Value v) { int tri = UINTEGER_LEXICODER.decode(v.get()); if( tri % 2 == 0 ) return; triangles += (tri-1)/2; }
/** * {@inheritDoc} * * @return a byte array containing the concatenation of each element in the list encoded. */ @Override public byte[] encode(List<LT> v) { byte[][] encElements = new byte[v.size()][]; int index = 0; for (LT element : v) { encElements[index++] = escape(lexicoder.encode(element)); } return concat(encElements); }
@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; } }
public Pair<Long, Long> ingestMap(SortedMap<ArrayHolder, Integer> map, BatchWriter bw, byte[] sampleidb, SpecificKmerAction specificKmerAction) throws MutationsRejectedException { long ingested = 0, totalsum = 0; for (Map.Entry<ArrayHolder, Integer> entry : map.entrySet()) { Mutation m = new Mutation(specificKmerAction == null ? entry.getKey().b : specificKmerAction.transformKmer(entry.getKey().b)); long lv = entry.getValue().longValue(); totalsum += lv; m.put(EMPTY_BYTES, sampleidb, LEX.encode(lv)); bw.addMutation(m); ingested++; } return new Pair<>(ingested, totalsum); } }
@Override protected ComparablePair<A,B> decodeUnchecked(byte[] data, int offset, int len) { byte[][] fields = split(data, offset, len); if (fields.length != 2) { throw new RuntimeException("Data does not have 2 fields, it has " + fields.length); } return new ComparablePair<>(firstLexicoder.decode(unescape(fields[0])), secondLexicoder.decode(unescape(fields[1]))); }