Interface refactoring

Author: Artem Labazin

CHANGELOG.md

@@ -13,6 +13,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [1.0.3](https://github.com/appulse-projects/utils-java/releases/tag/1.0.3) - 2018-01-28
 
+### Changed
+
+- Refactored `Bytes` interface.
+
+### Removed
+
+- Netty's dependency.
+
+## [1.0.3](https://github.com/appulse-projects/utils-java/releases/tag/1.0.3) - 2018-01-28
+
 ### Added
 
 - New `Bytes` methods.

pom.xml

@@ -24,7 +24,7 @@ limitations under the License.
 
   <groupId>io.appulse</groupId>
   <artifactId>utils-java</artifactId>
-  <version>1.0.3</version>
+  <version>1.0.4</version>
   <packaging>jar</packaging>
 
   <properties>
@@ -62,7 +62,7 @@ limitations under the License.
     <url>https://github.com/appulse-projects/utils-java</url>
     <connection>scm:git:https://github.com/appulse-projects/utils-java.git</connection>
     <developerConnection>scm:git:https://github.com/appulse-projects/utils-java.git</developerConnection>
-    <tag>1.0.3</tag>
+    <tag>1.0.4</tag>
   </scm>
 
   <distributionManagement>
@@ -102,13 +102,6 @@ limitations under the License.
       <scope>provided</scope>
     </dependency>
 
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-buffer</artifactId>
-      <version>4.1.20.Final</version>
-      <scope>provided</scope>
-    </dependency>
-
     <dependency>
       <groupId>com.google.code.findbugs</groupId>
       <artifactId>annotations</artifactId>

src/main/java/io/appulse/utils/Bytes.java

@@ -23,8 +23,8 @@
 import java.util.Arrays;
 import java.util.stream.IntStream;
 
-import io.netty.buffer.ByteBuf;
 import lombok.Getter;
+import lombok.NonNull;
 import lombok.experimental.Delegate;
 import lombok.experimental.FieldDefaults;
 import lombok.experimental.NonFinal;
@@ -38,26 +38,15 @@
 @FieldDefaults(level = PRIVATE, makeFinal = true)
 public final class Bytes {
 
-  public static Bytes wrap (byte[] bytes) {
+  public static Bytes wrap (@NonNull byte[] bytes) {
     val result = allocate(bytes.length);
-    return result.put(bytes);
-  }
-
-  public static Bytes wrap (ByteBuffer buffer) {
-    val clone = ByteBuffer.wrap(buffer.array());
-    return new Bytes(clone);
+    result.put(bytes);
+    result.flip();
+    return result;
   }
 
-  public static Bytes wrap (ByteBuf buf) {
-    ByteBuffer buffer;
-    if (buf.isDirect()) {
-      buffer = buf.nioBuffer();
-    } else {
-      val bytes = new byte[buf.readableBytes()];
-      buf.getBytes(buf.readerIndex(), bytes);
-      buffer = ByteBuffer.wrap(bytes);
-    }
-    return new Bytes(buffer);
+  public static Bytes wrap (@NonNull ByteBuffer buffer) {
+    return wrap(buffer.array());
   }
 
   public static Bytes allocate () {
@@ -79,15 +68,20 @@ public static Bytes allocate (int capacity) {
   @Getter(value = PACKAGE)
   ByteBuffer buffer;
 
+  @NonFinal
+  int limit;
+
   private Bytes (ByteBuffer buffer) {
     puts = new BytesDelegatePuts(this);
     gets = new BytesDelegateGets(this);
     this.buffer = buffer;
+    limit = buffer.position();
   }
 
   public Bytes put (byte value) {
     checkCapacity(1);
     buffer.put(value);
+    limit++;
     return this;
   }
 
@@ -96,13 +90,14 @@ public Bytes put (int index, byte value) {
     return this;
   }
 
-  public Bytes put (byte[] bytes) {
+  public Bytes put (@NonNull byte[] bytes) {
     checkCapacity(bytes.length);
     buffer.put(bytes);
+    limit += bytes.length;
     return this;
   }
 
-  public Bytes put (int index, byte[] bytes) {
+  public Bytes put (int index, @NonNull byte[] bytes) {
     checkCapacity(index, bytes.length);
     IntStream.range(index, index + bytes.length).forEach(it -> {
       buffer.put(it, bytes[it - index]);
@@ -133,32 +128,39 @@ public byte[] getBytes (int offset, int length) {
   }
 
   public byte[] array () {
-    return Arrays.copyOfRange(buffer.array(), 0, buffer.position());
+    return Arrays.copyOfRange(buffer.array(), 0, limit);
   }
 
   public int limit () {
-    return buffer.limit();
+    return limit;
   }
 
   public int remaining () {
-    return buffer.remaining();
+    return limit - buffer.position();
   }
 
   public int position () {
     return buffer.position();
   }
 
   public Bytes position (int position) {
+    if (position > limit || position < 0) {
+      throw new IllegalArgumentException();
+    }
     buffer.position(position);
     return this;
   }
 
-  public void clear () {
+  public Bytes clear () {
     buffer.clear();
+    limit = 0;
+    return this;
   }
 
-  public void flip () {
+  public Bytes flip () {
+    limit = buffer.position();
     buffer.flip();
+    return this;
   }
 
   private void checkCapacity (int size) {

src/test/java/io/appulse/utils/BytesTest.java

@@ -35,6 +35,12 @@ public void wrap () {
     Bytes bytes = Bytes.wrap(expected);
 
     assertThat(bytes.position())
+        .isEqualTo(0);
+
+    assertThat(bytes.limit())
+        .isEqualTo(expected.length);
+
+    assertThat(bytes.remaining())
         .isEqualTo(expected.length);
 
     assertThat(bytes.array())
@@ -92,7 +98,7 @@ public void array () {
   @Test
   public void limit () {
       Bytes bytes = Bytes.allocate(2);
-      assertThat(bytes.limit()).isEqualTo(2);
+      assertThat(bytes.limit()).isEqualTo(0);
 
       bytes.put4B(4);
       assertThat(bytes.limit()).isEqualTo(4);
@@ -104,15 +110,15 @@ public void limit () {
   @Test
   public void remaining () {
       Bytes bytes = Bytes.allocate(2);
-      assertThat(bytes.remaining()).isEqualTo(2);
+      assertThat(bytes.remaining()).isEqualTo(0);
 
       bytes.put4B(4);
       assertThat(bytes.remaining()).isEqualTo(0);
 
       Bytes wrapped = Bytes.wrap(new byte[] { 1 });
-      assertThat(wrapped.remaining()).isEqualTo(0);
+      assertThat(wrapped.remaining()).isEqualTo(1);
 
       wrapped.flip();
-      assertThat(wrapped.remaining()).isEqualTo(1);
+      assertThat(wrapped.remaining()).isEqualTo(0);
   }
 }