Comparator<? super E> result = comparator;
    if (result == null) {
      return comparator = Ordering.from(forwardMultiset().comparator()).<E>reverse();
    }
    return result;
  }

  @LazyInit @CheckForNull private transient NavigableSet<E> elementSet;

  @Override
  public NavigableSet<E> elementSet() {
    NavigableSet<E> result = elementSet;
    if (result == null) {

     * We can't simply cast the result of `RegularImmutableMap.get` to V because of a bug in our
     * nullness checker (resulting from https://github.com/jspecify/checker-framework/issues/8).
     */
    if (result == null) {
      return null;
    } else {
      return (V) result;
    }
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {

   * that conversion is safe.
   *
   * <p>This method is intended to help with usages of type parameters that have {@linkplain
   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null
   * types (or if the type is a non-variable type, like {@code String}), then code should almost
   * never use this method, preferring instead to call {@code requireNonNull} so as to benefit from
   * its runtime check.
   *

            assertEquals("guest", permissionHelper.encode("guest"));
        } finally {
            ComponentUtil.setFessConfig(null);
        }
    }

    public void test_decode() {
        assertNull(permissionHelper.decode(null));
        assertNull(permissionHelper.decode(""));
        assertNull(permissionHelper.decode(" "));
        assertNull(permissionHelper.decode("D"));

  @Override
  @CheckForNull
  public Entry<K, V> firstEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(entryIterator(), null);
  }

  @Override
  @CheckForNull
  public Entry<K, V> lastEntry() {
    return Iterators.<@Nullable Entry<K, V>>getNext(descendingEntryIterator(), null);
  }

  @Override
  @CheckForNull
  public Entry<K, V> pollFirstEntry() {
    return Iterators.pollNext(entryIterator());
  }

     *             installation has failed.
     * @throws IllegalArgumentException in case of parameter {@code request} is {@code null} or parameter
     *             {@code localRepository} is {@code null} or {@code localRepository} is not a directory
     *             or parameter {@code mavenArtifacts} is {@code null} or
     *             {@code mavenArtifacts.isEmpty()} is {@code true}.
     */

     * @param context The environmental context used to determine the activation status of the profile, must not be
     *            {@code null}.
     * @param problems The container used to collect problems (e.g. bad syntax) that were encountered, must not be
     *            {@code null}.
     * @return {@code true} if the profile is active, {@code false} otherwise.

     *            false} to use the update policy configured on each repository.
     * @return This request, never {@code null}.
     */
    RepositoryRequest setForceUpdate(boolean forceUpdate);

    /**
     * Gets the local repository to use.
     *
     * @return The local repository to use or {@code null} if not set.
     */
    ArtifactRepository getLocalRepository();

    /**
     * Sets the local repository to use.

    }

    public String getInput() {
        return input;
    }

    public String getOutput() {
        return output;
    }

    public boolean isUpdated() {
        return newInput != null && newOutput != null;
    }

    public boolean isDeleted() {
        return isUpdated() && StringUtil.isBlank(newInput);
    }

    @Override
    public int hashCode() {
        return Objects.hash(input, output);

                artifact.getGroupId(),
                artifact.getArtifactId(),
                artifact.getVersion(),
                artifact.getType(),
                artifact.getClassifier(),
                null,
                artifact.getDownloadUrl(),
                artifact.getDependencyTrail());
    }

    protected ArtifactNotFoundException(