import org.codehaus.plexus.interpolation.util.ValueSourceUtils;

/**
 *
 * @deprecated use {@link org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
class PathTranslatingPostProcessor implements InterpolationPostProcessor {

    private final Collection<String> unprefixedPathKeys;
    private final Path projectDir;
    private final PathTranslator pathTranslator;
    private final List<String> expressionPrefixes;

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

import org.apache.maven.artifact.Artifact;

/**
 */
public class ExclusionSetFilter implements ArtifactFilter {
    private Set<String> excludes;

    public ExclusionSetFilter(String[] excludes) {
        this.excludes = new LinkedHashSet<>(Arrays.asList(excludes));
    }

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new PreemptiveAuth().run();
  }

  static final class BasicAuthInterceptor implements Interceptor {
    private final String credentials;
    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {
      this.credentials = Credentials.basic(username, password);

import org.lastaflute.db.dbflute.exception.ProvidedClassificationNotFoundException;

/**
 * @author jflute
 */
public class FessListedClassificationProvider implements ListedClassificationProvider {

    @Override
    public ClassificationMeta provide(final String classificationName) throws ProvidedClassificationNotFoundException {

import java.io.Serializable;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Set;

/**
 * @author shinsuke
 *
 */
public class ResultData implements Serializable {
    private static final long serialVersionUID = 1L;

    private String transformerName;

    private byte[] data;

    private String encoding;

 * other {@code Future}, be {@linkplain #cancel cancelled}.
 *
 * <p>{@code SettableFuture} is the recommended {@code ListenableFuture} implementation when your
 * task cannot be implemented with {@link ListeningExecutorService}, the various {@link Futures}
 * utility methods, or {@link ListenableFutureTask}. Those APIs have less opportunity for developer

 * own subclass of {@link ListenableFuture}, complete with a method like {@link #from} to adapt an
 * existing {@code ListenableFuture}, implemented atop a {@link ForwardingListenableFuture} that
 * forwards to that future and adds the desired methods.
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

    * If you didn't use FastAPI and used Starlette directly (or another tool, like Sanic, Flask, Responder, etc) you would have to implement all the data validation and serialization yourself. So, your final application would still have the same overhead as if it was built using FastAPI. And in many cases, this data validation and serialization is the biggest amount of code written in...

        asList(1, 2, 3, 4, 5),
        Ordering.<Integer>natural().leastOf(list.iterator(), Integer.MAX_VALUE));
  }

  public void testGreatestOfIterable_simple() {
    /*
     * If greatestOf() promised to be implemented as reverse().leastOf(), this
     * test would be enough. It doesn't... but we'll cheat and act like it does
     * anyway. There's a comment there to remind us to fix this if we change it.
     */

        asList(1, 2, 3, 4, 5),
        Ordering.<Integer>natural().leastOf(list.iterator(), Integer.MAX_VALUE));
  }

  public void testGreatestOfIterable_simple() {
    /*
     * If greatestOf() promised to be implemented as reverse().leastOf(), this
     * test would be enough. It doesn't... but we'll cheat and act like it does
     * anyway. There's a comment there to remind us to fix this if we change it.
     */