Optional<> replaced with NullableValue<>

koma1 · Aug 17, 2021 · 10e9c7f · 10e9c7f
1 parent 634cebd
commit 10e9c7f
Show file tree

Hide file tree

Showing 2 changed files with 33 additions and 13 deletions.
diff --git a/src/main/java/pw/komarov/streamer/Streamer.java b/src/main/java/pw/komarov/streamer/Streamer.java
@@ -1,5 +1,7 @@
 package pw.komarov.streamer;
 
+import pw.komarov.utils.NullableValue;
+
 import java.util.*;
 import java.util.function.*;
 import java.util.stream.*;
@@ -213,7 +215,7 @@ public T next() {
             return next;
         }
 
-        @SuppressWarnings({"OptionalAssignedToNull","unchecked"})
+        @SuppressWarnings("unchecked")
         private void calculateSorted() {
             for (int i = 1; i <= sortedCount; i++) {
                 //building local operations list (from general operations list, by extracting sublist)
@@ -234,13 +236,13 @@ private void calculateSorted() {
 
                 //data collecting
                 final List<T> data = new ArrayList<>();
-                Optional<T> nextOpt;
+                NullableValue<T> nextValue;
                 do {
-                    nextOpt = getNext(localOperations);
-                    if (nextOpt != null)
-                        data.add(nextOpt.orElse(null));
+                    nextValue = getNext(localOperations);
+                    if (nextValue != null)
+                        data.add(nextValue.get());
 
-                } while (nextOpt != null);
+                } while (nextValue != null);
 
                 //sorting...
                 if (sortedOperation != null)
@@ -252,16 +254,15 @@ private void calculateSorted() {
         }
 
         private void calcNextAndHasNext() { //calculating next and getNext
-            Optional<T> opt = getNext(intermediateOperations);
+            NullableValue<T> nextValue = getNext(intermediateOperations);
 
-            //noinspection OptionalAssignedToNull
-            hasNext = opt != null;
+            hasNext = nextValue != null;
             if (hasNext)
-                next = opt.orElse(null);
+                next = nextValue.get();
         }
 
         @SuppressWarnings({"unchecked"})
-        private Optional<T> getNext(List<IntermediateOperation> operations) {
+        private NullableValue<T> getNext(List<IntermediateOperation> operations) {
             T next = null;
 
             boolean hasNext = !noNext && sourceIterator.hasNext();
@@ -293,10 +294,9 @@ private Optional<T> getNext(List<IntermediateOperation> operations) {
                 for (Consumer<? super T> peekSequence : peekSequences)
                     peekSequence.accept(next);
 
-                return Optional.ofNullable(next);
+                return NullableValue.of(next);
             }
 
-            //noinspection OptionalAssignedToNull
             return null;
         }
 

diff --git a/src/main/java/pw/komarov/utils/NullableValue.java b/src/main/java/pw/komarov/utils/NullableValue.java
@@ -0,0 +1,20 @@
+package pw.komarov.utils;
+
+public class NullableValue<E> {
+    private static final NullableValue<?> NULLABLE = new NullableValue<>(null);
+
+    private final E value;
+
+    private NullableValue(E value) {
+        this.value = value;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <E> NullableValue<E> of(E value) {
+        return value == null ? (NullableValue<E>) NULLABLE : new NullableValue<>(value);
+    }
+
+    public E get() {
+        return value;
+    }
+}