@Override public Object get(int i) { final int startOffset = i == 0 ? 0 : endOffsets[i-1]; final int endOffset = endOffsets[i]; return bytes.slice(startOffset, endOffset - startOffset).toBytesRef(); } @Override
/** * Returns the sliced {@link BytesReference}. If the {@link XContentType} is JSON, the byte preceding the marker is checked to see * if it is a carriage return and if so, the BytesReference is sliced so that the carriage return is ignored */ private BytesReference sliceTrimmingCarriageReturn(BytesReference bytesReference, int from, int nextMarker, XContentType xContentType) { final int length; if (XContentType.JSON == xContentType && bytesReference.get(nextMarker - 1) == (byte) '\r') { length = nextMarker - from - 1; } else { length = nextMarker - from; } return bytesReference.slice(from, length); }
void logOutboundMessage(TcpChannel channel, BytesReference message) { if (logger.isTraceEnabled()) { try { BytesReference withoutHeader = message.slice(HEADER_SIZE, message.length() - HEADER_SIZE); String logMessage = format(channel, withoutHeader, "WRITE"); logger.trace(logMessage); } catch (IOException e) { logger.trace("an exception occurred formatting a WRITE trace message", e); } } }
@Override public BytesReference slice(int from, int length) { FutureObjects.checkFromIndexSize(from, length, this.length); if (length == 0) { return BytesArray.EMPTY; } // for slices we only need to find the start and the end reference // adjust them and pass on the references in between as they are fully contained final int to = from + length; final int limit = getOffsetIndex(to - 1); final int start = getOffsetIndex(from); final BytesReference[] inSlice = new BytesReference[1 + (limit - start)]; for (int i = 0, j = start; i < inSlice.length; i++) { inSlice[i] = references[j++]; } int inSliceOffset = from - offsets[start]; if (inSlice.length == 1) { return inSlice[0].slice(inSliceOffset, length); } // now adjust slices in front and at the end inSlice[0] = inSlice[0].slice(inSliceOffset, inSlice[0].length() - inSliceOffset); inSlice[inSlice.length-1] = inSlice[inSlice.length-1].slice(0, to - offsets[limit]); return new CompositeBytesReference(inSlice); }
/** * Attempts to a decode a message from the provided bytes. If a full message is not available, null is * returned. If the message is a ping, an empty {@link BytesReference} will be returned. * * @param networkBytes the will be read * @return the message decoded * @throws StreamCorruptedException if the message header format is not recognized * @throws TcpTransport.HttpOnTransportException if the message header appears to be an HTTP message * @throws IllegalArgumentException if the message length is greater that the maximum allowed frame size. * This is dependent on the available memory. */ static BytesReference decodeFrame(BytesReference networkBytes) throws IOException { int messageLength = readMessageLength(networkBytes); if (messageLength == -1) { return null; } else { int totalLength = messageLength + BYTES_NEEDED_FOR_MESSAGE_SIZE; if (totalLength > networkBytes.length()) { return null; } else if (totalLength == 6) { return EMPTY_BYTES_REFERENCE; } else { return networkBytes.slice(BYTES_NEEDED_FOR_MESSAGE_SIZE, messageLength); } } }
try { final int bytesConsumed = TcpHeader.REQUEST_ID_SIZE + TcpHeader.STATUS_SIZE + TcpHeader.VERSION_ID_SIZE; compressor = CompressorFactory.compressor(message.slice(bytesConsumed, message.length() - bytesConsumed)); } catch (NotCompressedException ex) { throw new IllegalStateException(ex);
try (InputStream stream = data.slice(from, nextMarker - from).streamInput(); XContentParser parser = xContent.createParser(registry, LoggingDeprecationHandler.INSTANCE, stream)) { Map<String, Object> source = parser.map(); break; BytesReference bytes = data.slice(from, nextMarker - from); try (InputStream stream = bytes.streamInput(); XContentParser parser = xContent.createParser(registry, LoggingDeprecationHandler.INSTANCE, stream)) {
try { final int bytesConsumed = TcpHeader.REQUEST_ID_SIZE + TcpHeader.STATUS_SIZE + TcpHeader.VERSION_ID_SIZE; compressor = CompressorFactory.compressor(reference.slice(bytesConsumed, reference.length() - bytesConsumed)); } catch (NotCompressedException ex) { int maxToRead = Math.min(reference.length(), 10);
@Override public Object get(int i) { final int startOffset = i == 0 ? 0 : endOffsets[i-1]; final int endOffset = endOffsets[i]; return bytes.slice(startOffset, endOffset - startOffset).toBytesRef(); } @Override
@Override public Object get(int i) { final int startOffset = i == 0 ? 0 : endOffsets[i-1]; final int endOffset = endOffsets[i]; return bytes.slice(startOffset, endOffset - startOffset).toBytesRef(); } @Override
public Object get(int i) { final int startOffset = i == 0 ? 0 : endOffsets[i-1]; final int endOffset = endOffsets[i]; return bytes.slice(startOffset, endOffset - startOffset).toBytesRef(); } public int size() {
/** * Returns the sliced {@link BytesReference}. If the {@link XContentType} is JSON, the byte preceding the marker is checked to see * if it is a carriage return and if so, the BytesReference is sliced so that the carriage return is ignored */ private BytesReference sliceTrimmingCarriageReturn(BytesReference bytesReference, int from, int nextMarker, XContentType xContentType) { final int length; if (XContentType.JSON == xContentType && bytesReference.get(nextMarker - 1) == (byte) '\r') { length = nextMarker - from - 1; } else { length = nextMarker - from; } return bytesReference.slice(from, length); }
/** * Returns the sliced {@link BytesReference}. If the {@link XContentType} is JSON, the byte preceding the marker is checked to see * if it is a carriage return and if so, the BytesReference is sliced so that the carriage return is ignored */ private BytesReference sliceTrimmingCarriageReturn(BytesReference bytesReference, int from, int nextMarker, XContentType xContentType) { final int length; if (XContentType.JSON == xContentType && bytesReference.get(nextMarker - 1) == (byte) '\r') { length = nextMarker - from - 1; } else { length = nextMarker - from; } return bytesReference.slice(from, length); }
/** * Returns the sliced {@link BytesReference}. If the {@link XContentType} is JSON, the byte preceding the marker is checked to see * if it is a carriage return and if so, the BytesReference is sliced so that the carriage return is ignored */ private BytesReference sliceTrimmingCarriageReturn(BytesReference bytesReference, int from, int nextMarker, XContentType xContentType) { final int length; if (XContentType.JSON == xContentType && bytesReference.get(nextMarker - 1) == (byte) '\r') { length = nextMarker - from - 1; } else { length = nextMarker - from; } return bytesReference.slice(from, length); }
try (InputStream stream = data.slice(from, nextMarker - from).streamInput(); XContentParser parser = xContent .createParser(NamedXContentRegistry.EMPTY, LoggingDeprecationHandler.INSTANCE, stream)) {
public void testEquals() throws IOException { BytesReference bytesReference = newBytesReference(randomIntBetween(100, PAGE_SIZE * randomIntBetween(2, 5))); BytesReference copy = bytesReference.slice(0, bytesReference.length()); // get refs & compare assertEquals(copy, bytesReference); int sliceFrom = randomIntBetween(0, bytesReference.length()); int sliceLength = randomIntBetween(0, bytesReference.length() - sliceFrom); assertEquals(copy.slice(sliceFrom, sliceLength), bytesReference.slice(sliceFrom, sliceLength)); BytesRef bytesRef = BytesRef.deepCopyOf(copy.toBytesRef()); assertEquals(new BytesArray(bytesRef), copy); int offsetToFlip = randomIntBetween(0, bytesRef.length - 1); int value = ~Byte.toUnsignedInt(bytesRef.bytes[bytesRef.offset+offsetToFlip]); bytesRef.bytes[bytesRef.offset+offsetToFlip] = (byte)value; assertNotEquals(new BytesArray(bytesRef), copy); }
public void testSliceToBytesRef() throws IOException { int length = randomIntBetween(0, PAGE_SIZE); BytesReference pbr = newBytesReferenceWithOffsetOfZero(length); // get a BytesRef from a slice int sliceOffset = randomIntBetween(0, pbr.length()); int sliceLength = randomIntBetween(0, pbr.length() - sliceOffset); BytesRef sliceRef = pbr.slice(sliceOffset, sliceLength).toBytesRef(); if (sliceLength == 0 && sliceOffset != sliceRef.offset) { // some impls optimize this to an empty instance then the offset will be 0 assertEquals(0, sliceRef.offset); } else { // note that these are only true if we have <= than a page, otherwise offset/length are shifted assertEquals(sliceOffset, sliceRef.offset); } assertEquals(sliceLength, sliceRef.length); }
public void testSliceWriteToOutputStream() throws IOException { int length = randomIntBetween(10, PAGE_SIZE * randomIntBetween(2, 5)); BytesReference pbr = newBytesReference(length); int sliceOffset = randomIntBetween(1, length / 2); int sliceLength = length - sliceOffset; BytesReference slice = pbr.slice(sliceOffset, sliceLength); BytesStreamOutput sliceOut = new BytesStreamOutput(sliceLength); slice.writeTo(sliceOut); assertEquals(slice.length(), sliceOut.size()); assertArrayEquals(BytesReference.toBytes(slice), BytesReference.toBytes(sliceOut.bytes())); sliceOut.close(); }
public void testSliceIterator() throws IOException { int length = randomIntBetween(10, PAGE_SIZE * randomIntBetween(2, 8)); BytesReference pbr = newBytesReference(length); int sliceOffset = randomIntBetween(0, pbr.length()); int sliceLength = randomIntBetween(0, pbr.length() - sliceOffset); BytesReference slice = pbr.slice(sliceOffset, sliceLength); BytesRefIterator iterator = slice.iterator(); BytesRef ref = null; BytesRefBuilder builder = new BytesRefBuilder(); while((ref = iterator.next()) != null) { builder.append(ref); } assertArrayEquals(BytesReference.toBytes(slice), BytesRef.deepCopyOf(builder.toBytesRef()).bytes); }
public void testSliceCopyBytesRef() throws IOException { int length = randomIntBetween(10, PAGE_SIZE * randomIntBetween(2, 8)); BytesReference pbr = newBytesReference(length); int sliceOffset = randomIntBetween(0, pbr.length()); int sliceLength = randomIntBetween(0, pbr.length() - sliceOffset); BytesReference slice = pbr.slice(sliceOffset, sliceLength); BytesArray ba1 = new BytesArray(slice.toBytesRef(), true); BytesArray ba2 = new BytesArray(slice.toBytesRef(), true); assertNotNull(ba1); assertNotNull(ba2); assertNotSame(ba1.array(), ba2.array()); assertArrayEquals(BytesReference.toBytes(slice), ba1.array()); assertArrayEquals(BytesReference.toBytes(slice), ba2.array()); assertArrayEquals(ba1.array(), ba2.array()); }