Example usage for com.google.common.util.concurrent Futures dereference

Introduction

In this page you can find the example usage for com.google.common.util.concurrent Futures dereference.

Prototype

@SuppressWarnings({ "rawtypes", "unchecked" })
@CheckReturnValue
public static <V> ListenableFuture<V> dereference(
        ListenableFuture<? extends ListenableFuture<? extends V>> nested) 

Source Link

Document

Returns a new ListenableFuture whose result is the product of calling get() on the Future nested within the given Future , effectively chaining the futures one after the other.

Usage

From source file:org.robotninjas.barge.RaftService.java

public ListenableFuture<Object> commitAsync(final byte[] operation) throws RaftException {

    // Make sure this happens on the Barge thread
    ListenableFuture<ListenableFuture<Object>> response = executor
            .submit(new Callable<ListenableFuture<Object>>() {
                @Override/*  w  ww.j  ava  2  s  .  c o  m*/
                public ListenableFuture<Object> call() throws Exception {
                    return ctx.commitOperation(operation);
                }
            });

    return Futures.dereference(response);

}

---

From source file:org.opendaylight.openflowplugin.openflow.md.core.sal.OFRpcTask.java

/**
 * submit task into rpc worker pool//from w  ww .ja  va  2 s  .c o m
 * @return future result of task 
 */
public ListenableFuture<K> submit() {
    ListenableFuture<ListenableFuture<K>> compoundResult = getTaskContext().getRpcPool().submit(this);
    return Futures.dereference(compoundResult);
}

---

From source file:com.yahoo.yqlplus.engine.internal.generate.ProgramInvocation.java

public final GambitRuntime getRuntime(TaskContext context) {
    final ListeningExecutorService tasks = ((ScopedTracingExecutor) this.tasks).createSubExecutor(context);
    return new GambitRuntime() {
        @Override/*from   w  w  w .  ja  v  a  2  s .c om*/
        public ListenableFuture<List<Object>> scatter(List<Callable<Object>> targets) {
            List<ListenableFuture<Object>> resultList = Lists.newArrayListWithExpectedSize(targets.size());
            for (Callable<Object> out : targets) {
                resultList.add(fork(out));
            }
            return Futures.allAsList(resultList);
        }

        @Override
        public ListenableFuture<List<Object>> scatterAsync(List<Callable<ListenableFuture<Object>>> targets) {
            List<ListenableFuture<Object>> resultList = Lists.newArrayListWithExpectedSize(targets.size());
            for (Callable<ListenableFuture<Object>> out : targets) {
                resultList.add(forkAsync(out));
            }
            return Futures.allAsList(resultList);
        }

        @Override
        public ListenableFuture<Object> fork(Callable<Object> target) {
            return tasks.submit(target);
        }

        @Override
        public ListenableFuture<Object> forkAsync(Callable<ListenableFuture<Object>> target) {
            return Futures.dereference(tasks.submit(target));
        }
    };
}

---

From source file:io.v.v23.rpc.ReflectInvoker.java

@Override
public ListenableFuture<Object[]> invoke(final VContext ctx, final StreamServerCall call, final String method,
        final Object[] args) {
    Executor executor = V.getExecutor(ctx);
    if (executor == null) {
        return Futures.immediateFailedFuture(new VException("NULL executor in context: did "
                + "you derive server context from the context returned by V.init()?"));
    }/*w ww .  j  a v a2s  .c om*/
    try {
        final ServerMethod m = findMethod(method);
        final SettableFuture<ListenableFuture<Object[]>> ret = SettableFuture.create();
        // Invoke the method.
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    if (ctx.isCanceled()) {
                        ret.setException(new CanceledException(ctx));
                        return;
                    }
                    // Invoke the method and process results.
                    Object[] allArgs = new Object[2 + args.length];
                    allArgs[0] = ctx;
                    allArgs[1] = call;
                    System.arraycopy(args, 0, allArgs, 2, args.length);
                    Object result = m.invoke(allArgs);
                    ret.set(prepareReply(m, result));
                } catch (InvocationTargetException | IllegalAccessException e) {
                    ret.setException(new VException(
                            String.format("Error invoking method %s: %s", method, e.getCause().toString())));
                }
            }
        });
        return Futures.dereference(ret);
    } catch (VException e) {
        return Futures.immediateFailedFuture(e);
    }
}

---

From source file:com.android.tools.idea.avdmanager.AvdManagerConnection.java

