Java Code Examples for java.util.Optional#equals()

@Override
public Optional<ConstraintApplicationResult<ConnectorTableHandle>> applyFilter(ConnectorSession session, ConnectorTableHandle handle, Constraint constraint)
{
    InformationSchemaTableHandle table = (InformationSchemaTableHandle) handle;

    Optional<Set<String>> roles = table.getRoles();
    Optional<Set<String>> grantees = table.getGrantees();
    if (ROLE_AUTHORIZATION_DESCRIPTORS.equals(table.getTable()) && table.getRoles().isEmpty() && table.getGrantees().isEmpty()) {
        roles = calculateRoles(session, constraint.getSummary(), constraint.predicate());
        grantees = calculateGrantees(session, constraint.getSummary(), constraint.predicate());
    }

    Set<QualifiedTablePrefix> prefixes = table.getPrefixes();
    if (isTablesEnumeratingTable(table.getTable()) && table.getPrefixes().equals(defaultPrefixes(catalogName))) {
        prefixes = getPrefixes(session, table, constraint);
    }

    if (roles.equals(table.getRoles()) && grantees.equals(table.getGrantees()) && prefixes.equals(table.getPrefixes())) {
        return Optional.empty();
    }

    table = new InformationSchemaTableHandle(table.getCatalogName(), table.getTable(), prefixes, roles, grantees, table.getLimit());
    return Optional.of(new ConstraintApplicationResult<>(table, constraint.getSummary()));
}
 

@VisibleForTesting
static Optional<String> getCommonProjectPrefix(ImmutableSet<String> buildTargets) {
  Optional<String> commonPrefix = Optional.empty();

  for (String buildTarget : buildTargets) {
    Optional<String> prefix = getTargetPrefix(buildTarget);
    if (!prefix.isPresent()) {
      // This target did not have a prefix, so there is no common prefix
      return Optional.empty();
    }
    if (!commonPrefix.isPresent()) {
      // This is the first target, all others should match
      commonPrefix = prefix;
    } else if (!commonPrefix.equals(prefix)) {
      // Mismatch was found
      return Optional.empty();
    }
  }

  // There was a common prefix (or buildTargets Set was empty).
  return commonPrefix;
}
 

private void integrityCheck(List<T> foundItems, Optional<Serializable> id, Field field, Object prop) {
    if (!foundItems.isEmpty()) {


        if (foundItems.size() > 1) {
            throw new ElepyException(String.format("There are duplicates with the %s: '%s' in the given array!", ReflectionUtils.getPrettyName(field), String.valueOf(prop)));
        }

        T foundRecord = foundItems.get(0);
        final Optional<Serializable> foundId = ReflectionUtils.getId(foundRecord);
        if (id.isPresent() || foundId.isPresent()) {
            if (!id.equals(foundId)) {
                throw new ElepyException(String.format("An item with the %s: '%s' already exists in the system!", ReflectionUtils.getPrettyName(field), String.valueOf(prop)));
            }
        } else {
            throw new ElepyException(String.format("There are duplicates with the %s: '%s' in the given array!", ReflectionUtils.getPrettyName(field), String.valueOf(prop)));

        }
    }
}
 

@Override
public void readFrom(final UnaryOperator<String> reader) {
    final Span span = activeSpan();

    final Optional<FlowId> now = extractor.extract(span, reader);
    final Optional<FlowId> later = extractor.extract(span);

    final Optional<String> nowId = now.map(FlowId::getValue);
    final Optional<String> laterId = later.map(FlowId::getValue);

    if (nowId.equals(laterId)) {
        later.ifPresent(flowId -> {
            listener.onRead(span, flowId);
        });
    } else {
        now.ifPresent(flowId -> {
            bag(span, flowId);
            listener.onRead(span, flowId);
        });
    }
}
 

public static void deleteScript(final String fileName, final AttributeCalculatorPane acp) {
    File f = new File(fileName);
    if (f.getPath().contains("_inbuilt_script")) {
        final NotifyDescriptor nd = new NotifyDescriptor.Message("Can't delete inbuilt script.", NotifyDescriptor.ERROR_MESSAGE);
        DialogDisplayer.getDefault().notify(nd);
    } else {
        final String msg = String.format("Are you sure you want to delete '%s'?",
                FilenameEncoder.decode(f.getName().substring(0, f.getName().length() - 5)));
        final Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
        alert.setHeaderText("Delete?");
        alert.setContentText(msg);
        final Optional<ButtonType> action = alert.showAndWait();
        final boolean del = action.equals(ButtonType.YES);
        if (del) {
            final boolean fIsDeleted = f.delete();
            if (!fIsDeleted) {
                //TODO: Handle case where file not successfully deleted
            }
        }
    }
}
 

