public static StaticBuffer fillBuffer(int len, byte value) { byte[] res = new byte[len]; for (int i = 0; i < len; i++) res[i]=value; return StaticArrayBuffer.of(res); }
public static StaticBuffer stringToByteBuffer(String s) { byte[] b; try { b = s.getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } ByteBuffer bb = ByteBuffer.allocate(b.length); bb.put(b); bb.flip(); return StaticArrayBuffer.of(bb); }
private StaticBuffer string2StaticBuffer(final String s) { ByteBuffer out = ByteBuffer.wrap(s.getBytes(Charset.forName("UTF-8"))); return StaticArrayBuffer.of(out); }
public static StaticBuffer getLongBuffer(long id) { ByteBuffer buffer = ByteBuffer.allocate(longSize); buffer.putLong(id); byte[] arr = buffer.array(); Preconditions.checkArgument(arr.length == longSize); return StaticArrayBuffer.of(arr); }
public static StaticBuffer getIntBuffer(int id) { ByteBuffer buffer = ByteBuffer.allocate(intSize); buffer.putInt(id); byte[] arr = buffer.array(); Preconditions.checkArgument(arr.length == intSize); return StaticArrayBuffer.of(arr); }
public static StaticBuffer getIntBuffer(int[] ids) { ByteBuffer buffer = ByteBuffer.allocate(intSize * ids.length); for (int id : ids) buffer.putInt(id); byte[] arr = buffer.array(); Preconditions.checkArgument(arr.length == intSize * ids.length); return StaticArrayBuffer.of(arr); }
@Override public StaticBuffer getStaticBufferFlipBytes(int from, int to) { ByteBuffer b = buffer.duplicate(); b.flip(); Preconditions.checkArgument(from>=0 && from<=to); Preconditions.checkArgument(to<=b.limit()); for (int i=from;i<to;i++) b.put(i,(byte)~b.get(i)); return StaticArrayBuffer.of(b); } }
public static StaticArrayBuffer of(ByteBuffer b) { if (b.hasArray()) { return new StaticArrayBuffer(b.array(),b.arrayOffset()+b.position(),b.arrayOffset()+b.limit()); } else { byte[] array = new byte[b.remaining()]; b.mark(); b.get(array); b.reset(); return StaticArrayBuffer.of(array); } }
ByteBuffer val = ByteBuffer.allocate(1); val.put((byte) -1); StaticBuffer staticVal = StaticArrayBuffer.of(val); key.putInt(k + offset); key.flip(); StaticBuffer staticKey = StaticArrayBuffer.of(key); col.putInt(c + offset); col.flip(); StaticBuffer staticCol = StaticArrayBuffer.of(col); rowAdditions.add(StaticArrayEntry.of(staticCol, staticVal));
private static StaticBuffer nextBiggerBuffer(StaticBuffer buffer, boolean allowOverflow) { int len = buffer.length(); byte[] next = new byte[len]; boolean carry = true; for (int i = len - 1; i >= 0; i--) { byte b = buffer.getByte(i); if (carry) { b++; if (b != 0) carry = false; } next[i]=b; } if (carry && allowOverflow) { return zeroBuffer(len); } else if (carry) { throw new IllegalArgumentException("Buffer overflow incrementing " + buffer); } else { return StaticArrayBuffer.of(next); } }
public static void loadValues(KeyColumnValueStore store, StoreTransaction tx, String[][] values, int shiftEveryNthRow, int shiftSliceLength) throws BackendException { for (int i = 0; i < values.length; i++) { final List<Entry> entries = new ArrayList<>(); for (int j = 0; j < values[i].length; j++) { StaticBuffer col; if (0 < shiftEveryNthRow && 0 == i/* +1 */ % shiftEveryNthRow) { ByteBuffer bb = ByteBuffer.allocate(shiftSliceLength + 9); for (int s = 0; s < shiftSliceLength; s++) { bb.put((byte) -1); } bb.put(KeyValueStoreUtil.getBuffer(j + 1).asByteBuffer()); bb.flip(); col = StaticArrayBuffer.of(bb); // col = KeyValueStoreUtil.getBuffer(j + values[i].length + // 100); } else { col = KeyValueStoreUtil.getBuffer(j); } entries.add(StaticArrayEntry.of(col, KeyValueStoreUtil .getBuffer(values[i][j]))); } if (!entries.isEmpty()) { store.mutate(KeyValueStoreUtil.getBuffer(i), entries, KeyColumnValueStore.NO_DELETIONS, tx); } } }
@Test public void testFuzzMessagesSerial() throws Exception { final int maxLen = 1024 * 4; final int rounds = 32; StoringReader reader = new StoringReader(rounds); final List<StaticBuffer> expected = new ArrayList<>(rounds); Log l = manager.openLog("fuzz"); l.registerReader(ReadMarker.fromNow(),reader); Random rand = new Random(); for (int i = 0; i < rounds; i++) { //int len = rand.nextInt(maxLen + 1); int len = maxLen; if (0 == len) len = 1; // 0 would throw IllegalArgumentException byte[] raw = new byte[len]; rand.nextBytes(raw); StaticBuffer sb = StaticArrayBuffer.of(raw); l.add(sb); expected.add(sb); Thread.sleep(100L); } reader.await(TIMEOUT_MS); assertEquals(rounds, reader.msgCount); assertEquals(expected, reader.messages); }
for (String qString : queryStrings) { String queryTokens[] = qString.split("/"); StaticBuffer start = StaticArrayBuffer.of(Hex.hexToBytes(queryTokens[0])); StaticBuffer end = StaticArrayBuffer.of(Hex.hexToBytes(queryTokens[1])); SliceQuery query = new SliceQuery(start, end); int limit = Integer.valueOf(queryTokens[2]);
private StaticBuffer concatenate(StaticBuffer front, StaticBuffer end, final boolean appendLength) { final boolean addKeyLength = !hasFixedKeyLength() && appendLength; int length = getLength(front); byte[] result = new byte[length + end.length() + (addKeyLength ? variableKeyLengthSize : 0)]; int position = 0; for (int i = 0; i < front.length(); i++) result[position++] = front.getByte(i); for (int i = 0; i < end.length(); i++) result[position++] = end.getByte(i); if (addKeyLength) { result[position++] = (byte) (length >>> 8); result[position] = (byte) length; } return StaticArrayBuffer.of(result); }
new SliceQuery(StaticArrayBuffer.of(new byte[]{(byte) 2}), BufferUtil.oneBuffer(1)), new SliceQuery(BufferUtil.zeroBuffer(1), BufferUtil.oneBuffer(1)))); runner.run(new SimpleScanJob(), conf10, SimpleScanJob.class.getName() + "#ROOT_NS");
/** * Companion to {@link #getStartKey(int)}. See its javadoc for details. */ private byte[] getEndKey(int regionCount) { ByteBuffer regionWidth = ByteBuffer.allocate(4); regionWidth.putInt((int)(((1L << 32) - 1L) / regionCount * (regionCount - 1))).flip(); return StaticArrayBuffer.of(regionWidth).getBytes(0, 4); }
@Override public StaticBuffer next() { ensureOpen(); currentRow = rows.next(); return StaticArrayBuffer.of(currentRow.getRow()); }
protected StaticBuffer decodeValue(final AttributeValue val) { if (null == val) { return null; } // Dynamo does not allow empty binary values, so we use a placeholder // for empty values if (Constants.EMPTY_BUFFER_PLACEHOLDER.equals(val.getS())) { return BufferUtil.emptyBuffer(); } return StaticArrayBuffer.of(val.getB()); }
EntryRecordIterator(final SliceQuery sliceQuery, final CQLColValGetter getter, final Iterator<Row> iterator, final StaticBuffer key) { this.getter = getter; final StaticBuffer sliceEnd = sliceQuery.getSliceEnd(); this.iterator = iterator .<Tuple3<StaticBuffer, StaticBuffer, Row>> map(row -> Tuple.of( StaticArrayBuffer.of(row.getBytes(CQLKeyColumnValueStore.COLUMN_COLUMN_NAME)), StaticArrayBuffer.of(row.getBytes(CQLKeyColumnValueStore.VALUE_COLUMN_NAME)), row)) .takeWhile(tuple -> key.equals(StaticArrayBuffer.of(tuple._3.getBytes(CQLKeyColumnValueStore.KEY_COLUMN_NAME))) && !sliceEnd.equals(tuple._1)) .take(sliceQuery.getLimit()); }
CQLResultSetKeyIterator(final SliceQuery sliceQuery, final CQLColValGetter getter, final ResultSet resultSet) { this.sliceQuery = sliceQuery; this.getter = getter; this.iterator = Iterator.ofAll(resultSet.iterator()) .peek(row -> { this.currentRow = row; this.currentKey = StaticArrayBuffer.of(row.getBytes(CQLKeyColumnValueStore.KEY_COLUMN_NAME)); }); }