/**
 * Handle the {@link AccelerationErrorCode} found when attempting to start an AVD.
 * @param project/*from  w ww.j  a va2s.c o m*/
 * @param error
 * @return a future with a device that was launched delayed, or null if startAvd should proceed to start the AVD.
 */
@Nullable
private ListenableFuture<IDevice> handleAccelerationError(@Nullable final Project project,
        @NotNull final AvdInfo info, @NotNull AccelerationErrorCode error) {
    switch (error) {
    case ALREADY_INSTALLED:
        return null;
    case TOOLS_UPDATE_REQUIRED:
    case PLATFORM_TOOLS_UPDATE_ADVISED:
    case SYSTEM_IMAGE_UPDATE_ADVISED:
        // Do not block emulator from running if we need updates (run with degradated performance):
        return null;
    case NO_EMULATOR_INSTALLED:
        // report this error below
        break;
    default:
        Abi abi = Abi.getEnum(info.getAbiType());
        boolean isAvdIntel = abi == Abi.X86 || abi == Abi.X86_64;
        if (!isAvdIntel) {
            // Do not block Arm and Mips emulators from running without an accelerator:
            return null;
        }
        // report all other errors
        break;
    }
    String accelerator = SystemInfo.isLinux ? "KVM" : "Intel HAXM";
    int result = Messages.showOkCancelDialog(project,
            String.format("%1$s is required to run this AVD.\n%2$s\n\n%3$s\n", accelerator, error.getProblem(),
                    error.getSolutionMessage()),
            error.getSolution().getDescription(), AllIcons.General.WarningDialog);
    if (result != Messages.OK || error.getSolution() == AccelerationErrorSolution.SolutionCode.NONE) {
        return Futures.immediateFailedFuture(new RuntimeException("Could not start AVD"));
    }
    final SettableFuture<ListenableFuture<IDevice>> future = SettableFuture.create();
    Runnable retry = () -> future.set(startAvd(project, info));
    Runnable cancel = () -> future.setException(new RuntimeException("Retry after fixing problem by hand"));
    Runnable action = AccelerationErrorSolution.getActionForFix(error, project, retry, cancel);
    ApplicationManager.getApplication().invokeLater(action);
    return Futures.dereference(future);
}

---

From source file:io.v.todos.persistence.syncbase.SyncbasePersistence.java

/**
 * This constructor is blocking for simplicity.
 *//*from  ww  w . j  a  v a 2  s  .c  o m*/
public SyncbasePersistence(final Activity activity, Bundle savedInstanceState)
        throws VException, SyncbaseServer.StartException {
    mVAndroidContext = VAndroidContexts.withDefaults(activity, savedInstanceState);

    FragmentManager mgr = activity.getFragmentManager();
    if (savedInstanceState == null) {
        FragmentTransaction t = mgr.beginTransaction();
        addFeatureFragments(mgr, t);
        t.commit();
    } else {
        addFeatureFragments(mgr, null);
    }

    // We might not actually have to seek blessings each time, but getBlessings does not
    // block if we already have blessings and this has better-behaved lifecycle
    // implications than trying to seek blessings in the static code.
    final SettableFuture<ListenableFuture<Blessings>> blessings = SettableFuture.create();
    if (activity.getMainLooper().getThread() == Thread.currentThread()) {
        blessings.set(BlessingsManager.getBlessings(getVContext(), activity, BLESSINGS_KEY, true));
    } else {
        new Handler(activity.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                blessings.set(BlessingsManager.getBlessings(getVContext(), activity, BLESSINGS_KEY, true));
            }
        });
    }

    VFutures.sync(Futures.dereference(blessings));
    appVInit(activity.getApplicationContext());
    final SyncbasePersistence self = this;
    /*final Future<?> ensureCloudDatabaseExists = sExecutor.submit(new Runnable() {
    @Override
    public void run() {
        ensureCloudDatabaseExists();
    }
    });*/
    ensureSyncbaseStarted(activity);
    ensureDatabaseExists();
    ensureUserCollectionExists();
    // TODO(alexfandrianto): If the cloud is dependent on me, then we must do this too.
    // VFutures.sync(ensureCloudDatabaseExists); // must finish before syncgroup setup
    ensureUserSyncgroupExists();
    Sharing.initDiscovery(sDatabase); // requires that db and collection exist
    sInitialized = true;
}

---