elf4j version bump

Author: q3769

pom.xml

@@ -28,7 +28,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.github.q3769</groupId>
     <artifactId>chunk4j</artifactId>
-    <version>20230309.0.3</version>
+    <version>20230309.0.4</version>
     <packaging>jar</packaging>
     <name>chunk4j</name>
     <description>A Java API to chop up larger data blobs into smaller "chunks" of a pre-defined size, and stitch the
@@ -134,12 +134,12 @@
         <dependency>
             <groupId>io.github.elf4j</groupId>
             <artifactId>elf4j</artifactId>
-            <version>2.1.1</version>
+            <version>2.2.1</version>
         </dependency>
         <dependency>
             <groupId>io.github.elf4j</groupId>
             <artifactId>elf4j-provider</artifactId>
-            <version>2.0.0</version>
+            <version>3.0.2</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -203,7 +203,7 @@
             <plugin>
                 <groupId>io.github.q3769</groupId>
                 <artifactId>semver-maven-plugin</artifactId>
-                <version>20221011.0.8</version>
+                <version>20221011.0.9</version>
             </plugin>
         </plugins>
     </build>

src/main/java/chunk4j/Chopper.java

@@ -32,7 +32,8 @@
 public interface Chopper {
 
     /**
-     * @param bytes the original data blob to be chopped into chunks
+     * @param bytes
+     *         the original data blob to be chopped into chunks
      * @return the group of chunks which the original data blob is chopped into. Each chunk carries a portion of the
      *         original bytes; and the size of that portion has a pre-configured maximum (a.k.a. the {@code Chunk}'s
      *         capacity). Thus, if the size of the original bytes is smaller or equal to the chunk's capacity, then the

src/main/java/chunk4j/ChunkChopper.java

@@ -47,7 +47,8 @@ private ChunkChopper(int chunkByteCapacity) {
     }
 
     /**
-     * @param maxChunkByteSize how big you want the chunks of your data chopped up to be
+     * @param maxChunkByteSize
+     *         how big you want the chunks of your data chopped up to be
      * @return new Chopper instance
      */
     public static ChunkChopper ofByteSize(int maxChunkByteSize) {

src/main/java/chunk4j/ChunkStitcher.java

@@ -69,8 +69,9 @@ private static Optional<byte[]> optionalOf(@Nullable byte[] bytes) {
     }
 
     /**
-     * @param chunk to be added to its corresponding chunk group, possibly stitched to restore the original data bytes
-     *              if this is the last chunk the group is expecting.
+     * @param chunk
+     *         to be added to its corresponding chunk group, possibly stitched to restore the original data bytes if
+     *         this is the last chunk the group is expecting.
      * @return non-empty <code>Optional</code> containing the original data bytes restored by the stitcher if the input
      *         chunk is the last missing piece of the entire chunk group representing the original data; otherwise, if
      *         the input chunk is not the last one expected, empty <code>Optional</code>.
@@ -121,8 +122,9 @@ public ChunkStitcher build() {
         }
 
         /**
-         * @param maxStitchTime max duration from the very first chunk received by the stitcher to the original data is
-         *                      restored completely
+         * @param maxStitchTime
+         *         max duration from the very first chunk received by the stitcher to the original data is restored
+         *         completely
          * @return the fluent builder
          */
         public Builder maxStitchTime(Duration maxStitchTime) {
@@ -131,8 +133,9 @@ public Builder maxStitchTime(Duration maxStitchTime) {
         }
 
         /**
-         * @param v Optional safeguard against excessive large size of target restore data - either by mistake or
-         *          malicious attack. Default to no size limit.
+         * @param v
+         *         Optional safeguard against excessive large size of target restore data - either by mistake or
+         *         malicious attack. Default to no size limit.
          * @return same builder instance
          */
         public Builder maxStitchedByteSize(int v) {
@@ -141,7 +144,8 @@ public Builder maxStitchedByteSize(int v) {
         }
 
         /**
-         * @param maxGroups max number of pending stitch groups. These groups will take up memory at runtime.
+         * @param maxGroups
+         *         max number of pending stitch groups. These groups will take up memory at runtime.
          * @return the fluent builder
          */
         public Builder maxStitchingGroups(long maxGroups) {
@@ -181,8 +185,9 @@ private static int totalByteSizeOf(@NonNull Collection<Chunk> chunks) {
         }
 
         /**
-         * @param chunk to be added in the stitching group, possibly stitched if this is the last chunk the group is
-         *              expecting.
+         * @param chunk
+         *         to be added in the stitching group, possibly stitched if this is the last chunk the group is
+         *         expecting.
          * @return the bytes by stitching together all the chunks in the group if the passed-in chunk is the last one
          *         the group is expecting; otherwise, <code>null</code>.
          */

src/main/java/chunk4j/Stitcher.java

@@ -32,11 +32,12 @@
 public interface Stitcher {
 
     /**
-     * @param chunk to be added to its corresponding chunk group. If this chunk renders its group "complete", i.e. all
-     *              the chunks of the original data blob are gathered, then the original data blob will be stitched
-     *              together and returned. Otherwise, if the chunk group still hasn't gathered all the chunks needed,
-     *              even with the addition of this chunk, then the whole group will be kept around, waiting for the
-     *              missing chunk(s) to arrive.
+     * @param chunk
+     *         to be added to its corresponding chunk group. If this chunk renders its group "complete", i.e. all the
+     *         chunks of the original data blob are gathered, then the original data blob will be stitched together and
+     *         returned. Otherwise, if the chunk group still hasn't gathered all the chunks needed, even with the
+     *         addition of this chunk, then the whole group will be kept around, waiting for the missing chunk(s) to
+     *         arrive.
      * @return non-empty <code>Optional</code> containing the original data blob restored by the stitcher if the input
      *         chunk is the last missing piece of the entire chunk group representing the original data; otherwise, if
      *         the input chunk is not the last one expected, empty <code>Optional</code>.