Removed unused packstream methods

Main those that do flushing. Now it's handled by netty channels.

Author: lutovich

driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java

@@ -39,12 +39,6 @@ public void stop()
         buf = null;
     }
 
-    @Override
-    public boolean hasMoreData()
-    {
-        return buf.isReadable();
-    }
-
     @Override
     public byte readByte()
     {

driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java

@@ -60,12 +60,6 @@ public void stop()
         currentChunkSize = 0;
     }
 
-    @Override
-    public PackOutput flush()
-    {
-        throw new UnsupportedOperationException( "Flush not supported, this output only writes to a buffer" );
-    }
-
     @Override
     public PackOutput writeByte( byte value )
     {

driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java

@@ -28,19 +28,11 @@ public interface MessageFormat
     interface Writer
     {
         Writer write( Message msg ) throws IOException;
-
-        Writer flush() throws IOException;
     }
 
     interface Reader
     {
-        /**
-         * Return true is there is another message in the underlying buffer
-         */
-        boolean hasNext() throws IOException;
-
         void read( MessageHandler handler ) throws IOException;
-
     }
 
     Writer newWriter( PackOutput output, boolean byteArraySupportEnabled );

driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java

@@ -326,13 +326,6 @@ private void packValue( Value value ) throws IOException
             }
         }
 
-        @Override
-        public Writer flush() throws IOException
-        {
-            packer.flush();
-            return this;
-        }
-
         @Override
         public Writer write( Message msg ) throws IOException
         {
@@ -376,12 +369,6 @@ public Reader( PackInput input )
             unpacker = new PackStream.Unpacker( input );
         }
 
-        @Override
-        public boolean hasNext() throws IOException
-        {
-            return unpacker.hasNext();
-        }
-
         /**
          * Parse a single message into the given consumer.
          */
@@ -660,14 +647,4 @@ private Map<String,Value> unpackMap() throws IOException
             return map;
         }
     }
-
-    public static class NoOpRunnable implements Runnable
-    {
-        @Override
-        public void run()
-        {
-            // no-op
-        }
-    }
-
 }

driver/src/main/java/org/neo4j/driver/internal/packstream/PackInput.java

@@ -26,9 +26,6 @@
  */
 public interface PackInput
 {
-    /** True if there is at least one more consumable byte */
-    boolean hasMoreData() throws IOException;
-
     /** Consume one byte */
     byte readByte() throws IOException;
 

driver/src/main/java/org/neo4j/driver/internal/packstream/PackOutput.java

@@ -25,10 +25,6 @@
  */
 public interface PackOutput
 {
-    // todo: remove flush method
-    /** If implementation has been buffering data, it should flush those buffers now. */
-    PackOutput flush() throws IOException;
-
     /** Produce a single byte */
     PackOutput writeByte( byte value ) throws IOException;
 

driver/src/main/java/org/neo4j/driver/internal/packstream/PackStream.java

@@ -157,11 +157,6 @@ public Packer( PackOutput out )
             this.out = out;
         }
 
-        public void flush() throws IOException
-        {
-            out.flush();
-        }
-
         public void packRaw( byte[] data ) throws IOException
         {
             out.writeBytes( data );
@@ -425,11 +420,6 @@ public Unpacker( PackInput in )
             this.in = in;
         }
 
-        public boolean hasNext() throws IOException
-        {
-            return in.hasMoreData();
-        }
-
         public long unpackStructHeader() throws IOException
         {
             final byte markerByte = in.readByte();

driver/src/test/java/org/neo4j/driver/internal/async/inbound/ByteBufInputTest.java

@@ -24,7 +24,6 @@
 import static org.hamcrest.Matchers.instanceOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.mock;
@@ -66,17 +65,6 @@ public void shouldThrowWhenStartedTwice()
         }
     }
 
