CompletableFutureBasic + CachingDataStorageImpl

src/main/java/part2/cache/CachingDataStorageImpl.java

@@ -1,7 +1,6 @@
 package part2.cache;
 
 import db.DataStorage;
-import db.SlowCompletableFutureDb;
 
 import java.util.concurrent.*;
 
@@ -32,12 +31,36 @@ public CachingDataStorageImpl(DataStorage<String, T> db, int timeout, TimeUnit t
 
     @Override
     public OutdatableResult<T> getOutdatable(String key) {
+        CompletableFuture<T> result = new CompletableFuture<>();
+        CompletableFuture<Void> outdated = new CompletableFuture<>();
+
+        OutdatableResult<T> newResult = new OutdatableResult<>(result, outdated);
+        OutdatableResult<T> cacheResult = cache.putIfAbsent(key, newResult);
+
+        if (cacheResult != null)
+            return cacheResult;
+
+        db.get(key).whenComplete((e, th) -> {
+            if (th != null)
+                result.completeExceptionally(th);
+            else {
+                result.complete(e);
+            }
+            scheduledExecutorService.schedule(() -> {
+                        cache.remove(key, newResult);
+                        outdated.complete(null);
+                    },
+                    timeout,
+                    timeoutUnits);
+        });
+
+        return newResult;
+
         // TODO implement
         // TODO use ScheduledExecutorService to remove outdated result from cache - see SlowCompletableFutureDb implementation
         // TODO complete OutdatableResult::outdated after removing outdated result from cache
         // TODO don't use obtrudeException on result - just don't
         // TODO use remove(Object key, Object value) to remove target value
         // TODO Start timeout after receiving result in CompletableFuture, not after receiving CompletableFuture itself
-        throw new UnsupportedOperationException();
     }
 }

src/test/java/part1/exercise/CompletableFutureBasics.java

@@ -60,42 +60,36 @@ public static void after() {
     public void createNonEmpty() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
         assertTrue(optPerson.isPresent());
         assertEquals(person, optPerson.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
         final List<Person> persons = streamPerson.collect(toList());
         assertThat(persons.size(), is(1));
         assertEquals(person, persons.get(0));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
         assertTrue(futurePerson.isDone());
         assertEquals(person, futurePerson.get());
     }
 
     @Test
     public void createEmpty() throws ExecutionException, InterruptedException {
-        // TODO Create empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.empty();
 
         assertFalse(optPerson.isPresent());
 
-        // TODO Create empty stream
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.empty();
 
         final List<Person> persons = streamPerson.collect(toList());
         assertThat(persons.size(), is(0));
 
-        // TODO Complete CompletableFuture with NoSuchElementException
-        final CompletableFuture<Person> futurePerson = null;
-        // futurePerson.???
+        final CompletableFuture<Person> futurePerson = new CompletableFuture<>();
+         futurePerson.completeExceptionally(new NoSuchElementException());
 
         assertTrue(futurePerson.isCompletedExceptionally());
         assertTrue(futurePerson
@@ -107,56 +101,48 @@ public void createEmpty() throws ExecutionException, InterruptedException {
     public void forEach() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
         final CompletableFuture<Person> result1 = new CompletableFuture<>();
 
-        // TODO using optPerson.ifPresent complete result1
+        optPerson.ifPresent(result1::complete);
+
         assertEquals(person, result1.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
         final CompletableFuture<Person> result2 = new CompletableFuture<>();
 
-        // TODO Using streamPerson.forEach complete result2
+        streamPerson.forEach(result2::complete);
         assertEquals(person, result2.get());
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
         final CompletableFuture<Person> result3 = new CompletableFuture<>();
 
-        // TODO Using futurePerson.thenAccept complete result3
+        futurePerson.thenAccept(result3::complete);
         assertEquals(person, result3.get());
     }
 
     @Test
     public void map() throws ExecutionException, InterruptedException {
         final Person person = new Person("John", "Galt", 33);
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
-        // TODO get Optional<first name> from optPerson
-        final Optional<String> optFirstName = null;
+        final Optional<String> optFirstName = Optional.of(person.getFirstName());
 
         assertEquals(person.getFirstName(), optFirstName.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
-        // TODO Get Stream<first name> from streamPerson
-        final Stream<String> streamFirstName = null;
+        final Stream<String> streamFirstName = streamPerson.map(Person::getFirstName);
 
         assertEquals(person.getFirstName(), streamFirstName.collect(toList()).get(0));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
-        // TODO Get CompletableFuture<first name> from futurePerson
-        final CompletableFuture<String> futureFirstName = null;
+        final CompletableFuture<String> futureFirstName = futurePerson.thenApply(Person::getFirstName);
 
         assertEquals(person.getFirstName(), futureFirstName.get());
     }
@@ -165,31 +151,30 @@ public void map() throws ExecutionException, InterruptedException {
     public void flatMap() throws ExecutionException, InterruptedException {
         final Person person = employeeDb.get(keys.get(0)).thenApply(Employee::getPerson).get();
 
-        // TODO Create non empty Optional
-        final Optional<Person> optPerson = null;
+        final Optional<Person> optPerson = Optional.of(person);
 
-        // TODO Using flatMap and .getFirstName().codePoints().mapToObj(p -> p).findFirst()
-        // TODO get the first letter of first name if any
-        final Optional<Integer> optFirstCodePointOfFirstName =
-                null;
+        final Optional<Integer> optFirstCodePointOfFirstName = optPerson
+                .flatMap(person1 -> person1.getFirstName()
+                                .codePoints()
+                                .boxed()
+                                .findFirst());
 
         assertEquals(Integer.valueOf(65), optFirstCodePointOfFirstName.get());
 
-        // TODO Create stream with a single element
-        final Stream<Person> streamPerson = null;
+        final Stream<Person> streamPerson = Stream.of(person);
 
-        // TODO Using flatMapToInt and .getFirstName().codePoints() get codepoints stream from streamPerson
-        final IntStream codePoints = null;
+        final IntStream codePoints = streamPerson
+                .flatMapToInt(person1 -> person1
+                        .getFirstName()
+                        .codePoints());
 
         final int[] codePointsArray = codePoints.toArray();
         assertEquals(person.getFirstName(), new String(codePointsArray, 0, codePointsArray.length));
 
-        // TODO Create completed CompletableFuture
-        final CompletableFuture<Person> futurePerson = null;
+        final CompletableFuture<Person> futurePerson = CompletableFuture.completedFuture(person);
 
-        // TODO Get CompletableFuture<Employee> from futurePerson using getKeyByPerson and employeeDb
-        final CompletableFuture<Employee> futureEmployee = null;
+        final CompletableFuture<Employee> futureEmployee = employeeDb.get(getKeyByPerson(futurePerson.get()));
 
         assertEquals(person, futureEmployee.thenApply(Employee::getPerson).get());
     }
-}
+}