@Override public int read() throws IOException { return hasRemaining() ? get() & BYTE_MASK : -1; }
@Override public int read(byte[] b, int off, int len) throws IOException { if (!hasRemaining()) { return -1; } int toRead = Math.min(remaining(), len); get(b, off, toRead); return toRead; } };
/** * @see ByteBuffer#get() */ public byte get() { if (!hasRemaining()) { throw new BufferUnderflowException(); } return get(position); }
/** * {@inheritDoc} */ @Override public int hashCode() { int hash = 0; Pointer oldPos = position.duplicate(); while (hasRemaining()) { hash *= 31; // NOSONAR, standard way of hashing hash += get(); } position = oldPos; return hash; }
/** * @see ByteBuffer#put(ByteBuffer) */ public IoBuffer put(IoBuffer src) { if (src == this) { // NOSONAR, checking the instance throw new IllegalArgumentException(); } if (remaining() < src.remaining()) { throw new BufferOverflowException(); } if (isReadOnly()) { throw new ReadOnlyBufferException(); } while (src.hasRemaining()) { put(src.get()); } return this; }
/** * @see ByteBuffer#slice() */ public IoBuffer slice() { position.updatePos(); IoBuffer out = new IoBuffer(); out.order(order()); position.getNode().getBuffer().position(position.getPositionInNode()); if (hasRemaining()) { tail.getBuffer().limit(limit.getPositionInNode()); for (BufferNode node = position.getNode(); node != limit.getNode(); node = node.getNext()) { if (node != head) { // NOSONAR, check if instances are the same. node.getBuffer().position(0); } out.add(node.getBuffer()); } if (tail != head) { // NOSONAR, check if instances are the same. tail.getBuffer().position(0); } out.add(tail.getBuffer().slice()); tail.getBuffer().limit(tail.getBuffer().capacity()); } position.getNode().getBuffer().position(0); return out; }
/** * {@inheritDoc} */ @Override public boolean equals(Object ob) { if (this == ob) { return true; } if (!(ob instanceof IoBuffer)) { return false; } IoBuffer that = (IoBuffer) ob; if (this.remaining() != that.remaining()) { return false; } int p = this.position(); int q = that.position(); while (this.hasRemaining() && that.hasRemaining()) { if (this.get() != that.get()) { this.position(p); that.position(q); return false; } } this.position(p); that.position(q); return true; }
assertEquals(10, ioBuffer.limit()); assertEquals(10, ioBuffer.capacity()); assertTrue(ioBuffer.hasRemaining()); assertTrue(ioBuffer.hasRemaining()); assertEquals("0123456789".charAt(i), ioBuffer.get()); assertFalse(ioBuffer.hasRemaining()); ioBuffer.get(); fail();
/** * Test the addition of 3 heap buffers, one being empty */ @Test public void testAddHeapBuffersOneEmpty() { ByteBuffer bb1 = ByteBuffer.allocate(5); bb1.put("012".getBytes()); bb1.flip(); ByteBuffer bb2 = ByteBuffer.allocate(0); ByteBuffer bb3 = ByteBuffer.allocate(5); bb3.put("3456".getBytes()); bb3.flip(); IoBuffer ioBuffer = IoBuffer.newInstance(); ioBuffer.add(bb1, bb2).add(bb3); assertEquals(0, ioBuffer.position()); assertEquals(7, ioBuffer.limit()); assertEquals(7, ioBuffer.capacity()); for (int i = 0; i < 7; i++) { assertTrue(ioBuffer.hasRemaining()); assertEquals("0123456".charAt(i), ioBuffer.get()); } try { ioBuffer.get(); fail(); } catch (BufferUnderflowException bufe) { assertTrue(true); } }
assertTrue(ioBuffer.hasRemaining()); assertTrue(ioBuffer.hasRemaining()); assertEquals('1', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('2', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('3', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('4', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('5', ioBuffer.get()); assertFalse(ioBuffer.hasRemaining()); ioBuffer.get(); fail();
/** * Test the get() method on a IoBuffer containing one ByteBuffer with 3 * bytes */ @Test public void testGetOneBuffer3Bytes() { ByteBuffer bb = ByteBuffer.allocate(5); bb.put("012".getBytes()); bb.flip(); IoBuffer ioBuffer = IoBuffer.wrap(bb); assertEquals(0, ioBuffer.position()); assertEquals(3, ioBuffer.limit()); assertTrue(ioBuffer.hasRemaining()); assertEquals('0', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('1', ioBuffer.get()); assertTrue(ioBuffer.hasRemaining()); assertEquals('2', ioBuffer.get()); try { assertFalse(ioBuffer.hasRemaining()); ioBuffer.get(); fail(); } catch (BufferUnderflowException bufe) { // expected assertEquals(3, ioBuffer.position()); } }
/** * Test the get() method on a IoBuffer containing one ByteBuffer with 0 * bytes */ @Test public void testGetOneBuffer0Bytes() { ByteBuffer bb = ByteBuffer.allocate(0); IoBuffer ioBuffer = IoBuffer.wrap(bb); assertEquals(0, ioBuffer.position()); assertEquals(0, ioBuffer.limit()); try { assertFalse(ioBuffer.hasRemaining()); ioBuffer.get(); fail(); } catch (BufferUnderflowException bufe) { // expected assertEquals(0, ioBuffer.position()); } }
/** * Test the allocation of a new direct IoBuffer with no byte in it */ @Test public void testAllocateDirect0() { IoBuffer ioBuffer = IoBuffer.allocateDirect(0); assertTrue(ioBuffer.isDirect()); assertEquals(0, ioBuffer.capacity()); assertEquals(0, ioBuffer.limit()); assertEquals(0, ioBuffer.position()); assertFalse(ioBuffer.hasRemaining()); }
/** * Test the allocation of a new heap IoBuffer with no byte in it */ @Test public void testAllocate0() { IoBuffer ioBuffer = IoBuffer.allocate(0); assertFalse(ioBuffer.isDirect()); assertEquals(0, ioBuffer.capacity()); assertEquals(0, ioBuffer.limit()); assertEquals(0, ioBuffer.position()); assertFalse(ioBuffer.hasRemaining()); }
/** * Test the allocation of a new direct IoBuffer with 1024 bytes */ @Test public void testAllocateDirect1024() { IoBuffer ioBuffer = IoBuffer.allocateDirect(1024); assertTrue(ioBuffer.isDirect()); assertEquals(1024, ioBuffer.capacity()); assertEquals(1024, ioBuffer.limit()); assertEquals(0, ioBuffer.position()); assertTrue(ioBuffer.hasRemaining()); }
/** * Test the allocation of a new heap IoBuffer with 1024 bytes */ @Test public void testAllocate1024() { IoBuffer ioBuffer = IoBuffer.allocate(1024); assertFalse(ioBuffer.isDirect()); assertEquals(1024, ioBuffer.capacity()); assertEquals(1024, ioBuffer.limit()); assertEquals(0, ioBuffer.position()); assertTrue(ioBuffer.hasRemaining()); }