this.client = client;
        this.settings = settings;
        analyzerSettings = settings.analyzer();
    }

    @Override
    public void init() throws IOException {
        // nothing
    }

    @Override
    public List<String> convert(final String text, final String field, final String... langs) throws IOException {
        final ReadingConverter converter;

        }

        @Override
        public void execute() throws MojoExecutionException {
            try {
                mojoV4.execute();
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                throw new MojoExecutionException(e);
            }
        }

        @Override
        public void setLog(Log log) {}

    putAll(multimap);
  }

  @Override
  Map<K, Collection<V>> createAsMap() {
    return createMaybeNavigableAsMap();
  }

  /**
   * {@inheritDoc}
   *
   * <p>Creates an empty {@code TreeSet} for a collection of values for one key.
   *
   * @return a new {@code TreeSet} containing a collection of values for one key
   */
  @Override
  SortedSet<V> createCollection() {

    /**
     * Closes this output stream and releases any system resources associated
     * with it.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {
            if (this.handle.isValid()) {
                this.handle.close();
            }
        } finally {

 *
 * @author koichik
 */
class JulLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {
        return new JulLoggerAdapter(clazz);
    }

    @Override
    public void releaseAll() {
    }

    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {
          @Override
          protected Boolean initialValue() {
            return false;
          }
        };

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {
      checkNotNull(event);
      checkNotNull(subscribers);

        this.iterators = iterators;
    }

    @Override
    public boolean hasNext() {
        for (; index < iterators.length; ++index) {
            if (iterators[index].hasNext()) {
                return true;
            }
        }
        return false;
    }

    @Override
    public E next() {
        if (!hasNext()) {

  MapRetrievalCache(Map<K, V> backingMap) {
    super(backingMap);
  }

  @SuppressWarnings("unchecked") // Safe because we only cast if key is found in map.
  @Override
  @Nullable V get(Object key) {
    checkNotNull(key);
    V value = getIfCached(key);
    if (value != null) {
      return value;
    }

    value = getWithoutCaching(key);
    if (value != null) {

    protected AbstractMavenTransferListener(MessageBuilderFactory messageBuilderFactory, PrintWriter out) {
        this.messageBuilderFactory = messageBuilderFactory;
        this.out = out;
    }

    @Override
    public void transferInitiated(TransferEvent event) {
        String action = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";

    }

    @Override
    public void onEvent(Object event) {
        if (event instanceof ExecutionEvent executionEvent) {
            if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
                usedTypes.clear();
            }
        }
    }

    @Override
    public Optional<Type> lookup(String id) {
        return Optional.of(require(id));