neo4j
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/InternalPoint2D.java
Copy file name to clipboard
+88Lines changed: 88 additions & 0 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/InternalPoint2D.java
Copy file name to clipboard
+88Lines changed: 88 additions & 0 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/InternalPoint3D.java
Copy file name to clipboard
+98Lines changed: 98 additions & 0 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/InternalPoint3D.java
Copy file name to clipboard
+98Lines changed: 98 additions & 0 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolV1Util.java renamed to ‎driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolUtil.java
Copy file name to clipboard
+18-7Lines changed: 18 additions & 7 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolV1Util.java renamed to ‎driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolUtil.java
Copy file name to clipboard
+18-7Lines changed: 18 additions & 7 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java
Copy file name to clipboard
+15-6Lines changed: 15 additions & 6 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java
Copy file name to clipboard
+15-6Lines changed: 15 additions & 6 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/inbound/ByteBufInput.java
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java
Copy file name to clipboard
+5-5Lines changed: 5 additions & 5 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions b/‎driver/src/main/java/org/neo4j/driver/internal/messaging/MessageFormat.java
Copy file name to clipboard
+1-3Lines changed: 1 addition & 3 deletions
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2002-2018 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [https://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal;
+
+import java.util.Objects;
+
+import org.neo4j.driver.v1.types.Point2D;
+
+public class InternalPoint2D implements Point2D
+{
+    private final long srid;
+    private final double x;
+    private final double y;
+
+    public InternalPoint2D( long srid, double x, double y )
+    {
+        this.srid = srid;
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public long srid()
+    {
+        return srid;
+    }
+
+    @Override
+    public double x()
+    {
+        return x;
+    }
+
+    @Override
+    public double y()
+    {
+        return y;
+    }
+
+    @Override
+    public boolean equals( Object o )
+    {
+        if ( this == o )
+        {
+            return true;
+        }
+        if ( o == null || getClass() != o.getClass() )
+        {
+            return false;
+        }
+        InternalPoint2D that = (InternalPoint2D) o;
+        return srid == that.srid &&
+               Double.compare( that.x, x ) == 0 &&
+               Double.compare( that.y, y ) == 0;
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash( srid, x, y );
+    }
+
+    @Override
+    public String toString()
+    {
+        return "Point2D{" +
+               "srid=" + srid +
+               ", x=" + x +
+               ", y=" + y +
+               '}';
+    }
+}
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2002-2018 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [https://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal;
+
+import java.util.Objects;
+
+import org.neo4j.driver.v1.types.Point3D;
+
+public class InternalPoint3D implements Point3D
+{
+    private final long srid;
+    private final double x;
+    private final double y;
+    private final double z;
+
+    public InternalPoint3D( long srid, double x, double y, double z )
+    {
+        this.srid = srid;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    @Override
+    public long srid()
+    {
+        return srid;
+    }
+
+    @Override
+    public double x()
+    {
+        return x;
+    }
+
+    @Override
+    public double y()
+    {
+        return y;
+    }
+
+    @Override
+    public double z()
+    {
+        return z;
+    }
+
+    @Override
+    public boolean equals( Object o )
+    {
+        if ( this == o )
+        {
+            return true;
+        }
+        if ( o == null || getClass() != o.getClass() )
+        {
+            return false;
+        }
+        InternalPoint3D that = (InternalPoint3D) o;
+        return srid == that.srid &&
+               Double.compare( that.x, x ) == 0 &&
+               Double.compare( that.y, y ) == 0 &&
+               Double.compare( that.z, z ) == 0;
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return Objects.hash( srid, x, y, z );
+    }
+
+    @Override
+    public String toString()
+    {
+        return "Point3D{" +
+               "srid=" + srid +
+               ", x=" + x +
+               ", y=" + y +
+               ", z=" + z +
+               '}';
+    }
+}
@@ -22,38 +22,43 @@
 
 import static io.netty.buffer.Unpooled.copyInt;
 import static io.netty.buffer.Unpooled.unreleasableBuffer;
+import static java.lang.Integer.toHexString;
 
-public final class BoltProtocolV1Util
+public final class BoltProtocolUtil
 {
     public static final int HTTP = 1213486160; //== 0x48545450 == "HTTP"
 
-    public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017;
     public static final int PROTOCOL_VERSION_1 = 1;
+    public static final int PROTOCOL_VERSION_2 = 2;
+
+    public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017;
     public static final int NO_PROTOCOL_VERSION = 0;
 
     public static final int CHUNK_HEADER_SIZE_BYTES = 2;
 
     public static final int DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = Short.MAX_VALUE / 2;
 
-    private static final ByteBuf BOLT_V1_HANDSHAKE_BUF = unreleasableBuffer( copyInt(
+    private static final ByteBuf HANDSHAKE_BUF = unreleasableBuffer( copyInt(
             BOLT_MAGIC_PREAMBLE,
+            PROTOCOL_VERSION_2,
             PROTOCOL_VERSION_1,
             NO_PROTOCOL_VERSION,
-            NO_PROTOCOL_VERSION,
             NO_PROTOCOL_VERSION ) ).asReadOnly();
 
-    private BoltProtocolV1Util()
+    private static final String HANDSHAKE_STRING = createHandshakeString();
+
+    private BoltProtocolUtil()
     {
     }
 
     public static ByteBuf handshakeBuf()
     {
-        return BOLT_V1_HANDSHAKE_BUF.duplicate();
+        return HANDSHAKE_BUF.duplicate();
     }
 
     public static String handshakeString()
     {
-        return "[0x6060B017, 1, 0, 0, 0]";
+        return HANDSHAKE_STRING;
     }
 
     public static void writeMessageBoundary( ByteBuf buf )
@@ -70,4 +75,10 @@ public static void writeChunkHeader( ByteBuf buf, int chunkStartIndex, int heade
     {
         buf.setShort( chunkStartIndex, headerValue );
     }
+
+    private static String createHandshakeString()
+    {
+        ByteBuf buf = handshakeBuf();
+        return String.format( "[0x%s, %s, %s, %s, %s]", toHexString( buf.readInt() ), buf.readInt(), buf.readInt(), buf.readInt(), buf.readInt() );
+    }
 }
@@ -31,8 +31,8 @@
 import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 
 import static java.lang.String.format;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeBuf;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeString;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.handshakeBuf;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.handshakeString;
 
 public class ChannelConnectedListener implements ChannelFutureListener
 {
 
@@ -31,16 +31,18 @@
 import org.neo4j.driver.internal.logging.ChannelActivityLogger;
 import org.neo4j.driver.internal.messaging.MessageFormat;
 import org.neo4j.driver.internal.messaging.PackStreamMessageFormatV1;
+import org.neo4j.driver.internal.messaging.PackStreamMessageFormatV2;
 import org.neo4j.driver.internal.util.ErrorUtil;
 import org.neo4j.driver.v1.Logger;
 import org.neo4j.driver.v1.Logging;
 import org.neo4j.driver.v1.exceptions.ClientException;
 import org.neo4j.driver.v1.exceptions.SecurityException;
 import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;
 
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.HTTP;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.NO_PROTOCOL_VERSION;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.PROTOCOL_VERSION_1;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.HTTP;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.NO_PROTOCOL_VERSION;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.PROTOCOL_VERSION_1;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.PROTOCOL_VERSION_2;
 
 public class HandshakeHandler extends ReplayingDecoder<Void>
 {
@@ -121,9 +123,10 @@ protected void decode( ChannelHandlerContext ctx, ByteBuf in, List<Object> out )
         switch ( serverSuggestedVersion )
         {
         case PROTOCOL_VERSION_1:
-            MessageFormat messageFormat = new PackStreamMessageFormatV1();
-            pipelineBuilder.build( messageFormat, pipeline, logging );
-            handshakeCompletedPromise.setSuccess();
+            protocolSelected( new PackStreamMessageFormatV1(), pipeline );
+            break;
+        case PROTOCOL_VERSION_2:
+            protocolSelected( new PackStreamMessageFormatV2(), pipeline );
             break;
         case NO_PROTOCOL_VERSION:
             fail( ctx, protocolNoSupportedByServerError() );
@@ -137,6 +140,12 @@ protected void decode( ChannelHandlerContext ctx, ByteBuf in, List<Object> out )
         }
     }
 
+    private void protocolSelected( MessageFormat messageFormat, ChannelPipeline pipeline )
+    {
+        pipelineBuilder.build( messageFormat, pipeline, logging );
+        handshakeCompletedPromise.setSuccess();
+    }
+
     private void fail( ChannelHandlerContext ctx, Throwable error )
     {
         ctx.close().addListener( future -> handshakeCompletedPromise.tryFailure( error ) );
 
@@ -70,10 +70,9 @@ public double readDouble()
     }
 
     @Override
-    public PackInput readBytes( byte[] into, int offset, int toRead )
+    public void readBytes( byte[] into, int offset, int toRead )
     {
         buf.readBytes( into, offset, toRead );
-        return this;
     }
 
     @Override
 
@@ -20,12 +20,12 @@
 
 import io.netty.buffer.ByteBuf;
 
-import org.neo4j.driver.internal.async.BoltProtocolV1Util;
+import org.neo4j.driver.internal.async.BoltProtocolUtil;
 import org.neo4j.driver.internal.packstream.PackOutput;
 
 import static java.util.Objects.requireNonNull;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.CHUNK_HEADER_SIZE_BYTES;
-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.CHUNK_HEADER_SIZE_BYTES;
+import static org.neo4j.driver.internal.async.BoltProtocolUtil.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES;
 
 public class ChunkAwareByteBufOutput implements PackOutput
 {
@@ -138,15 +138,15 @@ private void ensureCanFitInCurrentChunk( int numberOfBytes )
     private void startNewChunk( int index )
     {
         currentChunkStartIndex = index;
-        BoltProtocolV1Util.writeEmptyChunkHeader( buf );
+        BoltProtocolUtil.writeEmptyChunkHeader( buf );
         currentChunkSize = CHUNK_HEADER_SIZE_BYTES;
     }
 
     private void writeChunkSizeHeader()
     {
         // go to the beginning of the chunk and write the size header
         int chunkBodySize = currentChunkSize - CHUNK_HEADER_SIZE_BYTES;
-        BoltProtocolV1Util.writeChunkHeader( buf, currentChunkStartIndex, chunkBodySize );
+        BoltProtocolUtil.writeChunkHeader( buf, currentChunkStartIndex, chunkBodySize );
     }
 
     private int availableBytesInCurrentChunk()
 
@@ -25,7 +25,7 @@
 
 import java.util.List;
 
-import org.neo4j.driver.internal.async.BoltProtocolV1Util;
+import org.neo4j.driver.internal.async.BoltProtocolUtil;
 import org.neo4j.driver.internal.logging.ChannelActivityLogger;
 import org.neo4j.driver.internal.messaging.Message;
 import org.neo4j.driver.internal.messaging.MessageFormat;
@@ -95,7 +95,7 @@ protected void encode( ChannelHandlerContext ctx, Message msg, List<Object> out
             log.trace( "C: %s", hexDump( messageBuf ) );
         }
 
-        BoltProtocolV1Util.writeMessageBoundary( messageBuf );
+        BoltProtocolUtil.writeMessageBoundary( messageBuf );
         out.add( messageBuf );
     }
 
 
@@ -27,7 +27,7 @@ public interface MessageFormat
 {
     interface Writer
     {
-        Writer write( Message msg ) throws IOException;
+        void write( Message msg ) throws IOException;
     }
 
     interface Reader
@@ -38,6 +38,4 @@ interface Reader
     Writer newWriter( PackOutput output, boolean byteArraySupportEnabled );
 
     Reader newReader( PackInput input );
-
-    int version();
 }
Original file line number	Diff line number	Diff line change
`@@ -22,38 +22,43 @@`
`22`	`22`
`23`	`23`	`import static io.netty.buffer.Unpooled.copyInt;`
`24`	`24`	`import static io.netty.buffer.Unpooled.unreleasableBuffer;`
	`25`	`+import static java.lang.Integer.toHexString;`
`25`	`26`
`26`		`-public final class BoltProtocolV1Util`
	`27`	`+public final class BoltProtocolUtil`
`27`	`28`	`{`
`28`	`29`	`public static final int HTTP = 1213486160; //== 0x48545450 == "HTTP"`
`29`	`30`
`30`		`- public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017;`
`31`	`31`	`public static final int PROTOCOL_VERSION_1 = 1;`
	`32`	`+ public static final int PROTOCOL_VERSION_2 = 2;`
	`33`	`+`
	`34`	`+ public static final int BOLT_MAGIC_PREAMBLE = 0x6060B017;`
`32`	`35`	`public static final int NO_PROTOCOL_VERSION = 0;`
`33`	`36`
`34`	`37`	`public static final int CHUNK_HEADER_SIZE_BYTES = 2;`
`35`	`38`
`36`	`39`	`public static final int DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = Short.MAX_VALUE / 2;`
`37`	`40`
`38`		`- private static final ByteBuf BOLT_V1_HANDSHAKE_BUF = unreleasableBuffer( copyInt(`
	`41`	`+ private static final ByteBuf HANDSHAKE_BUF = unreleasableBuffer( copyInt(`
`39`	`42`	`BOLT_MAGIC_PREAMBLE,`
	`43`	`+ PROTOCOL_VERSION_2,`
`40`	`44`	`PROTOCOL_VERSION_1,`
`41`	`45`	`NO_PROTOCOL_VERSION,`
`42`		`- NO_PROTOCOL_VERSION,`
`43`	`46`	`NO_PROTOCOL_VERSION ) ).asReadOnly();`
`44`	`47`
`45`		`- private BoltProtocolV1Util()`
	`48`	`+ private static final String HANDSHAKE_STRING = createHandshakeString();`
	`49`	`+`
	`50`	`+ private BoltProtocolUtil()`
`46`	`51`	`{`
`47`	`52`	`}`
`48`	`53`
`49`	`54`	`public static ByteBuf handshakeBuf()`
`50`	`55`	`{`
`51`		`- return BOLT_V1_HANDSHAKE_BUF.duplicate();`
	`56`	`+ return HANDSHAKE_BUF.duplicate();`
`52`	`57`	`}`
`53`	`58`
`54`	`59`	`public static String handshakeString()`
`55`	`60`	`{`
`56`		`- return "[0x6060B017, 1, 0, 0, 0]";`
	`61`	`+ return HANDSHAKE_STRING;`
`57`	`62`	`}`
`58`	`63`
`59`	`64`	`public static void writeMessageBoundary( ByteBuf buf )`
`@@ -70,4 +75,10 @@ public static void writeChunkHeader( ByteBuf buf, int chunkStartIndex, int heade`
`70`	`75`	`{`
`71`	`76`	`buf.setShort( chunkStartIndex, headerValue );`
`72`	`77`	`}`
	`78`	`+`
	`79`	`+ private static String createHandshakeString()`
	`80`	`+ {`
	`81`	`+ ByteBuf buf = handshakeBuf();`
	`82`	`+ return String.format( "[0x%s, %s, %s, %s, %s]", toHexString( buf.readInt() ), buf.readInt(), buf.readInt(), buf.readInt(), buf.readInt() );`
	`83`	`+ }`
`73`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,8 @@`
`31`	`31`	`import org.neo4j.driver.v1.exceptions.ServiceUnavailableException;`
`32`	`32`
`33`	`33`	`import static java.lang.String.format;`
`34`		`-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeBuf;`
`35`		`-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeString;`
	`34`	`+import static org.neo4j.driver.internal.async.BoltProtocolUtil.handshakeBuf;`
	`35`	`+import static org.neo4j.driver.internal.async.BoltProtocolUtil.handshakeString;`
`36`	`36`
`37`	`37`	`public class ChannelConnectedListener implements ChannelFutureListener`
`38`	`38`	`{`
Original file line number	Diff line number	Diff line change
`@@ -70,10 +70,9 @@ public double readDouble()`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`@Override`
`73`		`- public PackInput readBytes( byte[] into, int offset, int toRead )`
	`73`	`+ public void readBytes( byte[] into, int offset, int toRead )`
`74`	`74`	`{`
`75`	`75`	`buf.readBytes( into, offset, toRead );`
`76`		`- return this;`
`77`	`76`	`}`
`78`	`77`
`79`	`78`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,12 @@`
`20`	`20`
`21`	`21`	`import io.netty.buffer.ByteBuf;`
`22`	`22`
`23`		`-import org.neo4j.driver.internal.async.BoltProtocolV1Util;`
	`23`	`+import org.neo4j.driver.internal.async.BoltProtocolUtil;`
`24`	`24`	`import org.neo4j.driver.internal.packstream.PackOutput;`
`25`	`25`
`26`	`26`	`import static java.util.Objects.requireNonNull;`
`27`		`-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.CHUNK_HEADER_SIZE_BYTES;`
`28`		`-import static org.neo4j.driver.internal.async.BoltProtocolV1Util.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES;`
	`27`	`+import static org.neo4j.driver.internal.async.BoltProtocolUtil.CHUNK_HEADER_SIZE_BYTES;`
	`28`	`+import static org.neo4j.driver.internal.async.BoltProtocolUtil.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES;`
`29`	`29`
`30`	`30`	`public class ChunkAwareByteBufOutput implements PackOutput`
`31`	`31`	`{`
`@@ -138,15 +138,15 @@ private void ensureCanFitInCurrentChunk( int numberOfBytes )`
`138`	`138`	`private void startNewChunk( int index )`
`139`	`139`	`{`
`140`	`140`	`currentChunkStartIndex = index;`
`141`		`- BoltProtocolV1Util.writeEmptyChunkHeader( buf );`
	`141`	`+ BoltProtocolUtil.writeEmptyChunkHeader( buf );`
`142`	`142`	`currentChunkSize = CHUNK_HEADER_SIZE_BYTES;`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`private void writeChunkSizeHeader()`
`146`	`146`	`{`
`147`	`147`	`// go to the beginning of the chunk and write the size header`
`148`	`148`	`int chunkBodySize = currentChunkSize - CHUNK_HEADER_SIZE_BYTES;`
`149`		`- BoltProtocolV1Util.writeChunkHeader( buf, currentChunkStartIndex, chunkBodySize );`
	`149`	`+ BoltProtocolUtil.writeChunkHeader( buf, currentChunkStartIndex, chunkBodySize );`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`private int availableBytesInCurrentChunk()`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@`
`25`	`25`
`26`	`26`	`import java.util.List;`
`27`	`27`
`28`		`-import org.neo4j.driver.internal.async.BoltProtocolV1Util;`
	`28`	`+import org.neo4j.driver.internal.async.BoltProtocolUtil;`
`29`	`29`	`import org.neo4j.driver.internal.logging.ChannelActivityLogger;`
`30`	`30`	`import org.neo4j.driver.internal.messaging.Message;`
`31`	`31`	`import org.neo4j.driver.internal.messaging.MessageFormat;`
`@@ -95,7 +95,7 @@ protected void encode( ChannelHandlerContext ctx, Message msg, List<Object> out`
`95`	`95`	`log.trace( "C: %s", hexDump( messageBuf ) );`
`96`	`96`	`}`
`97`	`97`
`98`		`- BoltProtocolV1Util.writeMessageBoundary( messageBuf );`
	`98`	`+ BoltProtocolUtil.writeMessageBoundary( messageBuf );`
`99`	`99`	`out.add( messageBuf );`
`100`	`100`	`}`
`101`	`101`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public interface MessageFormat`
`27`	`27`	`{`
`28`	`28`	`interface Writer`
`29`	`29`	`{`
`30`		`- Writer write( Message msg ) throws IOException;`
	`30`	`+ void write( Message msg ) throws IOException;`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`interface Reader`
`@@ -38,6 +38,4 @@ interface Reader`
`38`	`38`	`Writer newWriter( PackOutput output, boolean byteArraySupportEnabled );`
`39`	`39`
`40`	`40`	`Reader newReader( PackInput input );`
`41`		`-`
`42`		`- int version();`
`43`	`41`	`}`