Java Code Examples for javax.annotation.Nullable

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;
}