minor fixes

Author: Artem Labazin

pom.xml

@@ -24,7 +24,7 @@ limitations under the License.
 
   <groupId>io.appulse</groupId>
   <artifactId>utils-java</artifactId>
-  <version>1.12.0</version>
+  <version>1.13.0</version>
   <packaging>jar</packaging>
 
   <properties>
@@ -66,7 +66,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.12.0</tag>
+    <tag>1.13.0</tag>
   </scm>
 
   <distributionManagement>
@@ -111,6 +111,7 @@ limitations under the License.
       <artifactId>netty-buffer</artifactId>
       <version>4.1.33.Final</version>
       <scope>compile</scope>
+      <optional>true</optional>
     </dependency>
 
     <dependency>

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

@@ -20,8 +20,6 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 
-import io.netty.buffer.ByteBuf;
-
 /**
  * This interface provides an abstract view for a primitive byte
  * arrays ({@code byte[]}).
@@ -63,20 +61,6 @@ static Bytes wrap (ByteBuffer buffer) {
     return new BytesByteBuffer(buffer);
   }
 
-  /**
-   * Wraps a {@link ByteBuf} buffer into a new {@link Bytes} object.
-   * <p>
-   * Modifications to this buffer's content will cause the wrapped
-   * buffer's content to be modified, and vice versa.
-   *
-   * @param buffer the value to wrap
-   *
-   * @return the new {@link Bytes} instance
-   */
-  static Bytes wrap (ByteBuf buffer) {
-    return new BytesByteBuf(buffer);
-  }
-
   /**
    * Copies a byte array into a new {@link Bytes} object.
    * <p>
@@ -106,35 +90,34 @@ static Bytes copy (ByteBuffer buffer) {
   }
 
   /**
-   * Copies a {@link ByteBuf} buffer into a new {@link Bytes} object.
-   * <p>
-   * Modifications to this buffer's content will not cause the wrapped
-   * buffer's content to be modified, and vice versa.
-   *
-   * @param buffer the value to copy
+   * Create a new {@link Bytes} instance with a fixed size content
    *
    * @return the new {@link Bytes} instance
    */