private TypeCompatibility typeCompatibilityForRow(RowType firstType, RowType secondType)
{
    List<Field> firstFields = firstType.getFields();
    List<Field> secondFields = secondType.getFields();
    if (firstFields.size() != secondFields.size()) {
        return TypeCompatibility.incompatible();
    }

    ImmutableList.Builder<Field> fields = ImmutableList.builder();
    boolean coercible = true;
    for (int i = 0; i < firstFields.size(); i++) {
        Type firstFieldType = firstFields.get(i).getType();
        Type secondFieldType = secondFields.get(i).getType();
        TypeCompatibility typeCompatibility = compatibility(firstFieldType, secondFieldType);
        if (!typeCompatibility.isCompatible()) {
            return TypeCompatibility.incompatible();
        }
        Type commonParameterType = typeCompatibility.getCommonSuperType();

        Optional<String> firstParameterName = firstFields.get(i).getName();
        Optional<String> secondParameterName = secondFields.get(i).getName();
        Optional<String> commonName = firstParameterName.equals(secondParameterName) ? firstParameterName : Optional.empty();

        // ignore parameter name for coercible
        coercible &= typeCompatibility.isCoercible();
        fields.add(new Field(commonName, commonParameterType));
    }

    return TypeCompatibility.compatible(RowType.from(fields.build()), coercible);
}
 

@Override
public Optional<? extends Module> findModule(final String name, final Optional<Revision> revision) {
    for (final Module module : getNameToModules().get(name)) {
        if (revision.equals(module.getRevision())) {
            return Optional.of(module);
        }
    }

    return Optional.empty();
}
 

private static void assertEqualIpAddresses(HostName hostName, Optional<? extends InetAddress> resolvedAddress,
                                           Set<String> nrAddresses, IPVersion ipVersion) {
    Optional<InetAddress> nrAddress = nrAddresses.stream()
            .map(InetAddresses::forString)
            .filter(ipVersion::match)
            .findFirst();
    if (resolvedAddress.equals(nrAddress)) return;

    throw new ConvergenceException(String.format(
            "IP address (%s) resolved from %s  does not match IP address (%s) in node-repo",
            resolvedAddress.map(InetAddresses::toAddrString).orElse("[none]"), hostName,
            nrAddress.map(InetAddresses::toAddrString).orElse("[none]")));
}
 

private static void testVersion() {
    Version current = Runtime.version();
    String javaVer = System.getProperty("java.runtime.version");

    // java.runtime.version == $VNUM(\-$PRE)?(\+$BUILD)?(-$OPT)?
    String [] jv  = javaVer.split("\\+");
    String [] ver = jv[0].split("-");
    List<Integer> javaVerVNum
        = Arrays.stream(ver[0].split("\\."))
        .map(Integer::parseInt)
        .collect(Collectors.toList());
    if (!javaVerVNum.equals(current.version())) {
        fail("Runtime.version()", javaVerVNum.toString(),
             current.version().toString());
    } else {
        pass();
    }

    Optional<String> javaVerPre
        = (ver.length == 2)
        ? Optional.ofNullable(ver[1])
        : Optional.empty();
    if (!javaVerPre.equals(current.pre())) {
        fail("testCurrent() pre()", javaVerPre.toString(),
             current.pre().toString());
    } else {
        pass();
    }

    testEHC(current.toString(), javaVer, true, true, 0, 0);
}
 

private void updateRegion(CharID id)
{
	RegionCacheInfo rci = getInfo(id);
	Optional<Region> current = rci.cachedRegion;
	Optional<Region> newRegion = getRegion(id);
	if (current.isEmpty() || !current.equals(newRegion))
	{
		current.ifPresent(region -> fireDataFacetChangeEvent(id, region.toString(), DataFacetChangeEvent.DATA_REMOVED));
		rci.cachedRegion = newRegion;
		fireDataFacetChangeEvent(id, newRegion.get().toString(), DataFacetChangeEvent.DATA_ADDED);
	}
}
 

