return false;
  }

  @Override
  public C first() {
    // requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
    return requireNonNull(range.lowerBound.leastValueAbove(domain));
  }

  @Override
  public C last() {
    // requireNonNull is safe because we checked the range is not empty in ContiguousSet.create.
    return requireNonNull(range.upperBound.greatestValueBelow(domain));

    /*
     * (non-Javadoc)
     *
     * @see
     * org.codelibs.fess.crawler.rule.RuleManager#hasRule(org.codelibs.fess.crawler.rule.Rule)
     */
    /**
     * Checks if the rule manager contains the specified rule.
     * @param rule the rule to check for
     * @return true if the rule is present, false otherwise
     */
    @Override
    public boolean hasRule(final Rule rule) {
        return ruleList.contains(rule);

        // Validate arrays existence and alignment (edge and structure checks)
        assertNotNull(WinError.WINERR_CODES, "WINERR_CODES should not be null");
        assertNotNull(WinError.WINERR_MESSAGES, "WINERR_MESSAGES should not be null");
        assertEquals(WinError.WINERR_CODES.length, WinError.WINERR_MESSAGES.length, "Codes/messages length mismatch");

        // Exact content check to guard against accidental reordering or drift

							return err
						}
						internalLogIf(ctx, err)
					}
				}
				dirStack = dirStack[:len(dirStack)-1]
			}

			// All objects will be returned as directories, there has been no object check yet.
			// Check it by attempting to read metadata.
			_, isDirObj := dirObjects[entry]
			if isDirObj {
				meta.name = meta.name[:len(meta.name)-1] + globalDirSuffixWithSlash
			}

			if s.walkReadMu != nil {

     * @param password The password.
     */
    public void setPassword(final String password) {
        this.password = password;
    }

    /**
     * Checks if this authentication matches the given FTP path.
     * @param path The FTP path to check.
     * @return true if it matches, false otherwise.
     */
    boolean matches(final String path) {
        if (StringUtil.isBlank(path)) {
            return false;

                        break;
                    }
                }
                // check for exact match
                else if (repo.equals(originalId)) {
                    result = true;
                    break;
                }
                // check for external:*
                else if (EXTERNAL_WILDCARD.equals(repo) && isExternalRepo(originalRepository)) {

	ctx := newContext(r, w, "KMSListKeys")
	defer logger.AuditLog(ctx, w, r, mustGetClaimsFromToken(r))

	// This only checks if the action (kms:ListKeys) is allowed, it does not check
	// each key name against the policy's Resources. We check that below, once
	// we have the list of key names from the KMS.
	objectAPI, _ := validateAdminReq(ctx, w, r, policy.KMSListKeysAction)
	if objectAPI == nil {

      }
    }
    return true;
  }

  /**
   * Checks all the properties that should always hold of a map. Also calls {@link
   * #assertMoreInvariants} to check invariants that are peculiar to specific implementations.
   *
   * @see #assertMoreInvariants
   * @param map the map to check.
   */
  protected final void assertInvariants(Map<K, V> map) {
    Set<K> keySet = map.keySet();

  duration: Long,
  unit: TimeUnit,
): Int {
  check(duration >= 0L) { "$name < 0" }
  val millis = unit.toMillis(duration)
  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {
  check(!duration.isNegative()) { "$name < 0" }

 *
 * <h2>Repository Resolution Process</h2>
 *
 * <p>When resolving dependencies, Maven follows this order:</p><ol>
 * <li>Check Local Repository: Maven first checks if the artifact is available in the local repository.</li>
 * <li>Check Remote Repositories: If the artifact is not found locally, Maven queries the configured remote repositories in the order they are listed.</li>