}

  @Override
  protected int doHash(F a) {
    return resultEquivalence.hash(function.apply(a));
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj == this) {
      return true;
    }
    if (obj instanceof FunctionalEquivalence) {
      FunctionalEquivalence<?, ?> that = (FunctionalEquivalence<?, ?>) obj;

        return java.util.Objects.hashCode(input);
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final StopwordsItem other = (StopwordsItem) obj;
        return java.util.Objects.equals(input, other.input);
    }

          dispatching.remove();
          queue.remove();
        }
      }
    }

    private static final class Event {
      private final Object event;
      private final Iterator<Subscriber> subscribers;

      private Event(Object event, Iterator<Subscriber> subscribers) {
        this.event = event;
        this.subscribers = subscribers;
      }
    }
  }

    }

    @Deprecated
    public Object lookup(String role) throws ComponentLookupException {
        return container.lookup(role);
    }

    @Deprecated
    public Object lookup(String role, String roleHint) throws ComponentLookupException {
        return container.lookup(role, roleHint);
    }

    @Deprecated
    public List<Object> lookupList(String role) throws ComponentLookupException {

@Singleton
public class DefaultPluginVersionResolver implements PluginVersionResolver {
    private static final String REPOSITORY_CONTEXT = org.apache.maven.api.services.RequestTrace.CONTEXT_PLUGIN;

    private static final Object CACHE_KEY = new Object();

    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final RepositorySystem repositorySystem;
    private final MetadataReader metadataReader;

   * {@link #valueField} of {@code future}.
   */
  static boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
    return ATOMIC_HELPER.casValue(future, expect, update);
  }

  /** Returns the value of the future, using a volatile read. */
  final @Nullable Object value() {
    return valueField;
  }

  /** Returns the head of the listener stack, using a volatile read. */

    public void init() {
        createFilterChain();
    }

    /**
     * Parses the given query string and returns a Lucene Query object.
     * The query is processed through the filter chain before being parsed.
     *
     * @param query the query string to parse
     * @return the parsed Query object
     * @throws QueryParseException if the query cannot be parsed
     */
    public Query parse(final String query) {

            public boolean equals(Object o) {
                return o instanceof DefaultProjectBuilderRequest that
                        && allowStubModel == that.allowStubModel
                        && recursive == that.recursive
                        && processPlugins == that.processPlugins
                        && Objects.equals(path, that.path)
                        && Objects.equals(source, that.source)

    }

    @Override
    public int size() {
      return multimap.size();
    }

    @Override
    public boolean contains(@Nullable Object object) {
      if (object instanceof Entry) {
        Entry<?, ?> entry = (Entry<?, ?>) object;
        return multimap.containsEntry(entry.getKey(), entry.getValue());
      }
      return false;
    }

    // redeclare to help optimizers with b/310253115

    }

    @Override
    public boolean equals(@Nullable Object object) {
      if (object == this) {
        return true;
      }
      if (object instanceof CharArrayAsList) {
        CharArrayAsList that = (CharArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }