.filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
        body.virtualHosts = stream(entity.getVirtualHosts())
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).collect(Collectors.joining("\n")));
        return body;
    }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.api.admin.dict;

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

import javax.annotation.Resource;

import org.codelibs.fess.app.web.api.ApiResult;
import org.codelibs.fess.app.web.api.admin.FessApiAdminAction;

import org.gradle.api.internal.tasks.compile.incremental.deps.ClassSetAnalysis;

import javax.annotation.Nullable;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

public class PreviousCompilation {
    private final PreviousCompilationData data;
    private final ClassSetAnalysis classAnalysis;

    public PreviousCompilation(PreviousCompilationData data) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.es.user.exbhv;

import java.util.Map;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.codelibs.core.misc.Pair;
import org.codelibs.fess.es.user.bsbhv.BsRoleBhv;
import org.codelibs.fess.es.user.exentity.Role;
import org.codelibs.fess.util.ComponentUtil;

            .collect(Collectors.toCollection(() -> result));

        callInterceptorSpecs.getConstructorRequests().stream()
            .peek(spec -> validateRequests(spec.getRequests(), onFailure))
            .map(InterceptGroovyCallsGenerator::generateConstructorInterceptorClass)
            .collect(Collectors.toCollection(() -> result));

        return result;
    }

  @SuppressWarnings({"rawtypes", "unchecked"})
  static <E> Collector<E, ?, ImmutableList<E>> toImmutableList() {
    return (Collector) TO_IMMUTABLE_LIST;
  }

  // Sets

  @SuppressWarnings({"rawtypes", "unchecked"})
  static <E> Collector<E, ?, ImmutableSet<E>> toImmutableSet() {
    return (Collector) TO_IMMUTABLE_SET;
  }

  static <E> Collector<E, ?, ImmutableSortedSet<E>> toImmutableSortedSet(

  static <E> Collector<E, ?, ImmutableList<E>> toImmutableList() {
    return (Collector) TO_IMMUTABLE_LIST;
  }

  // Sets

  @SuppressWarnings({"rawtypes", "unchecked"})
  static <E> Collector<E, ?, ImmutableSet<E>> toImmutableSet() {
    return (Collector) TO_IMMUTABLE_SET;
  }

  static <E> Collector<E, ?, ImmutableSortedSet<E>> toImmutableSortedSet(
      Comparator<? super E> comparator) {

import org.gradle.internal.DisplayName;
import org.gradle.internal.action.ConfigurableRule;
import org.gradle.internal.rules.SpecRuleAction;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

class ClassBasedMetadataRuleWrapper implements MetadataRuleWrapper {
    private final List<SpecConfigurableRule> classRules = Lists.newArrayListWithExpectedSize(5);

import me.lucko.jarrelocator.JarRelocator
import me.lucko.jarrelocator.Relocation
import java.util.jar.JarFile
import java.util.stream.Collectors

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath("me.lucko:jar-relocator:1.3")
    }
}

// tag::artifact-transform-relocate[]
@CacheableTransform                                                          // <1>

 */

package org.gradle.internal.rules;

import org.gradle.model.internal.type.ModelType;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class DefaultRuleActionValidator implements RuleActionValidator {
    private static final String VALID_NO_TYPES = "Rule may not have an input parameter of type: %s.";