Optional<MapDifference<String, String>> invalidateIfEnvHasChanged(Cell cell, AbsPath buildFile) {
  // Invalidate if env vars have changed.
  ImmutableMap<String, Optional<String>> usedEnv;
  try (AutoCloseableLock readLock = cachesLock.readLock()) {
    usedEnv = buildFileEnv.get(buildFile);
  }
  if (usedEnv == null) {
    this.cell.set(cell);
    return Optional.empty();
  }
  for (Map.Entry<String, Optional<String>> ent : usedEnv.entrySet()) {
    Optional<String> value =
        Optional.ofNullable(cell.getBuckConfig().getEnvironment().get(ent.getKey()));
    if (!value.equals(ent.getValue())) {
      LOG.verbose("invalidating for env change: %s (%s != %s)", buildFile, value, ent.getValue());
      invalidatePath(buildFile);
      this.cell.set(cell);
      return Optional.of(
          Maps.difference(
              value.map(v -> ImmutableMap.of(ent.getKey(), v)).orElse(ImmutableMap.of()),
              ent.getValue()
                  .map(v -> ImmutableMap.of(ent.getKey(), v))
                  .orElse(ImmutableMap.of())));
    }
  }
  return Optional.empty();
}
 

@Override
public void close() {
    Instant lastOldestResultReceivedAt = Instant.now();
    Optional<String> oldestIncompleteId = operationProcessor.oldestIncompleteResultId();

    while (oldestIncompleteId.isPresent() && waitForOperations(lastOldestResultReceivedAt, sleepTimeMs, closeTimeoutMs)) {
        Optional<String> oldestIncompleteIdNow = operationProcessor.oldestIncompleteResultId();
        if ( ! oldestIncompleteId.equals(oldestIncompleteIdNow))
            lastOldestResultReceivedAt = Instant.now();
        oldestIncompleteId = oldestIncompleteIdNow;
    }
    operationProcessor.close();
}
 

/**
 * In cases when performing restore and a component has been deleted, it is possible
 * for existing assets to become orphaned during the restore process. In the context
 * of the restore process, this method determines if an asset is associated with the
 * component found (using coordinates from the restored data) using the component's entity id.
 */
private boolean assetIsAssociatedWithComponent(final T data,
                                               final Repository repository,
                                               final String name) throws IOException
{
  Optional<EntityId> componentEntityId = componentEntityId(data);
  return componentEntityId.isPresent() && componentEntityId.equals(assetComponentEntityId(repository, name));
}
 

private void setColumnStatistics(HiveIdentity identity, String objectName, List<ColumnStatisticsObj> statistics, Call1<List<ColumnStatisticsObj>> saveColumnStatistics)
        throws TException
{
    boolean containsDateStatistics = statistics.stream().anyMatch(stats -> stats.getStatsData().isSetDateStats());

    Optional<Boolean> metastoreSupportsDateStatistics = this.metastoreSupportsDateStatistics.get();
    if (containsDateStatistics && metastoreSupportsDateStatistics.equals(Optional.of(FALSE))) {
        log.debug("Skipping date statistics for %s because metastore does not support them", objectName);
        statistics = statistics.stream()
                .filter(stats -> !stats.getStatsData().isSetDateStats())
                .collect(toImmutableList());
        containsDateStatistics = false;
    }

    if (!containsDateStatistics || metastoreSupportsDateStatistics.equals(Optional.of(TRUE))) {
        try (ThriftMetastoreClient client = createMetastoreClient(identity)) {
            saveColumnStatistics.call(client, statistics);
        }
        return;
    }

    List<ColumnStatisticsObj> statisticsExceptDate = statistics.stream()
            .filter(stats -> !stats.getStatsData().isSetDateStats())
            .collect(toImmutableList());

    List<ColumnStatisticsObj> dateStatistics = statistics.stream()
            .filter(stats -> stats.getStatsData().isSetDateStats())
            .collect(toImmutableList());

    verify(!dateStatistics.isEmpty() && metastoreSupportsDateStatistics.equals(Optional.empty()));

    try (ThriftMetastoreClient client = createMetastoreClient(identity)) {
        saveColumnStatistics.call(client, statisticsExceptDate);

        try {
            saveColumnStatistics.call(client, dateStatistics);
        }
        catch (TException e) {
            // When `dateStatistics.size() > 1` we expect something like "TApplicationException: Required field 'colName' is unset! Struct:ColumnStatisticsObj(colName:null, colType:null, statsData:null)"
            // When `dateStatistics.size() == 1` we expect something like "TTransportException: java.net.SocketTimeoutException: Read timed out"
            log.warn(e, "Failed to save date statistics for %s. Metastore might not support date statistics", objectName);
            if (!statisticsExceptDate.isEmpty() && metastoreSetDateStatisticsFailures.incrementAndGet() >= MAX_SET_DATE_STATISTICS_ATTEMPTS) {
                this.metastoreSupportsDateStatistics.set(Optional.of(FALSE));
            }
            return;
        }
    }
    this.metastoreSupportsDateStatistics.set(Optional.of(TRUE));
}
 