-    @Test
-    public void shouldDelegateHasMoreData()
-    {
-        ByteBufInput input = new ByteBufInput();
-        ByteBuf buf = mock( ByteBuf.class );
-        when( buf.isReadable() ).thenReturn( true );
-        input.start( buf );
-
-        assertTrue( input.hasMoreData() );
-    }
-
     @Test
     public void shouldDelegateReadByte()
     {

driver/src/test/java/org/neo4j/driver/internal/packstream/BufferedChannelInput.java

@@ -44,12 +44,6 @@ public BufferedChannelInput( int bufferCapacity, ReadableByteChannel ch )
         this.channel = ch;
     }
 
-    @Override
-    public boolean hasMoreData() throws IOException
-    {
-        return attempt( 1 );
-    }
-
     @Override
     public byte readByte() throws IOException
     {

driver/src/test/java/org/neo4j/driver/internal/packstream/BufferedChannelOutput.java renamed to driver/src/test/java/org/neo4j/driver/internal/packstream/ChannelOutput.java

@@ -20,99 +20,68 @@
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.nio.channels.WritableByteChannel;
 
-public class BufferedChannelOutput implements PackOutput
+public class ChannelOutput implements PackOutput
 {
-    private final ByteBuffer buffer;
     private final WritableByteChannel channel;
 
-    public BufferedChannelOutput( WritableByteChannel channel )
+    public ChannelOutput( WritableByteChannel channel )
     {
-        this( channel, 1024 );
-    }
-
-    public BufferedChannelOutput( WritableByteChannel channel, int bufferSize )
-    {
-        this.buffer = ByteBuffer.allocate( bufferSize ).order( ByteOrder.BIG_ENDIAN );
         this.channel = channel;
     }
 
-    @Override
-    public BufferedChannelOutput flush() throws IOException
-    {
-        buffer.flip();
-        do { channel.write( buffer ); } while ( buffer.remaining() > 0 );
-        buffer.clear();
-        return this;
-    }
-
     @Override
     public PackOutput writeBytes( byte[] data ) throws IOException
     {
-        int length = data.length;
-        int index = 0;
-        while ( index < length )
-        {
-            if ( buffer.remaining() == 0 )
-            {
-                flush();
-            }
-
-            int amountToWrite = Math.min( buffer.remaining(), length - index );
-
-            buffer.put( data, index, amountToWrite );
-            index += amountToWrite;
-        }
+        channel.write( ByteBuffer.wrap( data ) );
         return this;
     }
 
     @Override
     public PackOutput writeByte( byte value ) throws IOException
     {
-        ensure( 1 );
-        buffer.put( value );
+        channel.write( ByteBuffer.wrap( new byte[]{value} ) );
         return this;
     }
 
     @Override
     public PackOutput writeShort( short value ) throws IOException
     {
-        ensure( 2 );
+        ByteBuffer buffer = ByteBuffer.allocate( Short.BYTES );
         buffer.putShort( value );
+        buffer.flip();
+        channel.write( buffer );
         return this;
     }
 
     @Override
     public PackOutput writeInt( int value ) throws IOException
     {
-        ensure( 4 );
+        ByteBuffer buffer = ByteBuffer.allocate( Integer.BYTES );
         buffer.putInt( value );
+        buffer.flip();
+        channel.write( buffer );
         return this;
     }
 
     @Override
     public PackOutput writeLong( long value ) throws IOException
     {
-        ensure( 8 );
+        ByteBuffer buffer = ByteBuffer.allocate( Long.BYTES );
         buffer.putLong( value );
+        buffer.flip();
+        channel.write( buffer );
         return this;
     }
 
     @Override
     public PackOutput writeDouble( double value ) throws IOException
     {
-        ensure( 8 );
+        ByteBuffer buffer = ByteBuffer.allocate( Double.BYTES );
         buffer.putDouble( value );
+        buffer.flip();
+        channel.write( buffer );
         return this;
     }
-
-    private void ensure( int size ) throws IOException
-    {
-        if ( buffer.remaining() < size )
-        {
-            flush();
-        }
-    }
 }