@SuppressWarnings("unchecked") public <L extends GeneratedMessage> L get(Class<L> clazz, ExtensionRegistryLite registry) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { Method parseMethod = clazz.getDeclaredMethod("parseFrom", InputStream.class, ExtensionRegistryLite.class); return (L) parseMethod.invoke(null, input.asInputStream(), registry); }
/** * Extends the current IoBuffer capacity. * * @param size * the number of bytes to extend the current IoBuffer * @return the current {@link IoBuffer} */ public IoBuffer extend(int size) { ByteBuffer extension = isDirect() ? ByteBuffer.allocateDirect(size) : ByteBuffer.allocate(size); add(extension); return this; }
/** * @see ByteBuffer#getChar(int) */ public char getChar(int index) { return getChar(getPointerByPosition(index)); }
/** * @see ByteBuffer#getDouble(int) */ public double getDouble(int index) { return getDouble(getPointerByPosition(index)); }
/** * Test the flip() method */ @Test public void testFlip() { ByteBuffer bb1 = ByteBuffer.allocate(4); bb1.put("0123".getBytes()); bb1.flip(); ByteBuffer bb2 = ByteBuffer.allocate(4); bb2.put("4567".getBytes()); bb2.flip(); IoBuffer ioBuffer = IoBuffer.wrap(bb1, bb2); // Move forward a bit ioBuffer.get(); ioBuffer.get(); // Clear ioBuffer.clear(); // We should be back to the origin assertEquals(0, ioBuffer.position()); assertEquals(8, ioBuffer.limit()); }
/** * 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); } }
@Test public void testSlice() { ByteBuffer bb1 = ByteBuffer.allocate(5); bb1.put("012".getBytes()); bb1.flip(); ByteBuffer bb2 = ByteBuffer.allocate(5); bb2.put("345".getBytes()); bb2.flip(); ByteBuffer bb3 = ByteBuffer.allocate(5); bb3.put("6789".getBytes()); bb3.flip(); IoBuffer ioBuffer = IoBuffer.newInstance(); ioBuffer.add(bb1, bb2).add(bb3); ioBuffer.position(2); ioBuffer.limit(8); IoBuffer slice = ioBuffer.slice(); assertEquals(6, slice.remaining()); assertEquals(0, slice.position()); assertEquals(6, slice.limit()); byte seg[] = "234567".getBytes(); for (int i = 0; i < 6; i++) { assertEquals(seg[i], slice.get(i)); } }
@Test public void testFloat() { for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(5).order(bo).putFloat(-0.68f).rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(5, ioBuffer.capacity()); ioBuffer.extend(3); ioBuffer.position(4); assertEquals(8, ioBuffer.capacity()); ioBuffer.putFloat(3.14f); ioBuffer.rewind(); assertEquals(-0.68f, ioBuffer.getFloat(), 0.001f); assertEquals(3.14f, ioBuffer.getFloat(), 0.001f); ioBuffer.rewind(); ioBuffer.putFloat(2, -12.34f); assertEquals(-12.34f, ioBuffer.getFloat(2), 0.001f); } }
@Test public void testDouble() { for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(9).order(bo).putDouble(Math.PI).rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(9, ioBuffer.capacity()); ioBuffer.extend(7); ioBuffer.position(8); assertEquals(16, ioBuffer.capacity()); ioBuffer.putDouble(-Math.E); ioBuffer.rewind(); assertEquals(Math.PI, ioBuffer.getDouble(), 1E-10); assertEquals(-Math.E, ioBuffer.getDouble(), 1E-10); ioBuffer.rewind(); ioBuffer.putDouble(4, 12.34); assertEquals(12.34, ioBuffer.getDouble(4), 1E-10); } }
/** * 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()); }
@Override public OUT decode(IoBuffer input, MutableInt nextBlockSize) { OUT output = null; if (nextBlockSize.getValue() == null) { nextBlockSize.setValue(sizeDecoder.decode(input)); } if (nextBlockSize.isDefined() && (input.remaining() >= nextBlockSize.getValue())) { IoBuffer buffer = input.slice(); buffer.limit(buffer.position() + nextBlockSize.getValue()); output = payloadDecoder.decode(buffer); nextBlockSize.reset(); } return output; }
@Test public void testLong() { for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(9).order(bo).putLong(123456789012l).rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(9, ioBuffer.capacity()); ioBuffer.extend(7); ioBuffer.position(8); assertEquals(16, ioBuffer.capacity()); ioBuffer.putLong(-23456789023l); ioBuffer.rewind(); assertEquals(123456789012l, ioBuffer.getLong()); assertEquals(-23456789023l, ioBuffer.getLong()); ioBuffer.rewind(); ioBuffer.putLong(4, 1234567890); assertEquals(1234567890, ioBuffer.getLong(4)); try { ioBuffer.putLong(9, 1); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } try { ioBuffer.getLong(9); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } } }
for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(3).order(bo).putChar('\u00EB').rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(3, ioBuffer.capacity()); ioBuffer.extend(1); ioBuffer.order(bo); ioBuffer.position(2); assertEquals(4, ioBuffer.capacity()); ioBuffer.putChar('\u00FC'); ioBuffer.rewind(); assertEquals('\u00EB', ioBuffer.getChar()); assertEquals('\u00FC', ioBuffer.getChar()); ioBuffer.rewind(); ioBuffer.putChar(1, '\u00E7'); assertEquals('\u00E7', ioBuffer.getChar(1)); ioBuffer.putChar(3, '\u00F1'); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { ioBuffer.getChar(3); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) {
@Test public void testShort() { for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(3).order(bo).putShort((short) 12345).rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(3, ioBuffer.capacity()); ioBuffer.extend(1); ioBuffer.position(2); assertEquals(4, ioBuffer.capacity()); ioBuffer.putShort((short) -23456); ioBuffer.rewind(); assertEquals(12345, ioBuffer.getShort()); assertEquals(-23456, ioBuffer.getShort()); ioBuffer.rewind(); ioBuffer.putShort(1, (short) 12345); assertEquals((short) 12345, ioBuffer.getShort(1)); try { ioBuffer.putShort(3, (short) 1); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } try { ioBuffer.getShort(3); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } } }
@Test public void testInt() { for (ByteOrder bo : new ByteOrder[] { ByteOrder.BIG_ENDIAN, ByteOrder.LITTLE_ENDIAN }) { ByteBuffer bb = (ByteBuffer) ByteBuffer.allocate(5).order(bo).putInt(123456).rewind(); IoBuffer ioBuffer = IoBuffer.wrap(bb).order(bo); assertEquals(5, ioBuffer.capacity()); ioBuffer.extend(3); ioBuffer.position(4); assertEquals(8, ioBuffer.capacity()); ioBuffer.putInt(-23456789); ioBuffer.rewind(); assertEquals(123456, ioBuffer.getInt()); assertEquals(-23456789, ioBuffer.getInt()); ioBuffer.rewind(); ioBuffer.putInt(2, 1234567890); assertEquals(1234567890, ioBuffer.getInt(2)); try { ioBuffer.putInt(5, 1); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } try { ioBuffer.getInt(5); fail("Not enough place on the buffer"); } catch (BufferUnderflowException e) { // Should come here } } }
@Test public void testCompact() { ByteBuffer bb1 = ByteBuffer.allocate(5); bb1.put("012".getBytes()); bb1.flip(); ByteBuffer bb2 = ByteBuffer.allocate(5); bb2.put("345".getBytes()); bb2.flip(); ByteBuffer bb3 = ByteBuffer.allocate(5); bb3.put("6789".getBytes()); bb3.flip(); IoBuffer ioBuffer = IoBuffer.newInstance(); ioBuffer.add(bb1, bb2).add(bb3); ioBuffer.position(2); ioBuffer.limit(8); ioBuffer.compact(); assertEquals(ioBuffer.capacity(), ioBuffer.limit()); assertEquals(6, ioBuffer.position()); byte seg[] = "234567".getBytes(); for (int i = 0; i < 6; i++) { assertEquals(seg[i], ioBuffer.get(i)); } }
/** * @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; }