More null safe operations

winterbe · winterbe · commit 76ff6b67a83a · 2015-03-14T07:55:06.000+01:00
diff --git a/src/com/winterbe/java8/Take.java b/src/com/winterbe/java8/Take.java
@@ -2,6 +2,7 @@
 
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * Simplified elvis-like operator. You can achieve the same with Optional but Take has simpler syntax.
@@ -19,15 +20,25 @@ private Take(T value) {
         this.value = value;
     }
 
+    public static <T> Optional<T> of(Supplier<T> resolver) {
+        try {
+            T result = resolver.get();
+            return Optional.ofNullable(result);
+        }
+        catch (NullPointerException e) {
+            return Optional.empty();
+        }
+    }
+
     public static <T> Take<T> of(T something) {
         return new Take<>(something);
     }
 
-    public <S> Take<S> take(Function<? super T, S> mapper) {
+    public <S> Take<S> take(Function<? super T, S> resolver) {
         if (!isPresent()) {
             return empty();
         }
-        S result = mapper.apply(value);
+        S result = resolver.apply(value);
         return new Take<>(result);
     }
 
diff --git a/src/com/winterbe/java8/TakeTest.java b/src/com/winterbe/java8/TakeTest.java
@@ -40,7 +40,21 @@ public static void main(String[] args) {
                 .take(Inner::getFoo)
                 .get();
 
-        System.out.println(optional.get());
+        System.out.println(optional.isPresent());
+
+        something.getNested().inner = null;
+        Optional<String> optional2 = Take.of(() ->
+                something.getNested().getInner().getFoo());
+        System.out.println(optional2.isPresent());
+
+
+        String x = null;
+        String y = "boo";
+        String z = Take.of(x).orElse(y);
+
+        System.out.println(z);
+
+
     }
 
 }
