下面列出了怎么用javax.annotation.Nullable的API类实例代码及写法,或者点击链接到github查看源代码。
private static StateTableEntry<Integer, VoidNamespace, Integer> generateElement(
@Nonnull Random random,
@Nullable StateTableEntry<Integer, VoidNamespace, Integer> next) {
Integer generatedKey = random.nextInt() & Integer.MAX_VALUE;
return new StateTableEntry<>(
generatedKey,
VoidNamespace.INSTANCE,
random.nextInt(),
generatedKey.hashCode(),
next,
0,
0);
}
public ArchivedExecutionGraph(
JobID jobID,
String jobName,
Map<JobVertexID, ArchivedExecutionJobVertex> tasks,
List<ArchivedExecutionJobVertex> verticesInCreationOrder,
long[] stateTimestamps,
JobStatus state,
@Nullable ErrorInfo failureCause,
String jsonPlan,
StringifiedAccumulatorResult[] archivedUserAccumulators,
Map<String, SerializedValue<OptionalFailure<Object>>> serializedUserAccumulators,
ArchivedExecutionConfig executionConfig,
boolean isStoppable,
@Nullable CheckpointCoordinatorConfiguration jobCheckpointingConfiguration,
@Nullable CheckpointStatsSnapshot checkpointStatsSnapshot) {
this.jobID = Preconditions.checkNotNull(jobID);
this.jobName = Preconditions.checkNotNull(jobName);
this.tasks = Preconditions.checkNotNull(tasks);
this.verticesInCreationOrder = Preconditions.checkNotNull(verticesInCreationOrder);
this.stateTimestamps = Preconditions.checkNotNull(stateTimestamps);
this.state = Preconditions.checkNotNull(state);
this.failureCause = failureCause;
this.jsonPlan = Preconditions.checkNotNull(jsonPlan);
this.archivedUserAccumulators = Preconditions.checkNotNull(archivedUserAccumulators);
this.serializedUserAccumulators = Preconditions.checkNotNull(serializedUserAccumulators);
this.archivedExecutionConfig = Preconditions.checkNotNull(executionConfig);
this.isStoppable = isStoppable;
this.jobCheckpointingConfiguration = jobCheckpointingConfiguration;
this.checkpointStatsSnapshot = checkpointStatsSnapshot;
}
public Set<Long> getCuboidsRecommend() {
return Sets.newHashSet(FluentIterable.from(cuboidsRecommend).transform(new Function<String, Long>() {
@Nullable
@Override
public Long apply(@Nullable String cuboid) {
return Long.valueOf(cuboid);
}
}));
}
@Nullable
private static Address protobufAddressToSdkAddress(EnvelopeAddress address) {
if (address == null
|| (address.getId().isEmpty()
&& address.getNamespace().isEmpty()
&& address.getType().isEmpty())) {
return null;
}
FunctionType functionType = new FunctionType(address.getNamespace(), address.getType());
return new Address(functionType, address.getId());
}
@Inject(method = SPAWN, at = @At(value = "INVOKE", target = "net/minecraft/world/World.spawnEntity(Lnet/minecraft/entity/Entity;)Z"), cancellable = true, locals = LocalCapture.CAPTURE_FAILHARD)
private void hookMobSpawns(World world, @Nullable CompoundTag itemTag, @Nullable Text name, @Nullable PlayerEntity player, BlockPos pos, SpawnType type, boolean alignPosition, boolean bl, CallbackInfoReturnable<Entity> callback, Entity entity) {
if (!(entity instanceof MobEntity)) {
return;
}
MobEntity mob = (MobEntity) entity;
if (EntityEvents.doSpecialSpawn(mob, world, pos.getX(), pos.getY(), pos.getZ(), null, type)) {
callback.setReturnValue(null);
}
}
@Nullable
@Managed
@Nested
public CacheStatsMBean getProjectionCache()
{
return projectionCacheStats;
}
public ParallelProcessingTraverserWorker(
TraverserConfiguration conf,
IndexingService indexingService,
@Nullable ExecutorService executor) {
super(conf, indexingService);
this.itemRetriever = conf.getItemRetriever();
this.hostload = conf.getHostload();
this.sharedExecutor = executor != null;
this.executor = sharedExecutor ? executor : Executors.newCachedThreadPool();
queue = new ConcurrentLinkedQueue<>();
}
@SuppressWarnings("unchecked")
private void read16Layout(@Nullable String schemaString, ObjectInputStream in)
throws IOException, ClassNotFoundException {
Schema schema = AvroFactory.parseSchemaString(schemaString);
Class<T> type = (Class<T>) in.readObject();
this.previousSchema = new SerializableAvroSchema();
this.schema = new SerializableAvroSchema(schema);
this.type = type;
}
@Nullable
protected synchronized Map<Integer, VertCoordType> readTable3(String path) {
try (InputStream is = GribResourceReader.getInputStream(path)) {
SAXBuilder builder = new SAXBuilder();
org.jdom2.Document doc = builder.build(is);
Element root = doc.getRootElement();
Map<Integer, VertCoordType> result = new HashMap<>(200);
List<Element> params = root.getChildren("parameter");
for (Element elem1 : params) {
int code = Integer.parseInt(elem1.getAttributeValue("code"));
String desc = elem1.getChildText("description");
String abbrev = elem1.getChildText("abbrev");
String units = elem1.getChildText("units");
String datum = elem1.getChildText("datum");
boolean isLayer = elem1.getChild("isLayer") != null;
boolean isPositiveUp = elem1.getChild("isPositiveUp") != null;
VertCoordType lt = new VertCoordType(code, desc, abbrev, units, datum, isPositiveUp, isLayer);
result.put(code, lt);
}
return Collections.unmodifiableMap(result); // all at once - thread safe
} catch (IOException | JDOMException e) {
logger.error("Cant parse NcepLevelTypes = " + path, e);
return null;
}
}
@Override
@Nullable
public StreamElement pollNextNullable() throws Exception {
while (true) {
// get the stream element from the deserializer
if (currentRecordDeserializer != null) {
DeserializationResult result = currentRecordDeserializer.getNextRecord(deserializationDelegate);
if (result.isBufferConsumed()) {
currentRecordDeserializer.getCurrentBuffer().recycleBuffer();
currentRecordDeserializer = null;
}
if (result.isFullRecord()) {
return deserializationDelegate.getInstance();
}
}
Optional<BufferOrEvent> bufferOrEvent = checkpointedInputGate.pollNext();
if (bufferOrEvent.isPresent()) {
processBufferOrEvent(bufferOrEvent.get());
} else {
if (checkpointedInputGate.isFinished()) {
isFinished = true;
checkState(checkpointedInputGate.isAvailable().isDone(), "Finished BarrierHandler should be available");
if (!checkpointedInputGate.isEmpty()) {
throw new IllegalStateException("Trailing data in checkpoint barrier handler.");
}
}
return null;
}
}
}
/**
* Creates a new shared slot that has is a sub-slot of the given parent shared slot, and that belongs
* to the given task group.
*
* @param owner The component from which this slot is allocated.
* @param location The location info of the TaskManager where the slot was allocated from
* @param slotNumber The number of the slot.
* @param taskManagerGateway The gateway to communicate with the TaskManager
* @param assignmentGroup The assignment group that this shared slot belongs to.
* @param parent The parent slot of this slot.
* @param groupId The assignment group of this slot.
*/
public SharedSlot(
SlotOwner owner,
TaskManagerLocation location,
int slotNumber,
TaskManagerGateway taskManagerGateway,
SlotSharingGroupAssignment assignmentGroup,
@Nullable SharedSlot parent,
@Nullable AbstractID groupId) {
super(owner, location, slotNumber, taskManagerGateway, parent, groupId);
this.assignmentGroup = checkNotNull(assignmentGroup);
this.subSlots = new HashSet<Slot>();
}
private void handleError(ChannelHandlerContext ctx, String errorMessage, HttpResponseStatus responseStatus, @Nullable Throwable e) {
HttpRequest tmpRequest = currentHttpRequest;
deleteUploadedFiles();
reset();
LOG.warn(errorMessage, e);
HandlerUtils.sendErrorResponse(
ctx,
tmpRequest,
new ErrorResponseBody(errorMessage),
responseStatus,
Collections.emptyMap()
);
ReferenceCountUtil.release(tmpRequest);
}
@Nullable
public static Range<Double> getMzRangeFromFormula(String formula, IonizationType ionType,
MZTolerance mzTolerance, Integer charge) {
if ((formula == null) || (ionType == null) || (mzTolerance == null) || (charge == null))
return null;
String ionizedFormula = FormulaUtils.ionizeFormula(formula, ionType, charge);
double calculatedMZ = FormulaUtils.calculateExactMass(ionizedFormula, charge) / charge;
return mzTolerance.getToleranceRange(calculatedMZ);
}
/**
* Decrypt a message using a given key and a detached message authentication code.
*
* @param cipherText The cipher text to decrypt.
* @param mac The message authentication code.
* @param data Extra non-confidential data that is included within the encrypted payload.
* @param key The key to use for decryption.
* @param nonce The nonce that was used for encryption.
* @return The decrypted data, or {@code null} if verification failed.
* @throws UnsupportedOperationException If AES256-GSM support is not available.
*/
@Nullable
public static byte[] decryptDetached(byte[] cipherText, byte[] mac, byte[] data, Key key, Nonce nonce) {
assertAvailable();
checkArgument(!key.isDestroyed(), "Key has been destroyed");
long abytes = Sodium.crypto_aead_aes256gcm_abytes();
if (abytes > Integer.MAX_VALUE) {
throw new IllegalStateException("crypto_aead_aes256gcm_abytes: " + abytes + " is too large");
}
if (mac.length != abytes) {
throw new IllegalArgumentException("mac must be " + abytes + " bytes, got " + mac.length);
}
byte[] clearText = new byte[cipherText.length];
int rc = Sodium
.crypto_aead_aes256gcm_decrypt_detached(
clearText,
null,
cipherText,
cipherText.length,
mac,
data,
data.length,
nonce.value.pointer(),
key.value.pointer());
if (rc == -1) {
return null;
}
if (rc != 0) {
throw new SodiumException("crypto_aead_aes256gcm_encrypt: failed with result " + rc);
}
return clearText;
}
/**
* A formatted string representation of the value
*
* @return the formatted representation of the value (or an empty String)
*/
@Override
@Nonnull
public String getFormattedString(@Nullable Object value) {
if (value instanceof Range) {
Range r = (Range) value;
return getFormatter().format(r.lowerEndpoint()) + "-"
+ getFormatter().format(r.upperEndpoint());
} else
return "";
}
@Override
public ProducerRecord<byte[], byte[]> serialize(
final ClickEventStatistics message, @Nullable final Long timestamp) {
try {
//if topic is null, default topic will be used
return new ProducerRecord<>(topic, objectMapper.writeValueAsBytes(message));
} catch (JsonProcessingException e) {
throw new IllegalArgumentException("Could not serialize record: " + message, e);
}
}
public StringStatistics(@Nullable Slice minimum, @Nullable Slice maximum, long sum)
{
if (minimum != null && maximum != null && minimum.compareTo(maximum) > 0) {
throw new IllegalArgumentException(format(
"minimum is not less than or equal to maximum: '%s' [%s], '%s' [%s]",
minimum.toStringUtf8(),
base16().encode(minimum.getBytes()),
maximum.toStringUtf8(),
base16().encode(maximum.getBytes())));
}
this.minimum = minimum;
this.maximum = maximum;
this.sum = sum;
}
TestingDispatcher(
RpcService rpcService,
String endpointId,
Configuration configuration,
HighAvailabilityServices highAvailabilityServices,
GatewayRetriever<ResourceManagerGateway> resourceManagerGatewayRetriever,
BlobServer blobServer,
HeartbeatServices heartbeatServices,
JobManagerMetricGroup jobManagerMetricGroup,
@Nullable String metricQueryServicePath,
ArchivedExecutionGraphStore archivedExecutionGraphStore,
JobManagerRunnerFactory jobManagerRunnerFactory,
FatalErrorHandler fatalErrorHandler) throws Exception {
super(
rpcService,
endpointId,
configuration,
highAvailabilityServices,
highAvailabilityServices.getSubmittedJobGraphStore(),
resourceManagerGatewayRetriever,
blobServer,
heartbeatServices,
jobManagerMetricGroup,
metricQueryServicePath,
archivedExecutionGraphStore,
jobManagerRunnerFactory,
fatalErrorHandler,
VoidHistoryServerArchivist.INSTANCE);
this.startFuture = new CompletableFuture<>();
}
/**
* Finds a channel with the given id and contract hash and returns it, or returns null.
*/
@Nullable
public StoredClientChannel getChannel(Sha256Hash id, Sha256Hash contractHash) {
lock.lock();
try {
Set<StoredClientChannel> setChannels = mapChannels.get(id);
for (StoredClientChannel channel : setChannels) {
if (channel.contract.getHash().equals(contractHash))
return channel;
}
return null;
} finally {
lock.unlock();
}
}
public LongArrayBlockBuilder(@Nullable BlockBuilderStatus blockBuilderStatus, int expectedEntries)
{
this.blockBuilderStatus = blockBuilderStatus;
this.initialEntryCount = max(expectedEntries, 1);
updateDataSize();
}
@Override
@Nullable
protected Asn1Tag getTag() {
return TAG_EllipsoidArc;
}
@Nullable
@Override
public String get(Map<String, String> carrier, String key) {
return carrier.get(key);
}
private Optional<JiraCloudSiteConfig> getSiteConfigFor(@Nullable final String jiraSite) {
return siteConfigRetriever.getJiraSiteConfig(jiraSite);
}
@Nullable
public Triple getPrecisePosition() {
return precisePosition;
}
Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) {
this.tag = tag;
this.isImplicitTagging = isImplicitTagging;
}
@Nullable
default CompoundTag serializeCaps() {
return getCapabilityProvider().serializeCaps();
}
/**
* Process a hot-cold update given a {@link WorldPoint} where a check occurred and the resulting temperature and
* temperature change discovered at that point. This will filter the set of possible locations which can be the
* solution.
*
* @param worldPoint The point where a hot-cold check occurred
* @param temperature The temperature of the checked point
* @param temperatureChange The change of temperature of the checked point compared to the previously-checked point
* @return A set of {@link HotColdLocation}s which are still possible after the filtering occurs. This return value
* is the same as would be returned by {@code getPossibleLocations()}.
*/
public Set<HotColdLocation> signal(@Nonnull final WorldPoint worldPoint, @Nonnull final HotColdTemperature temperature, @Nullable final HotColdTemperatureChange temperatureChange)
{
// when the strange device reads a temperature, that means that the center of the final dig location
// is a range of squares away from the player's current location (Chebyshev AKA Chess-board distance)
int maxSquaresAway = temperature.getMaxDistance();
int minSquaresAway = temperature.getMinDistance();
// maxDistanceArea encompasses all of the points that are within the max possible distance from the player
final Rectangle maxDistanceArea = new Rectangle(
worldPoint.getX() - maxSquaresAway,
worldPoint.getY() - maxSquaresAway,
2 * maxSquaresAway + 1,
2 * maxSquaresAway + 1);
// minDistanceArea encompasses all of the points that are within the min possible distance from the player
final Rectangle minDistanceArea = new Rectangle(
worldPoint.getX() - minSquaresAway,
worldPoint.getY() - minSquaresAway,
2 * minSquaresAway + 1,
2 * minSquaresAway + 1);
// eliminate from consideration dig spots that lie entirely within the min range or entirely outside of the max range
possibleLocations.removeIf(entry -> minDistanceArea.contains(entry.getRect()) || !maxDistanceArea.intersects(entry.getRect()));
// if a previous world point has been recorded, we can consider the warmer/colder result from the strange device
if (lastWorldPoint != null && temperatureChange != null)
{
switch (temperatureChange)
{
case COLDER:
// eliminate spots that are absolutely warmer
possibleLocations.removeIf(entry -> isFirstPointCloserRect(worldPoint, lastWorldPoint, entry.getRect()));
break;
case WARMER:
// eliminate spots that are absolutely colder
possibleLocations.removeIf(entry -> isFirstPointCloserRect(lastWorldPoint, worldPoint, entry.getRect()));
break;
case SAME:
// eliminate spots which are absolutely colder or warmer (as they would not yield a SAME temperature change)
possibleLocations.removeIf(entry ->
isFirstPointCloserRect(worldPoint, lastWorldPoint, entry.getRect())
|| isFirstPointCloserRect(lastWorldPoint, worldPoint, entry.getRect()));
}
}
lastWorldPoint = worldPoint;
return getPossibleLocations();
}
@Nullable
public String getTestPasswordOverride()
{
return testPasswordOverride;
}
@Override
@Nullable
protected Asn1Tag getTag() {
return TAG_ephemIDotType;
}
Key(Class<?> type, @Nullable String label) {
this.type = type;
this.label = label;
}