JAVA :: FP :: Mapping

package aschuma.data.access;

import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class ProcessingTest {


   public static class Data1 {

      private final Data2 data2;

      public Data2 getData2() {
         return data2;
      }

      public Data1(final Data2 data2) {
         this.data2 = data2;
      }
   }

   public static class Data2 {

      private final List<Data3> data3;

      public Data2(final List<Data3> data3) {
         this.data3 = data3;
      }

      public List<Data3> getData3() {
         return data3;
      }

   }

   public static class Data3 {

      private final String key;
      private final double value;

      public Data3(final String key, final double value) {
         this.key = key;
         this.value = value;
      }

      public String getKey() {
         return key;
      }

      public Double getValue() {
         return value;
      }
   }

   public static class Optionals {
      public static <U> Optional<U> orElse(Optional<U> u, Optional<U> v) {
         return u.isPresent() ? u : v;
      }

      public static <U> Optional<U> orElse(Optional<U> u, U v) {
         return u.isPresent() ? u : Optional.ofNullable(v);
      }

      public static <U> Optional<U> orElse(Optional<U> u, Supplier<U> s) {
         Supplier<Optional<U>> uSupplier = () -> Optional.ofNullable(s.get());
         return orElse2(u, uSupplier);
      }

      public static <U> Optional<U> orElse2(Optional<U> u, Supplier<Optional<U>> s) {
         if (u.isPresent()) {
            return u;
         } else {
            return s.get();
         }
      }

   }

   Data1 data1;

   @Before
   public void setup() {
      Data3 data3a = new Data3("A", 1.0);
      Data3 data3b = new Data3("B", 2.0);
      Data3 data3c = new Data3("C", 3.0);
      Data3 data3d = new Data3("D", 4.0);

      Data2 data2 = new Data2(Arrays.asList(data3a, data3b, data3c, data3d));

      data1 = new Data1(data2);
   }

   @Test
   public void simpleTest() {

      // when

      String key = "B";

      Data1 base = data1;

      Optional<Double> aDouble = readData3From(key, base);
      Optionals.orElse(aDouble, 10.0).map(this::normalize).ifPresent(storeValue("REF_B"));

      // then

   }

   private Double normalize(Double d) {
      return d < 0 ? -d : d;
   }

   private Optional<Double> readData3From(final String key, final Data1 base) {
      return Optional
            .ofNullable(base.getData2().getData3())
            .flatMap(relevantData(key))
            .map(Data3::getValue);
   }

   private Consumer<Double> storeValue(final String fieldKey) {
      return aDouble -> System.out.println("" + fieldKey + " " + aDouble);
   }

   private Function<List<Data3>, Optional<Data3>> relevantData(final String key) {
      return list ->
            list.stream().filter(data3HasKey(key)).findFirst();
   }

   Predicate<Data3> data3HasKey(final String s) {
      return data3 -> s.equals(data3.getKey());
   }

}