import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
private void handle(RoutingContext rc) {
    @Nullable JsonObject json = rc.getBodyAsJson();
    if (json == null || json.getDouble("amount") == null) {
        System.out.println("No content or no amount");
        rc.fail(400);
        return;
    }

    double amount = json.getDouble("amount");
    String target = json.getString("currency");
    if (target == null) {
        target = "EUR";
    }
    double rate = getRate(target);
    if (rate == -1) {
        System.out.println("Unknown currency: " + target);
        rc.fail(400);
    }
    
    int i = random.nextInt(10);
    if (i < 5) {

        rc.response().end(new JsonObject()
            .put("amount", convert(amount, rate))
            .put("currency", target).encode()
        );
    } else if (i < 8) {
        // Failure
        rc.fail(500);
    }
    // Timeout, we don't write the response.
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public List<@Nullable String> methodWithListNullableStringReturn() {
  ArrayList<String> ret = new ArrayList<>();
  ret.add("first");
  ret.add(null);
  ret.add("third");
  return ret;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public MongoClient removeDocumentsWithOptions(String collection, JsonObject query, @Nullable WriteOption writeOption, Handler<AsyncResult<MongoClientDeleteResult>> resultHandler) {
  requireNonNull(collection, "collection cannot be null");
  requireNonNull(query, "query cannot be null");
  requireNonNull(resultHandler, "resultHandler cannot be null");

  MongoCollection<JsonObject> coll = getCollection(collection, writeOption);
  Bson bquery = wrap(encodeKeyWhenUseObjectId(query));
  coll.deleteMany(bquery, toMongoClientDeleteResult(resultHandler));
  return this;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
private MongoCollection<JsonObject> getCollection(String name, @Nullable WriteOption writeOption) {
  MongoCollection<JsonObject> coll = holder.db.getCollection(name, JsonObject.class);
  if (coll != null && writeOption != null) {
    coll = coll.withWriteConcern(WriteConcern.valueOf(writeOption.name()));
  }
  return coll;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public @Nullable JsonObject methodWithNullableJsonObjectReturn(boolean notNull) {
  if (notNull) {
    return new JsonObject().put("foo", "wibble").put("bar", 3);
  } else {
    return null;
  }
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
/**
 * @return the response body decoded as a json object
 */
@CacheReturn
@Nullable
default JsonObject bodyAsJsonObject() {
  Buffer b = bodyAsBuffer();
  return b != null ? BodyCodecImpl.JSON_OBJECT_DECODER.apply(b) : null;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public @Nullable String subtag(int level) {
  ensureHeaderProcessed();
  if(level < parsedValues.size()){
    return parsedValues.get(level);
  }
  return null;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public @Nullable List<JsonObject> methodWithNullableListJsonObjectReturn(boolean notNull) {
  if (notNull) {
    return Arrays.asList(new JsonObject().put("foo", "bar"), new JsonObject().put("juu", 3));
  } else {
    return null;
  }
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public @Nullable List<Character> methodWithNullableListCharReturn(boolean notNull) {
  if (notNull) {
    return Arrays.asList('x', 'y', 'z');
  } else {
    return null;
  }
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
private @Nullable String getAlias() {
	return context.request().getParam("alias");
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public HttpServerResponse endHandler(@Nullable Handler<Void> handler) {
    serverResponse.endHandler(handler);
    return null;
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithNullableListGenEnumHandlerAsyncResult(boolean notNull, Handler<AsyncResult<@Nullable List<TestGenEnum>>> handler) {
  handler.handle(Future.succeededFuture(methodWithNullableListGenEnumReturn(notNull)));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithSetNullableLongHandlerAsyncResult(Handler<AsyncResult<Set<@Nullable Long>>> handler) {
  handler.handle(Future.succeededFuture(methodWithSetNullableLongReturn()));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Nullable
private static Bson toBson(@Nullable JsonObject json) {
  return json == null ? null : BsonDocument.parse(json.encode());
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Nullable
private JsonObjectBsonAdapter wrap(@Nullable JsonObject jsonObject) {
  return jsonObject == null ? null : new JsonObjectBsonAdapter(jsonObject);
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithNullableMapIntegerHandlerAsyncResult(boolean notNull, Handler<AsyncResult<@Nullable Map<String, Integer>>> handler) {
  handler.handle(Future.succeededFuture(methodWithNullableMapIntegerReturn(notNull)));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithNullableFloatHandler(boolean notNull, Handler<@Nullable Float> handler) {
  handler.handle(methodWithNullableFloatReturn(notNull));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithMapNullableShortHandlerAsyncResult(Handler<AsyncResult<Map<String, @Nullable Short>>> handler) {
  handler.handle(Future.succeededFuture(methodWithMapNullableShortReturn()));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithNullableMapShortHandler(boolean notNull, Handler<@Nullable Map<String, Short>> handler) {
  handler.handle(methodWithNullableMapShortReturn(notNull));
}
 

import io.vertx.codegen.annotations.Nullable; //导入依赖的package包/类
@Override
public void methodWithNullableDoubleHandlerAsyncResult(boolean notNull, Handler<AsyncResult<@Nullable Double>> handler) {
  handler.handle(Future.succeededFuture(methodWithNullableDoubleReturn(notNull)));
}