Simplified elvis-like operator

winterbe · winterbe · commit e7d913356545 · 2015-03-13T17:24:49.000+01:00
diff --git a/src/com/winterbe/java8/Take.java b/src/com/winterbe/java8/Take.java
@@ -0,0 +1,54 @@
+package com.winterbe.java8;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * Simplified elvis-like operator. You can achieve the same with Optional but Take has simpler syntax.
+ * 
+ * @see Optional2
+ * @author Benjamin Winterberg
+ */
+public class Take<T> {
+
+    private static final Take<?> EMPTY = new Take<>(null);
+
+    private T value;
+
+    private Take(T value) {
+        this.value = value;
+    }
+
+    public static <T> Take<T> of(T something) {
+        return new Take<>(something);
+    }
+
+    public <S> Take<S> take(Function<? super T, S> mapper) {
+        if (!isPresent()) {
+            return empty();
+        }
+        S result = mapper.apply(value);
+        return new Take<>(result);
+    }
+
+    public Optional<T> get() {
+        return Optional.ofNullable(value);
+    }
+
+    public T orElse(T fallback) {
+        if (isPresent()) {
+            return value;
+        }
+        return fallback;
+    }
+
+    public boolean isPresent() {
+        return value != null;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> Take<T> empty() {
+        return (Take<T>) EMPTY;
+    }
+
+}
diff --git a/src/com/winterbe/java8/TakeTest.java b/src/com/winterbe/java8/TakeTest.java
@@ -0,0 +1,46 @@
+package com.winterbe.java8;
+
+import java.util.Optional;
+
+/**
+ * @author Benjamin Winterberg
+ */
+public class TakeTest {
+
+    static class Outer {
+        Nested nested = new Nested();
+
+        Nested getNested() {
+            return nested;
+        }
+    }
+
+    static class Nested {
+        Inner inner = new Inner();
+
+        Inner getInner() {
+            return inner;
+        }
+    }
+
+    static class Inner {
+        String foo = "foo";
+
+        String getFoo() {
+            return foo;
+        }
+    }
+
+    public static void main(String[] args) {
+        Outer something = new Outer();
+
+        Optional<String> optional = Take.of(something)
+                .take(Outer::getNested)
+                .take(Nested::getInner)
+                .take(Inner::getFoo)
+                .get();
+
+        System.out.println(optional.get());
+    }
+
+}
