* specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api;

import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Immutable;
import org.apache.maven.api.annotations.Nonnull;

/**

        stream(crawlingConfig.getPermissions()).of(stream -> stream.forEach(p -> roleTypeList.add(p)));
        putResultDataBody(dataMap, fessConfig.getIndexFieldRole(), roleTypeList);
        // virtualHosts
        putResultDataBody(dataMap, fessConfig.getIndexFieldVirtualHost(),
                stream(crawlingConfig.getVirtualHosts()).get(stream -> stream.filter(StringUtil::isNotBlank).collect(Collectors.toList())));

     */
    Metadata read(Reader input, Map<String, ?> options) throws IOException, MetadataParseException;

    /**
     * Reads the metadata from the specified byte stream. The stream will be automatically closed before the method
     * returns.
     *
     * @param input The stream to deserialize the metadata from, must not be {@code null}.
     * @param options The options to use for deserialization, may be {@code null} to use the default values.

     */
    Settings read(Reader input, Map<String, ?> options) throws IOException, SettingsParseException;

    /**
     * Reads the settings from the specified byte stream. The stream will be automatically closed before the method
     * returns.
     *
     * @param input The stream to deserialize the settings from, must not be {@code null}.
     * @param options The options to use for deserialization, may be {@code null} to use the default values.

    /**
     * Reads the toolchains from the specified byte stream. The stream will be automatically closed before the method
     * returns.
     *
     * @param input The stream to deserialize the toolchains from, must not be {@code null}.
     * @param options The options to use for deserialization, may be {@code null} to use the default values.

                    logger.debug(() -> "Refreshed " + stream(indices).get(stream -> stream.collect(Collectors.joining(", "))));
                }
            }

            @Override
            public void onFailure(final Exception e) {
                logger.error(() -> "Failed to refresh " + stream(indices).get(stream -> stream.collect(Collectors.joining(", "))), e);
            }
        });

import java.util.Map;
import java.util.Set;

import org.codehaus.plexus.classworlds.realm.ClassRealm;

import static java.util.function.Function.identity;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toMap;

/**
 * Provides information about artifacts (identified by groupId:artifactId string key) and classpath elements exported by

    }

    public static class Config {

        private final String[] values;

        public Config(final String value) {
            values = StreamUtil.split(value, Pattern.quote("|")).get(stream -> stream.map(String::trim).toArray(n -> new String[n]));
        }

        public boolean isCache() {
            for (final String value : values) {
                if ("cache".equalsIgnoreCase(value)) {

@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class CountingOutputStream extends FilterOutputStream {

  private long count;

  /**
   * Wraps another output stream, counting the number of bytes written.
   *
   * @param out the output stream to be wrapped
   */
  public CountingOutputStream(OutputStream out) {
    super(checkNotNull(out));
  }

  /** Returns the number of bytes written. */

            if (path != null) {
                stream(path.split(File.pathSeparator)).of(stream -> stream.map(String::trim).forEach(s -> pathList.add(s)));
            }
            if (logger.isDebugEnabled()) {
                logger.debug("search paths: {}", pathList);
            }
            available = generatorList.stream().map(s -> {
                if (s.startsWith("${path}")) {