public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ByteBuffer buf = ByteBuffer.wrap(array, index, length); int readBytes = 0; do { int localReadBytes; try { localReadBytes = in.read(buf); } catch (ClosedChannelException e) { localReadBytes = -1; } if (localReadBytes < 0) { if (readBytes == 0) { return -1; } else { break; } } else if (localReadBytes == 0) { break; } readBytes += localReadBytes; } while (readBytes < length); return readBytes; }
public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ByteBuffer buf = ByteBuffer.wrap(array, index, length); int readBytes = 0; do { int localReadBytes; try { localReadBytes = in.read(buf); } catch (ClosedChannelException e) { localReadBytes = -1; } if (localReadBytes < 0) { if (readBytes == 0) { return -1; } else { break; } } if (localReadBytes == 0) { break; } readBytes += localReadBytes; } while (readBytes < length); return readBytes; }
public static void scatter() { ByteBuffer header = ByteBuffer.allocate(13); ByteBuffer body = ByteBuffer.allocate(100); ByteBuffer[] bufferArray = { header, body }; ScatteringByteChannel channel = getChannel(); try { channel.read(bufferArray); } catch (IOException e) { e.printStackTrace(); } header.rewind(); body.rewind(); String headerStr = convertBufferToString(header); String bodyStr = convertBufferToString(body); System.out.println(headerStr); System.out.println(bodyStr); }
@Override public int writeBytes(ScatteringByteChannel channel) throws IOException { if (buffer.readableBytes() > 0) { this.buffer.markReaderIndex(); this.buffer.discardReadBytes(); // compact the buffer } else { buffer.clear(); } int readBytes = 0; while (buffer.writableBytes() > 0) { int localReadBytes = buffer.writeBytes(channel, buffer.writableBytes()); if (localReadBytes < 0) { break; } readBytes += localReadBytes; } return readBytes; }
@Override public int writeBytes(ScatteringByteChannel ch, int max) throws IOException { ByteBuffer tmp = ByteBuffer.allocateDirect(max); int length = ch.read(tmp); writeBytes(tmp); return length; }
@Override public int writeBytes(ScatteringByteChannel in, int length) throws IOException { int writtenBytes = setBytes(writerIndex, in, length); if (writtenBytes > 0) { writerIndex += writtenBytes; } return writtenBytes; }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { // adapted from UnpooledDirectByteBuf: checkIndex(index, length); ByteBuffer tmpBuf = memorySegment.wrap(index, length); try { return in.read(tmpBuf); } catch (ClosedChannelException ignored) { return -1; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ensureAccessible(); ByteBuffer tmpBuf = internalNioBuffer(); tmpBuf.clear().position(index).limit(index + length); try { return in.read(tmpNioBuf); } catch (ClosedChannelException ignored) { return -1; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { checkIndex(index, length); index = idx(index); try { return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length)); } catch (ClosedChannelException ignored) { return -1; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ensureAccessible(); try { return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length)); } catch (ClosedChannelException ignored) { return -1; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { checkIndex(index, length); ByteBuffer tmpBuf = internalNioBuffer(); index = idx(index); tmpBuf.clear().position(index).limit(index + length); try { return in.read(tmpBuf); } catch (ClosedChannelException ignored) { return -1; } }
@Override public int writeBytes(ScatteringByteChannel in, int length) throws IOException { ensureAccessible(); ensureWritable(length); int writtenBytes = setBytes(writerIndex, in, length); if (writtenBytes > 0) { writerIndex += writtenBytes; } return writtenBytes; }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ensureAccessible(); ByteBuffer tmpBuf = internalNioBuffer(); tmpBuf.clear().position(index).limit(index + length); try { return in.read(tmpBuf); } catch (ClosedChannelException ignored) { return -1; } }
@Override public boolean copyFromChannel(ScatteringByteChannel channel) throws IOException { switch (dataFormat) { case BuiltinStorages.DRAW: return fillDrawBuffer(channel); default: throw new TajoInternalError(new NotImplementedException("Heap memory writer not implemented yet")); } }
protected boolean fillDrawBuffer(ScatteringByteChannel channel) throws IOException { reset(); int readBytes = memory.writeBytes(channel); if (readBytes > 0) { // get row capacity in buffer while (memory.isReadable()) { if (memory.readableBytes() < SizeOf.SIZE_OF_INT) { return true; } int recordSize = PlatformDependent.getInt(memory.address() + memory.readerPosition()); assert recordSize > 0; if (memory.readableBytes() < recordSize) { return true; } else { memory.readerPosition(memory.readerPosition() + recordSize); } rowNum++; } return true; } else { return false; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { ensureAccessible(); ByteBuffer tmpBuf = internalNioBuffer(); tmpBuf.clear().position(index).limit(index + length); try { return in.read(tmpNioBuf); } catch (ClosedChannelException e) { return -1; } }
@Override public int setBytes(int index, ScatteringByteChannel in, int length) throws IOException { checkIndex(index, length); index = idx(index); try { return in.read((ByteBuffer) internalNioBuffer().clear().position(index).limit(index + length)); } catch (ClosedChannelException e) { return -1; } }