default futures

Author: car031

logicaldoc-core/src/main/java/com/logicaldoc/core/document/DocumentFuture.java

@@ -0,0 +1,22 @@
+package com.logicaldoc.core.document;
+
+import java.util.concurrent.Future;
+
+import com.logicaldoc.util.concurrent.FutureElaboration;
+
+/**
+ * A future used to track asynchronous elaborations on a document.
+ * 
+ * @author Marco Meschieri - LogicalDOC
+ * @since 9.2
+ */
+public class DocumentFuture extends FutureElaboration<Document, Document> {
+
+	public DocumentFuture(Document document, Future<Document> future) {
+		super(document, future);
+	}
+
+	public Document getDocument() {
+		return super.getObject();
+	}
+}

logicaldoc-util/src/main/java/com/logicaldoc/util/concurrent/FutureElaboration.java

@@ -0,0 +1,56 @@
+package com.logicaldoc.util.concurrent;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * A future that wraps an other future representing some kind of elaboration on a specified object
+ * 
+ * @author Marco Meschieri - LogicalDOC
+ * @since 9.2
+ *
+ * @param <V> Type of the wrapped future
+ * @param <T> Type of the object being elaborated
+ */
+public class FutureElaboration<T, V> implements Future<V> {
+
+	private T object;
+
+	private Future<V> future;
+
+	public FutureElaboration(T object, Future<V> future) {
+		this.object = object;
+		this.future = future;
+	}
+
+	@Override
+	public boolean cancel(boolean mayInterruptIfRunning) {
+		return future.cancel(mayInterruptIfRunning);
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return future.isCancelled();
+	}
+
+	@Override
+	public boolean isDone() {
+		return future.isDone();
+	}
+
+	@Override
+	public V get() throws InterruptedException, ExecutionException {
+		return future.get();
+	}
+
+	@Override
+	public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		return future.get(timeout, unit);
+	}
+
+	public T getObject() {
+		return object;
+	}
+}

logicaldoc-util/src/main/java/com/logicaldoc/util/concurrent/FutureValue.java

@@ -0,0 +1,53 @@
+package com.logicaldoc.util.concurrent;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * A simple future that is always complete and always returns the given value
+ * 
+ * @author Marco Meschieri - LogicalDOC
+ * @since 9.2
+ *
+ * @param <V> Type of future
+ */
+public class FutureValue<V> implements Future<V> {
+
+	private V value;
+
+	public FutureValue() {
+		super();
+	}
+
+	public FutureValue(V value) {
+		super();
+		this.value = value;
+	}
+
+	@Override
+	public boolean cancel(boolean mayInterruptIfRunning) {
+		return false;
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return false;
+	}
+
+	@Override
+	public boolean isDone() {
+		return true;
+	}
+
+	@Override
+	public V get() throws InterruptedException, ExecutionException {
+		return value;
+	}
+
+	@Override
+	public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		return value;
+	}
+}

logicaldoc-util/src/main/java/com/logicaldoc/util/concurrent/SerialFuture.java

@@ -0,0 +1,70 @@
+package com.logicaldoc.util.concurrent;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * A future returns null but waits for the completion of a given collection of
+ * futures
+ * 
+ * @author Marco Meschieri - LogicalDOC
+ * @since 9.2
+ *
+ * @param <V> Type of all the futures to wait for
+ */
+public class SerialFuture<V> implements Future<V> {
+
+	private List<Future<V>> futures = new ArrayList<>();
+
+	public SerialFuture(Collection<Future<V>> futures) {
+		for (Future<V> future : futures) {
+			this.futures.add(future);
+		}
+	}
+
+	@Override
+	public boolean cancel(boolean mayInterruptIfRunning) {
+		return futures.stream().allMatch(f -> f.cancel(mayInterruptIfRunning));
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return futures.stream().allMatch(f -> f.isCancelled());
+	}
+
+	@Override
+	public boolean isDone() {
+		return futures.stream().allMatch(f -> f.isDone());
+	}
+
+	@Override
+	public V get() throws InterruptedException, ExecutionException {
+		return getAll().stream().findFirst().orElse(null);
+	}
+
+	public List<V> getAll() throws InterruptedException, ExecutionException {
+		List<V> gets = new ArrayList<>();
+		for (Future<V> future : futures)
+			gets.add(future.get());
+		return gets;
+	}
+
+	@Override
+	public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		return getAll(timeout, unit).stream().findFirst().orElse(null);
+	}
+
+	public List<V> getAll(long timeout, TimeUnit unit)
+			throws InterruptedException, ExecutionException, TimeoutException {
+		List<V> gets = new ArrayList<>();
+		for (Future<V> future : futures)
+			gets.add(future.get(timeout, unit));
+		return gets;
+	}
+
+}