private Optional<RowColumn> deleteBatch(TransactionBase tx, Optional<String> nodeId, Span span, Column column, int batchSize) {

        log.trace("Deleting batch of size: " + batchSize + " using Span: " + span + " and Column: " + column);
        RowScanner rs = tx.scanner().over(span).fetch(column).byRow().build();
        try {
            Iterator<ColumnScanner> colScannerIter = rs.iterator();

            int count = 0;
            boolean batchLimitMet = false;
            Bytes row = span.getStart().getRow();

            //get prefix if nodeId is specified
            Optional<Bytes> prefixBytes = Optional.empty();
            if (nodeId.isPresent()) {
                NodeType type = NodeType.fromNodeId(nodeId.get()).get();
                prefixBytes = Optional.ofNullable(Bytes.of(type.getNodeTypePrefix()));
            }

            while (colScannerIter.hasNext() && !batchLimitMet) {
                ColumnScanner colScanner = colScannerIter.next();
                row = colScanner.getRow();

                //extract the nodeId from the returned row if a nodeId was passed
                //into the SpanBatchInformation.  This is to ensure that the returned
                //row nodeId is equal to the nodeId passed in to the span batch information
                Optional<String> rowNodeId = Optional.empty();
                if (prefixBytes.isPresent()) {
                    rowNodeId = Optional.of(BindingSetRow.makeFromShardedRow(prefixBytes.get(), row).getNodeId());
                }

                //if nodeId is present, then results returned by span are filtered
                //on the nodeId.  This occurs when the hash is not included in the span
                if (!rowNodeId.isPresent() || rowNodeId.equals(nodeId)) {
                    Iterator<ColumnValue> iter = colScanner.iterator();
                    while (iter.hasNext()) {
                        if (count >= batchSize) {
                            batchLimitMet = true;
                            break;
                        }
                        ColumnValue colVal = iter.next();
                        tx.delete(row, colVal.getColumn());
                        count++;
                    }
                }
            }

            if (batchLimitMet) {
                return Optional.of(new RowColumn(row));
            } else {
                return Optional.empty();
            }
        } catch (Exception e) {
            return Optional.empty();
        }
    }
 

private JoinResult queryJoin(MatchPlayer joining, JoinRequest request, boolean queued) {
    final Optional<Team> lastTeam = lastTeam(joining.getPlayerId());
    final Optional<Team> chosenTeam = getInstanceOf(request.competitor(), Team.class);

    if(request.method() == JoinMethod.REMOTE) {
        // If remote joining, force the player onto a team
        return JoinAllowed.force(queryAutoJoin(joining, true));

    } else if(!request.competitor().isPresent()) {
        // If autojoining, and the player is already on a team, the request is satisfied
        if(Optionals.isInstance(joining.partyMaybe(), Competitor.class)) {
            return JoinDenied.error("command.gameplay.join.alreadyOnTeam", joining.getParty().getComponentName());
        }

        // If team choosing is disabled, and the match has not started yet, defer the join.
        // Note that this can only happen with autojoin. Choosing a team always fails if
        // the condition below is true.
        if(!queued && !config.allowChoose() && !getMatch().hasStarted()) {
            return new JoinQueued();
        }

        if(lastTeam.isPresent()) {
            // If the player was previously on a team, try to join that team first
            final JoinResult rejoin = lastTeam.get().queryJoin(joining, true, true);
            if(rejoin.isAllowed() || !canSwitchTeams(joining)) return rejoin;
            // If the join fails, and the player is allowed to switch teams, fall through to the auto-join
        }

        // Try to find a team for the player to join
        final JoinResult auto = queryAutoJoin(joining, true);
        if(auto.isAllowed()) return auto;

        if(jmm.canJoinFull(joining) || !joinConfiguration.overfill()) {
            return JoinDenied.unavailable("autoJoin.teamsFull");
        } else {
            // If the player is not premium, and overfill is enabled, plug the shop
            return JoinDenied.unavailable("autoJoin.teamsFull")
                .also(Links.shopPlug("shop.plug.joinFull"));
        }

    } else if(chosenTeam.isPresent()) {
        // If the player is already on the chosen team, there is nothing to do
        if(joining.hasParty() && contains(chosenTeam, joining.getParty())) {
            return JoinDenied.error("command.gameplay.join.alreadyOnTeam", joining.getParty().getComponentName());
        }

        // If team switching is disabled and the player is choosing to re-join their
        // last team, don't consider it a "choice" since that's the only team they can
        // join anyway. In any other case, check that they are allowed to choose their team.
        if(config.allowSwitch() || !chosenTeam.equals(lastTeam)) {
            // Team choosing is disabled
            if(!config.allowChoose()) {
                return JoinDenied.error("command.gameplay.join.choiceDisabled");
            }

            // Player is not allowed to choose their team
            if(!canChooseTeam(joining)) {
                return JoinDenied.unavailable("command.gameplay.join.choiceDenied")
                    .also(Links.shopPlug("shop.plug.chooseTeam"));
            }
        }

        // If team switching is disabled, check if the player is rejoining their former team
        if(!canSwitchTeams(joining) && lastTeam.isPresent()) {
            if(chosenTeam.equals(lastTeam)) {
                return chosenTeam.get().queryJoin(joining, true, true);
            } else {
                return JoinDenied.error("command.gameplay.join.switchDisabled", lastTeam.get().getComponentName());
            }
        }

        return chosenTeam.get().queryJoin(joining, true, false);
    }

    return null;
}
 

