mirror of https://github.com/etesync/android
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
155 lines
4.7 KiB
155 lines
4.7 KiB
/*
|
|
* ====================================================================
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
* ====================================================================
|
|
*
|
|
* This software consists of voluntary contributions made by many
|
|
* individuals on behalf of the Apache Software Foundation. For more
|
|
* information on the Apache Software Foundation, please see
|
|
* <http://www.apache.org/>.
|
|
*
|
|
*/
|
|
package org.apache.http.concurrent;
|
|
|
|
import org.apache.http.util.Args;
|
|
|
|
import java.util.concurrent.ExecutionException;
|
|
import java.util.concurrent.Future;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.TimeoutException;
|
|
|
|
/**
|
|
* Basic implementation of the {@link Future} interface. <tt>BasicFuture<tt>
|
|
* can be put into a completed state by invoking any of the following methods:
|
|
* {@link #cancel()}, {@link #failed(Exception)}, or {@link #completed(Object)}.
|
|
*
|
|
* @param <T> the future result type of an asynchronous operation.
|
|
* @since 4.2
|
|
*/
|
|
public class BasicFuture<T> implements Future<T>, Cancellable {
|
|
|
|
private final FutureCallback<T> callback;
|
|
|
|
private volatile boolean completed;
|
|
private volatile boolean cancelled;
|
|
private volatile T result;
|
|
private volatile Exception ex;
|
|
|
|
public BasicFuture(final FutureCallback<T> callback) {
|
|
super();
|
|
this.callback = callback;
|
|
}
|
|
|
|
public boolean isCancelled() {
|
|
return this.cancelled;
|
|
}
|
|
|
|
public boolean isDone() {
|
|
return this.completed;
|
|
}
|
|
|
|
private T getResult() throws ExecutionException {
|
|
if (this.ex != null) {
|
|
throw new ExecutionException(this.ex);
|
|
}
|
|
return this.result;
|
|
}
|
|
|
|
public synchronized T get() throws InterruptedException, ExecutionException {
|
|
while (!this.completed) {
|
|
wait();
|
|
}
|
|
return getResult();
|
|
}
|
|
|
|
public synchronized T get(final long timeout, final TimeUnit unit)
|
|
throws InterruptedException, ExecutionException, TimeoutException {
|
|
Args.notNull(unit, "Time unit");
|
|
final long msecs = unit.toMillis(timeout);
|
|
final long startTime = (msecs <= 0) ? 0 : System.currentTimeMillis();
|
|
long waitTime = msecs;
|
|
if (this.completed) {
|
|
return getResult();
|
|
} else if (waitTime <= 0) {
|
|
throw new TimeoutException();
|
|
} else {
|
|
for (;;) {
|
|
wait(waitTime);
|
|
if (this.completed) {
|
|
return getResult();
|
|
} else {
|
|
waitTime = msecs - (System.currentTimeMillis() - startTime);
|
|
if (waitTime <= 0) {
|
|
throw new TimeoutException();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean completed(final T result) {
|
|
synchronized(this) {
|
|
if (this.completed) {
|
|
return false;
|
|
}
|
|
this.completed = true;
|
|
this.result = result;
|
|
notifyAll();
|
|
}
|
|
if (this.callback != null) {
|
|
this.callback.completed(result);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean failed(final Exception exception) {
|
|
synchronized(this) {
|
|
if (this.completed) {
|
|
return false;
|
|
}
|
|
this.completed = true;
|
|
this.ex = exception;
|
|
notifyAll();
|
|
}
|
|
if (this.callback != null) {
|
|
this.callback.failed(exception);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean cancel(final boolean mayInterruptIfRunning) {
|
|
synchronized(this) {
|
|
if (this.completed) {
|
|
return false;
|
|
}
|
|
this.completed = true;
|
|
this.cancelled = true;
|
|
notifyAll();
|
|
}
|
|
if (this.callback != null) {
|
|
this.callback.cancelled();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean cancel() {
|
|
return cancel(true);
|
|
}
|
|
|
|
}
|