2 * Copyright (c) 2014 Brocade Communications Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.yangtools.util.concurrent;
11 import com.google.common.base.Function;
12 import com.google.common.base.Preconditions;
13 import com.google.common.util.concurrent.AbstractCheckedFuture;
14 import com.google.common.util.concurrent.ListenableFuture;
15 import java.util.concurrent.CancellationException;
16 import java.util.concurrent.ExecutionException;
17 import java.util.concurrent.TimeUnit;
18 import java.util.concurrent.TimeoutException;
21 * An implementation of CheckedFuture that provides similar behavior for the <code>get</code> methods
22 * that the <code>checkedGet</code> methods provide.
24 * For {@link CancellationException} and {@link InterruptedException}, the specified exception mapper
25 * is invoked to translate them to the checked exception type.
27 * For {@link ExecutionException}, the mapper is invoked to translate the cause to the checked exception
28 * and a new ExecutionException is thrown with the translated cause.
30 * @author Thomas Pantelis
32 * @param <V> The result type returned by this Future's get method
33 * @param <X> The checked exception type
35 public final class MappingCheckedFuture<V, X extends Exception> extends AbstractCheckedFuture<V, X> {
37 private final Function<Exception, X> mapper;
39 private MappingCheckedFuture( final ListenableFuture<V> delegate, final Function<Exception, X> mapper ) {
41 this.mapper = Preconditions.checkNotNull( mapper );
45 * Creates a new <code>MappingCheckedFuture</code> that wraps the given {@link ListenableFuture}
48 * @param delegate the {@link ListenableFuture} to wrap
49 * @param mapper the mapping {@link Function} used to translate exceptions from the delegate
50 * @return a new <code>MappingCheckedFuture</code>
52 public static <V, X extends Exception> MappingCheckedFuture<V, X> create(
53 final ListenableFuture<V> delegate, final Function<Exception, X> mapper ) {
54 return new MappingCheckedFuture<>(delegate, mapper);
58 protected X mapException( final Exception e ) {
59 return mapper.apply( e );
62 private ExecutionException wrapInExecutionException( final String message, final Exception e ) {
63 return new ExecutionException( message, mapException( e ) );
67 public V get() throws InterruptedException, ExecutionException {
70 } catch( final InterruptedException e ) {
71 Thread.currentThread().interrupt();
72 throw wrapInExecutionException( "Operation was interrupted", e );
73 } catch( final CancellationException e ) {
74 throw wrapInExecutionException( "Operation was cancelled", e );
75 } catch( final ExecutionException e ) {
76 throw wrapInExecutionException( e.getMessage(), e );
81 public V get( final long timeout, final TimeUnit unit )
82 throws InterruptedException, ExecutionException, TimeoutException {
84 return super.get( timeout, unit );
85 } catch( final InterruptedException e ) {
86 Thread.currentThread().interrupt();
87 throw wrapInExecutionException( "Operation was interrupted", e );
88 } catch( final CancellationException e ) {
89 throw wrapInExecutionException( "Operation was cancelled", e );
90 } catch( final ExecutionException e ) {
91 throw wrapInExecutionException( e.getMessage(), e );