Java OptionalInt.isPresent方法代码示例

import java.util.OptionalInt; //导入方法依赖的package包/类
@Override
protected void execute(HVSession session, CommandArgSet args) throws CommandException {
    EnumFacing facing;
    if (args.hasValue(DIRECTION)) {
        facing = args.value(DIRECTION);
    } else if (session.owner.getCommandSenderEntity() != null) {
        Entity e = session.owner.getCommandSenderEntity();
        facing = VecBridge.facingFromLook(e);
    } else {
        throw new CommandException("A direction must be provided, since the command was not excuted by an entity.");
    }
    OptionalInt amt = args.value(AMOUNT);
    if (amt.isPresent()) {
        session.performFullRegionCommand(sel -> sel.expandRegion(facing, amt.getAsInt()));
    } else {
        session.performFullRegionCommand(RegionSelector::expandRegionVertically);
    }
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
private void messageReceived(ChannelHandlerContext context, ByteBuf response)
{
    try {
        OptionalInt sequenceId = messageEncoding.extractResponseSequenceId(response);
        if (!sequenceId.isPresent()) {
            throw new TTransportException("Could not find sequenceId in Thrift message");
        }

        RequestHandler requestHandler = pendingRequests.remove(sequenceId.getAsInt());
        if (requestHandler == null) {
            throw new TTransportException("Unknown sequence id in response: " + sequenceId.getAsInt());
        }

        requestHandler.onResponseReceived(response);
    }
    catch (Throwable t) {
        onError(context, t);
    }
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
private static OptionalInt findAffinityArg(Method meth) {
    OptionalInt affinityArg = OptionalInt.empty();

    if (meth.getParameterCount() > 0) {
        for (int i = 0; i < meth.getParameterCount() && !affinityArg.isPresent(); i++) {
            Annotation[] annotations = meth.getParameterAnnotations()[i];

            for (int j = 0; j < annotations.length; j++) {
                if (RpcAffinityKey.class.isAssignableFrom(annotations[j].annotationType())) {
                    affinityArg = OptionalInt.of(i);

                    break;
                }
            }
        }
    }

    return affinityArg;
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
public List<CeremonyOfChaosMember> getWinners()
{
	final List<CeremonyOfChaosMember> winners = new ArrayList<>();
	//@formatter:off
	final OptionalInt winnerLifeTime = getMembers().values().stream()
		.mapToInt(CeremonyOfChaosMember::getLifeTime)
		.max();
	
	if(winnerLifeTime.isPresent())
	{
		getMembers().values().stream()
			.sorted(Comparator.comparingLong(CeremonyOfChaosMember::getLifeTime)
				.reversed()
				.thenComparingInt(CeremonyOfChaosMember::getScore)
				.reversed())
			.filter(member -> member.getLifeTime() == winnerLifeTime.getAsInt())
			.collect(Collectors.toCollection(() -> winners));
	}
	
	//@formatter:on
	return winners;
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
@Override
protected void execute() {
    IntentExtensionService service = get(IntentExtensionService.class);
    OptionalInt length = service.getCompilers().keySet().stream()
            .mapToInt(s -> s.getName().length())
            .max();
    if (length.isPresent()) {
        service.getCompilers().entrySet().forEach(e -> {
            print("%-" + length.getAsInt() + "s\t%s",
                  e.getKey().getName(),
                  e.getValue().getClass().getName());
        });
    } else {
        print("There are no compilers registered.");
    }

}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
StreamingMkvReader(boolean requirePath,
        Collection<EBMLTypeInfo> typeInfosToRead,
        ParserByteSource byteSource,
        OptionalInt maxContentBytesAtOnce) {
    this.requirePath = requirePath;
    typeInfosToRead.stream().forEach(t -> Validate.isTrue(t.getType() != EBMLTypeInfo.TYPE.MASTER));
    this.typeInfosToRead = new HashSet(typeInfosToRead);

    this.byteSource = byteSource;
    this.mkvStreamReaderCallback = new MkvStreamReaderCallback(this.requirePath, elementFilter());
    this.previousDataElement = Optional.empty();
    MkvTypeInfoProvider typeInfoProvider = new MkvTypeInfoProvider();
    try {
        typeInfoProvider.load();
    } catch (IllegalAccessException e) {
        //TODO: fix this
        throw new RuntimeException("Could not load mkv info", e);
    }
    if (maxContentBytesAtOnce.isPresent()) {
        this.parser = new EBMLParser(typeInfoProvider, mkvStreamReaderCallback, maxContentBytesAtOnce.getAsInt());
    } else {
        this.parser = new EBMLParser(typeInfoProvider, mkvStreamReaderCallback);
    }
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
@Encoding.Of
static int initFrom(OptionalInt optional) {
  if (optional.isPresent()) {
    return safeValue(optional.getAsInt());
  }
  return SENTINEL_VALUE;
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
@Encoding.Init
@Encoding.Copy
void setFrom(OptionalInt optional) {
  if (optional.isPresent()) {
    setFromInt(optional.getAsInt());
  } else {
    value = SENTINEL_VALUE;
  }
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
@Override
public void run(L2GameClient client)
{
	final L2PcInstance activeChar = client.getActiveChar();
	if ((activeChar == null) || (activeChar.getClan() == null))
	{
		return;
	}
	
	final OptionalInt clanId = ClanEntryManager.getInstance().getClanIdForPlayerApplication(activeChar.getObjectId());
	if (clanId.isPresent())
	{
		activeChar.sendPacket(new ExPledgeWaitingListApplied(clanId.getAsInt(), activeChar.getObjectId()));
	}
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
private void checkMessageSize(OptionalInt size) {
  if (!ehloResponse.getMaxMessageSize().isPresent() || !size.isPresent()) {
    return;
  }

  long maximumSize = ehloResponse.getMaxMessageSize().get();
  if (maximumSize < size.getAsInt()) {
    throw new MessageTooLargeException(config.getConnectionId(), maximumSize);
  }
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
static Optional<Result> parse(final String line) {
	final String[] parts = line.split(quote("|"));

	if (parts.length == 6) {
		final String name = parts[0].trim();
		final OptionalInt ntup = toOptionalInt(parts[1].trim());
		final OptionalInt tsamples = toOptionalInt(parts[2].trim());
		final OptionalInt psamples = toOptionalInt(parts[3].trim());
		final OptionalDouble pvalue = toOptionalDouble(parts[4].trim());
		final Optional<Assessment> assessment = Assessment.of(parts[5].trim());

		if (ntup.isPresent() &&
			tsamples.isPresent() &&
			psamples.isPresent() &&
			pvalue.isPresent() &&
			assessment.isPresent())
		{
			return Optional.of(new Result(
				name,
				ntup.getAsInt(),
				tsamples.getAsInt(),
				psamples.getAsInt(),
				pvalue.getAsDouble(),
				assessment.get()
			));
		}
	}

	return Optional.empty();
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
@Override
public String mention(boolean includeArticle, boolean plural, OptionalInt amount) {
	return (amount.isPresent() ? amount.orElse(0) : includeArticle ? "a " : "") + "stack" + (plural || (amount.orElse(1) != 1) ? "s" : "") + " of " + item.mention(this, false, amount.orElse(1) != 1, OptionalInt.of(this.amount));
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
private static OptionalInt findSplitArg(Method meth) {
    OptionalInt splitIdx = OptionalInt.empty();

    Annotation[][] parameters = meth.getParameterAnnotations();

    for (int i = 0; i < parameters.length; i++) {
        Annotation[] annotations = parameters[i];

        for (int j = 0; j < annotations.length; j++) {
            if (annotations[j].annotationType().equals(RpcSplit.class)) {
                if (splitIdx.isPresent()) {
                    throw new IllegalArgumentException("Only one argument can be annotated with @" + RpcSplit.class.getSimpleName()
                        + " [method=" + meth + ']');
                }

                splitIdx = OptionalInt.of(i);
            }
        }
    }

    if (splitIdx.isPresent()) {
        Class<?> splitType = meth.getParameterTypes()[splitIdx.getAsInt()];

        // Verify parameter type.
        if (!Collection.class.equals(splitType)
            && !Set.class.equals(splitType)
            && !List.class.equals(splitType)
            && !Map.class.equals(splitType)) {
            // Allowed types info for the error message.
            String col = Collection.class.getSimpleName();
            String lst = List.class.getSimpleName();
            String set = Set.class.getSimpleName();
            String map = Map.class.getSimpleName();

            throw new IllegalArgumentException("Parameter annotated with @" + RpcSplit.class.getSimpleName() + " has unsupported "
                + "type [supported-types={" + col + ", " + lst + ", " + set + ", " + map + "}, method=" + meth + ']');
        }
    }

    return splitIdx;
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @see jp.co.future.uroborosql.parameter.mapper.BindParameterMapper#toJdbc(java.lang.Object, java.sql.Connection, jp.co.future.uroborosql.parameter.mapper.BindParameterMapperManager)
 */
@Override
public Object toJdbc(final OptionalInt original, final Connection connection,
		final BindParameterMapperManager parameterMapperManager) {
	return original.isPresent() ? original.getAsInt() : null;
}
 

import java.util.OptionalInt; //导入方法依赖的package包/类
/**
 * If a value is present in {@code optional}, returns a stream containing only that element,
 * otherwise returns an empty stream.
 *
 * <p><b>Java 9 users:</b> use {@code optional.stream()} instead.
 */
public static IntStream stream(OptionalInt optional) {
  return optional.isPresent() ? IntStream.of(optional.getAsInt()) : IntStream.empty();
}