-  static Bytes copy (ByteBuf buffer) {
-    return BytesByteBuf.copy(buffer);
+  static Bytes allocate (int size) {
+    return new BytesFixedArray(size);
   }
 
   /**
-   * Create a new {@link Bytes} instance with a fixed size content
+   * Creates a new {@link Bytes} instance with a resizable content.
    *
    * @return the new {@link Bytes} instance
    */
-  static Bytes allocate (int size) {
-    return new BytesFixedArray(size);
+  static Bytes resizableArray () {
+    return new BytesExtendableArray();
   }
 
   /**
    * Creates a new {@link Bytes} instance with a resizable content.
    *
+   * @param initialSize the initial buffer's size
+   *
    * @return the new {@link Bytes} instance
+   *
+   * @since 1.13.0
    */
-  static Bytes resizableArray () {
-    return new BytesExtendableArray();
+  static Bytes resizableArray (int initialSize) {
+    return new BytesExtendableArray(initialSize);
   }
 
   /**
@@ -1773,4 +1756,15 @@ static Bytes resizableArray () {
    * @return the array that backs this buffer
    */
   byte[] array ();
+
+  /**
+   * Returns the copy of range the buffer's back byte array from
+   * <b>0</b> till <b>writeIndex</t>.
+   * <p>
+   * Modifications to this buffer's content may NOT cause the
+   * returned array's content to be modified, and vice versa.
+   *
+   * @return the copy of the array that backs this buffer
+   */
+  byte[] arrayCopy ();
 }

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

@@ -20,6 +20,7 @@
 
 import java.math.BigInteger;
 import java.nio.charset.Charset;
+import java.util.Arrays;
 
 import lombok.NonNull;
 import lombok.val;
@@ -473,6 +474,11 @@ public Bytes reset () {
     return this;
   }
 
+  @Override
+  public byte[] arrayCopy () {
+    return Arrays.copyOfRange(array(), 0, writerIndex());
+  }
+
   protected void checkWriteBounds (int index, int length) {
     if (index < readerIndex() || index + length > capacity()) {
       val msg = String.format("Writer index error. index(%d) < readerIndex(%d) || index(%d)+length(%d) > capacity(%d)",

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

@@ -22,8 +22,20 @@
 
 class BytesExtendableArray extends BytesFixedArray {
 
+  /**
+   * The maximum size of array to allocate.
+   * Some VMs reserve some header words in an array.
+   * Attempts to allocate larger arrays may result in
+   * OutOfMemoryError: Requested array size exceeds VM limit
+   */
+  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
   BytesExtendableArray () {
-    super(16);
+    this(16);
+  }
+
+  BytesExtendableArray (int initialSize) {
+    super(initialSize);
   }
 
   @Override
@@ -36,31 +48,31 @@ public Bytes writerIndex (int newIndex) {
     if (newIndex < readerIndex()) {
       throw new IndexOutOfBoundsException();
     }
-    while (newIndex > capacity()) {
-      extendBuffer();
-    }
+    checkWriteBounds(newIndex, 1);
     writerIndex = newIndex;
     return this;
   }
 
-  @Override
-  public byte[] array () {
-    return Arrays.copyOfRange(buffer, 0, writerIndex);
-  }
-
   @Override
   protected void checkWriteBounds (int index, int length) {
-    if (index < readerIndex()) {
-      throw new IndexOutOfBoundsException();
-    }
-    while (index + length > capacity()) {
-      extendBuffer();
+    // if (index < readerIndex()) {
+    //   throw new IndexOutOfBoundsException();
+    // }
+    val currentCapacity = capacity();
+    val neededCapacity = index + length;
+    if (currentCapacity >= neededCapacity) {
+      return;
     }
-  }
 
-  private void extendBuffer () {
-    val newBuffer = new byte[capacity() * 2];
-    System.arraycopy(buffer, 0, newBuffer, 0, buffer.length);
-    buffer = newBuffer;
+    int newCapacity = currentCapacity * 2;
+    if (newCapacity - neededCapacity < 0) {
+      newCapacity = neededCapacity;
+    }
+    if (newCapacity - MAX_ARRAY_SIZE > 0) {
+      newCapacity = neededCapacity > MAX_ARRAY_SIZE
+                    ? Integer.MAX_VALUE
+                    : MAX_ARRAY_SIZE;
+    }
+    buffer = Arrays.copyOf(buffer, newCapacity);
   }
 }

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

@@ -23,6 +23,7 @@
 import java.io.InputStream;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
+import java.nio.channels.ReadableByteChannel;
 import java.util.stream.Stream;
 
 import io.appulse.utils.exception.CantReadFromArrayException;
@@ -1077,6 +1078,46 @@ public static byte[] read (@NonNull InputStream stream, int length) {
     return result;
   }
 
+  /**
+   * Reads all bytes from the channel till the buffer is full.
+   *
+   * @param channel the bytes source
+   *
+   * @param buffer the destination, whre readed bytes store
+   *
+   * @since 1.13.0
+   */
+  @SneakyThrows
+  public static void read (@NonNull ReadableByteChannel channel, @NonNull ByteBuffer buffer) {
+    int totalReaded = 0;
+    do {
+      val readed = channel.read(buffer);
+      if (readed > 0) {
+        totalReaded += readed;
+      } else if (readed == -1) {
+        return;
+      }
+    } while (totalReaded < buffer.capacity());
+  }
+
+  /**
+   * Reads the bytes from the channel till the buffer's limit.
+   *
+   * @param channel the bytes source
+   *
+   * @param buffer the destination, whre readed bytes store
+   *
+   * @param limit the limit amount of bytes for read
+   *
+   * @since 1.13.0
+   */
+  @SneakyThrows
+  public static void read (@NonNull ReadableByteChannel channel, @NonNull ByteBuffer buffer, int limit) {
+    val subBuffer = ByteBuffer.allocate(limit);
+    read(channel, subBuffer);
+    buffer.put(subBuffer);
+  }
+
   /**
    * Reads all bytes from stream till the end of the stream.
    *