Java Future.succeededFuture方法代碼示例

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * 解析報文頭。
 * 
 * @param headerBuffer header Buffer
 * @param expectedCommand expectedCommand
 * @param expectedBodyLength expectedBodyLength
 * @return async result of the length of the packet body
 */
public static Future<Long> parseHeader(Buffer headerBuffer, byte expectedCommand, long expectedBodyLength) {
	if (headerBuffer.length() != HEADER_BYTE_LENGTH) {
		return Future.failedFuture(new FdfsException("receive packet size" + headerBuffer.length()
				+ " is not equal to the expected header size: " + HEADER_BYTE_LENGTH));
	}

	byte command = headerBuffer.getByte(PROTO_HEADER_CMD_INDEX);
	if (command != expectedCommand) {
		return Future.failedFuture(new FdfsException(
				"receive command: " + command + " is not equal to the expected command: " + expectedCommand));
	}

	byte status = headerBuffer.getByte(PROTO_HEADER_STATUS_INDEX);
	if (status != HEADER_STATUS_SUCCESS) {
		return Future.failedFuture(new FdfsException("receive packet errno is: " + status));
	}

	long bodyLength = headerBuffer.getLong(0);
	if (expectedBodyLength > 0 && bodyLength != expectedBodyLength) {
		return Future.failedFuture(new FdfsException("receive packet body length: " + bodyLength
				+ " is not equal to the expected: " + expectedBodyLength));
	}

	return Future.succeededFuture(bodyLength);
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<FdfsStorageOptions> parseStorage(Buffer bodyBuffer, String charset, boolean hasPathIndex) {
	try {
		FdfsStorageOptions storageOptions = new FdfsStorageOptions(options);

		String group = FdfsUtils
				.fdfsTrim(bodyBuffer.getString(0, FdfsProtocol.FDFS_GROUP_NAME_MAX_LEN, options.getCharset()));
		String ip = FdfsUtils.fdfsTrim(bodyBuffer.getString(FdfsProtocol.FDFS_GROUP_NAME_MAX_LEN,
				FdfsProtocol.FDFS_GROUP_NAME_MAX_LEN + FdfsProtocol.FDFS_IPADDR_SIZE - 1, options.getCharset()));
		long port = bodyBuffer.getLong(FdfsProtocol.FDFS_GROUP_NAME_MAX_LEN + FdfsProtocol.FDFS_IPADDR_SIZE - 1);

		storageOptions.setGroup(group).setAddress(SocketAddress.inetSocketAddress((int) port, ip));

		if (hasPathIndex && bodyBuffer.length() > FdfsProtocol.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN) {
			byte storePathIndex = bodyBuffer.getByte(FdfsProtocol.TRACKER_QUERY_STORAGE_FETCH_BODY_LEN);
			storageOptions.setStorePathIndex(storePathIndex);
		}

		return Future.succeededFuture(storageOptions);
	} catch (Exception e) {
		return Future.failedFuture(e);
	}
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
/**
 * Check for the Authentication info if required
 *
 * @return a future that resolves when successful got AuthInfo
 */
private Future<AuthInfo> getAuthInfo() {
	Future<AuthInfo> result;
	final String authName = this.getConsumerConfig().getAuthName();
	if ((this.authInfo == null) && (authName != null)) {
		result = Future.future();
		final EventBus eb = this.getVertx().eventBus();
		final String address = Constants.BUS_AUTHREQUEST + authName;
		eb.send(address, null, replyHandler -> {
			if (replyHandler.succeeded()) {
				this.authInfo = (AuthInfo) replyHandler.result().body();
				result.complete(this.authInfo);
			} else {
				result.fail(replyHandler.cause());
			}
		});

	} else {
		result = Future.succeededFuture(this.authInfo);
	}
	return result;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<AuthInfo> getAuthInfo() {
	Future<AuthInfo> result;
	if (this.authInfo == null) {
		result = Future.future();
		final EventBus eb = this.getVertx().eventBus();
		final String address = Constants.BUS_AUTHREQUEST + this.getListenerConfig().getAuthName();
		eb.send(address, null, replyHandler -> {
			if (replyHandler.succeeded()) {
				this.authInfo = (AuthInfo) replyHandler.result().body();
				result.complete(this.authInfo);
			} else {
				result.fail(replyHandler.cause());
			}
		});

	} else {
		result = Future.succeededFuture(this.authInfo);
	}
	return result;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
@SuppressWarnings("unchecked")
static Future<Envelop> build(final Object returnValue) {
    if (null == returnValue) {
        // Empty Future
        return Future.succeededFuture(Envelop.ok());
    }
    final Class<?> clazz = returnValue.getClass();
    final Future<Envelop> result;
    if (Future.class.isAssignableFrom(clazz)) {
        // Fix Async Server Issue
        LOGGER.info(Info.MSG_FLOW, "Future", clazz);
        result = (Future<Envelop>) returnValue;
    } else {
        if (Envelop.class == clazz) {
            // Envelop got
            LOGGER.info(Info.MSG_FLOW, "Envelop", clazz);
            result = Future.succeededFuture((Envelop) returnValue);
        } else {
            LOGGER.info(Info.MSG_FLOW, "Other Type", clazz);
            final Envelop envelop = Envelop.success(returnValue);
            result = Future.succeededFuture(envelop);
        }
    }
    return result;
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
Future<EntityManagerFactory> entityManagerFactory() {

      if (emf == null) {

        Future<EntityManagerFactory> f1 = Future.future();
        emfProvider.getEntityManagerFactory(datasourceName).setHandler(res -> {
          if (res.succeeded()) {
            emf = res.result();
            f1.complete(emf);
          } else {
            f1.fail(res.cause());
          }
        });
        return f1;
      }
      return Future.succeededFuture(emf);
    }
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<FdfsStorage> createStorage(FdfsStorageOptions storageOptions) {
	return Future.succeededFuture(new FdfsStorageImpl(vertx, pool, storageOptions));
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
private Future<FdfsTracker> createTracker(FdfsTrackerOptions trackerOptions) {
	return Future.succeededFuture(new FdfsTrackerImpl(vertx, pool, trackerOptions));
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
@Ipc(value = "IPC://EVENT/ADDR")
public Future<Envelop> send(final Envelop envelop) {
    final JsonObject data = envelop.data(JsonObject.class);
    data.put("role", "Terminator");
    return Future.succeededFuture(Envelop.success(data));
}
 

import io.vertx.core.Future; //導入方法依賴的package包/類
public static <T> Future<T> succeededFuture()
{
    return Future.succeededFuture();
}