private boolean isAntiCsrfTokenValid(final HttpServletRequest request, final Optional<String> token) {
  Optional<String> cookie = getAntiCsrfTokenCookie(request);

  return token.isPresent() && token.equals(cookie);
}
 

/**
 * Returns the premium price for the specified label and registry, or absent if the label is not
 * premium.
 */
public static Optional<Money> getPremiumPrice(String label, Registry registry) {
  // If the registry has no configured premium list, then no labels are premium.
  if (registry.getPremiumList() == null) {
    return Optional.empty();
  }
  DateTime startTime = DateTime.now(UTC);
  String listName = registry.getPremiumList().getName();
  Optional<PremiumList> optionalPremiumList = PremiumList.getCached(listName);
  checkState(optionalPremiumList.isPresent(), "Could not load premium list '%s'", listName);
  PremiumList premiumList = optionalPremiumList.get();
  PremiumListRevision revision;
  try {
    revision = cachePremiumListRevisions.get(premiumList.getRevisionKey());
  } catch (InvalidCacheLoadException | ExecutionException e) {
    throw new RuntimeException(
        "Could not load premium list revision " + premiumList.getRevisionKey(), e);
  }
  checkState(
      revision.getProbablePremiumLabels() != null,
      "Probable premium labels Bloom filter is null on revision '%s'",
      premiumList.getRevisionKey());

  CheckResults checkResults = checkStatus(revision, label);
  DomainLabelMetrics.recordPremiumListCheckOutcome(
      registry.getTldStr(),
      listName,
      checkResults.checkOutcome(),
      DateTime.now(UTC).getMillis() - startTime.getMillis());

  // Also load the value from Cloud SQL, compare the two results, and log if different.
  try {
    Optional<Money> priceFromSql = PremiumListDao.getPremiumPrice(label, registry);
    if (!priceFromSql.equals(checkResults.premiumPrice())) {
      logger.atWarning().log(
          "Unequal prices for domain %s.%s from Datastore (%s) and Cloud SQL (%s).",
          label, registry.getTldStr(), checkResults.premiumPrice(), priceFromSql);
    }
  } catch (Throwable t) {
    logger.atSevere().withCause(t).log(
        "Error loading price of domain %s.%s from Cloud SQL.", label, registry.getTldStr());
  }
  return checkResults.premiumPrice();
}
 

@Override
public boolean concerns(Environment environment, Optional<RegionName> region) {
    if (environment != this.environment) return false;
    if (region.isPresent() && ! region.equals(this.region)) return false;
    return true;
}
 

/**
 * Checks whether two values for a single dimension are compatible.
 *
 * <p>This happens if they have the same value or any of them is absent.
 */
private static boolean areCompatible(Optional<String> value1, Optional<String> value2) {
  return value1.equals(value2) || !value1.isPresent() || !value2.isPresent();
}