import scala.concurrent.Promise; //导入依赖的package包/类
Future<ActorSelection> readyTransaction() {
    // avoid the creation of a promise and a TransactionOperation
    if (transactionContext != null) {
        return transactionContext.readyTransaction();
    }

    final Promise<ActorSelection> promise = Futures.promise();
    enqueueTransactionOperation(new TransactionOperation() {
        @Override
        public void invoke(TransactionContext newTransactionContext) {
            promise.completeWith(newTransactionContext.readyTransaction());
        }
    });

    return promise.future();
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private <T> Future<T> transform(final Future<Object> future) {
    final Promise<T> promise = new scala.concurrent.impl.Promise.DefaultPromise<>();
    future.onComplete(new OnComplete<Object>() {
        @Override
        public void onComplete(final Throwable failure, final Object success) throws Throwable {
            if (success instanceof Throwable) {
                promise.failure((Throwable) success);
                return;
            }
            if (success == Void.TYPE) {
                promise.success(null);
                return;
            }
            promise.success((T) success);
        }
    }, context().dispatcher());
    return promise.future();
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
protected void init(Promise<Void> p) {
    log.info("[ARDRONE2 MODEL] Starting ARDrone 2.0 INIT");

    // Setup actor
    synchronized (lock) {
        if (initPromise == null) {
            initPromise = p;

            protocol = getContext().actorOf(Props.create(ArDrone2Protocol.class,
                    () -> new ArDrone2Protocol(new DroneConnectionDetails(ip, 5556, 5554), ArDrone2.this.self())));
        }
    }

    p.success(null);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
protected void init(Promise<Void> p) {
    // Discovery protocol + setup actor
    synchronized (lock) {
        if (connectionStatus == ConnectionStatus.NOT_INITIALIZED) {
            initPromise = p;

            connectionStatus = ConnectionStatus.CONNECTING;

            //TODO: dispose each time when udp bound is fixed
            protocol = getContext().actorOf(Props.create(ArDrone3.class,
                    () -> new ArDrone3(d2cPort, Bebop.this.self())), "protocol"); // Initialize listening already before broadcasting itself

            discoveryProtocol = getContext().actorOf(Props.create(ArDrone3Discovery.class,
                    () -> new ArDrone3Discovery(ip, Bebop.this.self(), d2cPort)), "discovery");
        }
    }
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private <T> boolean prematureExit(Promise<T> p) {
    if(connectionLost) {
        return true;
    }

    if(!initialized) {
        p.failure(new DroneException("Failed to send command. Not initialized yet."));
        return true;
    }

    if(crashed) {
        p.failure(new DroneException("Drone crashed, unable to execute commands"));
        return true;
    }
    return false;
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
protected void init(Promise<Void> p) {

    if(connectionLost) {
        return;
    }

    // Enable status updates
    eventBus.setPublishDisabled(false);

    // Schedule drones.simulation loop
    simulationTick = system.scheduler().schedule(
            simulationTimeStep,
            simulationTimeStep,
            self(),
            new StepSimulationMessage(simulationTimeStep),
            system.dispatcher(),
            self());

    initialized = true;
    p.success(null);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
protected void takeOff(Promise<Void> p) {

    if (prematureExit(p)) {
        return;
    }

    switch (state.getRawValue()) {
        case EMERGENCY:
            p.failure(new DroneException("Drone is in emergency status"));
            break;
        case LANDING:
            // Land drone before taking off again
            setFlyingState(FlyingState.LANDED);
            // Fall-through
        case LANDED:
            setFlyingState(FlyingState.TAKINGOFF);
            setAltitude(1);
            setFlyingState(FlyingState.HOVERING);
            // Fall-through
        default:
            p.success(null);
    }
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private void initInternal(final ActorRef sender, final ActorRef self) {
    if (!loading && !loaded) {
        loading = true;
        final ExecutionContext ec = getContext().system().dispatcher();

        log.debug("Attempting init.");

        Promise<Void> p = Futures.promise();
        p.future().onFailure(new OnFailure() {
            @Override
            public void onFailure(Throwable failure) throws Throwable {
                loading = false;
                loaded = false;
            }
        }, ec);
        p.future().onSuccess(new OnSuccess<Void>() {
            @Override
            public void onSuccess(Void result) throws Throwable {
                loaded = true;
                loading = false;
            }
        }, ec);
        handleMessage(p.future(), sender, self);
        init(p);
    }
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
final protected void moveToLocation(Promise<Void> v, double latitude, double longitude, double altitude) {
    synchronized (navigationLock) {
        if (navigationState.getRawValue() == NavigationState.IN_PROGRESS) {
            v.failure(new DroneException("Already navigating to " + getNavigator().getGoal() + ", abort this first."));
        } else if (navigationState.getRawValue() == NavigationState.UNAVAILABLE) {
            v.failure(new DroneException("Unable to navigate to goal"));
        } else if (!gpsFix.getRawValue()) {
            v.failure(new DroneException("No GPS fix yet."));
        } else {
            getNavigator().setCurrentLocation(location.getRawValue());
            getNavigator().setGoal(new Location(latitude, longitude, altitude));

            setNavigationState(NavigationState.IN_PROGRESS, NavigationStateReason.REQUESTED);
            v.success(null);
        }
    }
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Override
public F.Promise<Result> getDownload(String key, String name) {
    GeneratePresignedUrlRequest generatePresignedUrlRequest = new GeneratePresignedUrlRequest(bucketName, key);
    ResponseHeaderOverrides responseHeaders = new ResponseHeaderOverrides();
    responseHeaders.setContentDisposition("attachment; filename="+name);
    generatePresignedUrlRequest.setResponseHeaders(responseHeaders);

    AmazonS3 amazonS3 = new AmazonS3Client(credentials);

    try {
        URL url = amazonS3.generatePresignedUrl(generatePresignedUrlRequest);

        return F.Promise.pure(redirect(url.toString()));
    } catch (AmazonClientException ace) {
        logAmazonClientException (ace);
        return F.Promise.pure(internalServerError(error.render()));
    }
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private void setIfAlreadyComplete(final String field, Future<?> source,
		final Promise<Object> wait, SetterFailure onFailure) {
	if (source.isCompleted() && !wait.isCompleted()){
		Object returnValue;
		try {
			returnValue = Await.result(source, Duration.create(0, TimeUnit.SECONDS));
			if (returnValue instanceof Null){
				BeanUtils.setProperty(getThis(), field, null);
			} else {
				BeanUtils.setProperty(getThis(), field, returnValue);
			}
		} catch (Exception exception) {
			handleCallbackException(field, onFailure, exception, wait);
		}
		try {
			wait.success(null);
		} catch (IllegalStateException e){}
	}
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private void addIfAlreadyComplete(final String field, Future<?> source,
		final Promise<Object> wait, SetterFailure onFailure) {
	if (source.isCompleted() && !wait.isCompleted()){
		Object returnValue;
		try {
			returnValue = Await.result(source, Duration.create(0, TimeUnit.SECONDS));
			if (!(returnValue instanceof Null)){
				((List)PropertyUtils.getProperty(getThis(), field)).add(returnValue);
			}
		} catch (Exception exception) {
			handleCallbackException(field, onFailure, exception, wait);
		}
		
		try {
			wait.success(null);
		} catch (IllegalStateException e){}
	}
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public void add(final String field, Future<?> source, final Promise<Object> waiter, final SetterFailure onFailure){
	source.onComplete(new OnComplete(){
		@Override
		public void onComplete(Throwable exception, Object returnValue)
				throws Throwable {
			if (exception == null){
				try {
					if (!(returnValue instanceof Null)){
						((List)PropertyUtils.getProperty(getThis(), field)).add(returnValue);
					}
				} catch (IllegalAccessException | InvocationTargetException e){
					getLogger().error(exception, 
							String.format("Exception in add callback on widget / page [%s] field [%s]", 
									getThis().getClass().getCanonicalName(), field));
					exception = e;
				}
			} 
			if (exception != null){
				handleCallbackException(field, onFailure, exception, waiter);
			} else {
				waiter.success(null);
			}
		}	
	}, this.getActorContext().dispatcher());
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
private Route createRoute(ActorRef streamActor) {
    return route(
            path(segment("services").slash(longSegment()), id ->
                    get(() -> {
                        Promise<HttpResponse> promise = Futures.promise();
                        streamActor.tell(new Pair(id, promise), ActorRef.noSender());
                        return completeWithFuture(FutureConverters.toJava(promise.future()));
                    })));
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public String mapPromise() throws Exception {
  Promise<String> p = Promise.<String>apply();
  Future<String> f = p.future().map(mapF, ec);
  p.success(string);
  return Await.result(f, inf);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public String mapPromiseN() throws Exception {
  Promise<String> p = Promise.<String>apply();
  Future<String> f = p.future();
  for (int i = 0; i < N.n; i++)
    f = f.map(mapF, ec);
  p.success(string);
  return Await.result(f, inf);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public String flatMapPromise() throws Exception {
  Promise<String> p = Promise.<String>apply();
  Future<String> f = p.future().flatMap(flatMapF, ec);
  p.success(string);
  return Await.result(f, inf);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public String flatMapPromiseN() throws Exception {
  Promise<String> p = Promise.<String>apply();
  Future<String> f = p.future();
  for (int i = 0; i < N.n; i++)
    f = f.flatMap(flatMapF, ec);
  p.success(string);
  return Await.result(f, inf);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public Void ensurePromise() throws Exception {
  Promise<Void> p = Promise.<Void>apply();
  Future<Void> f = p.future().transform(ensureF, ec);
  p.success(null);
  return Await.result(f, inf);
}
 

import scala.concurrent.Promise; //导入依赖的package包/类
@Benchmark
public Void ensurePromiseN() throws Exception {
  Promise<Void> p = Promise.<Void>apply();
  Future<Void> f = p.future();
  for (int i = 0; i < N.n; i++)
    f = f.transform(ensureF, ec);
  p.success(null);
  return Await.result(f, inf);
}