import org.apache.catalina.startup.Tomcat;
import org.apache.tomcat.util.http.CookieProcessorBase;
import org.apache.tomcat.util.http.Rfc6265CookieProcessor;
import org.apache.tomcat.util.net.SSLHostConfig;
import org.apache.tomcat.util.net.SSLHostConfigCertificate;
import org.codelibs.core.lang.StringUtil;
import org.codelibs.fess.tomcat.valve.SuppressErrorReportValve;
import org.codelibs.fess.tomcat.webresources.FessWebResourceRoot;

                        return Collections.emptyList();
                    }

                    @Override
                    public Stream<Phase> allPhases() {
                        return Stream.concat(Stream.of(this), phases().stream().flatMap(Phase::allPhases));
                    }
                })
                .collect(Collectors.toList());
    }

    @Override
    public Collection<Alias> aliases() {

    /**
     * LDAP filter for finding user accounts.
     * Defines the search filter used to locate user accounts in LDAP.
     */
    @Size(max = 1000)
    public String ldapAccountFilter;

    /**
     * LDAP filter for finding groups.
     * Defines the search filter used to locate groups in LDAP.
     */
    @Size(max = 1000)
    public String ldapGroupFilter;

    /**

 *
 * <p>Duplicate host configurations allow administrators to define hostname patterns
 * that should be treated as equivalent during crawling. This helps avoid indexing
 * duplicate content from the same logical site that may be accessible via different
 * hostnames (e.g., www.example.com and example.com).</p>
 */
public class DuplicateHostService extends FessAppService {

    /**

/** Benchmarks for memory consumption of map implementations. */
@NullUnmarked
public class MapsMemoryBenchmark {
  static final Map<String, MapsImplEnum> mapEnums =
      uniqueIndex(
          Iterables.<MapsImplEnum>concat(
              asList(MapImpl.values()), asList(SortedMapImpl.values()), asList(BiMapImpl.values())),
          toStringFunction());

  @Param({
    "HashMapImpl",
    "LinkedHashMapImpl",
    "ConcurrentHashMapImpl",

if "x%1x" == "xx" goto displayUsage
set SERVICE_CMD=%1
shift
if "x%1x" == "xx" goto checkServiceCmd
set SERVICE_ID=%1

:checkServiceCmd

if "%LOG_OPTS%" == "" set LOG_OPTS=--LogPath "%LOG_DIR%" --LogPrefix "%SERVICE_ID%" --StdError auto --StdOutput auto

if /i %SERVICE_CMD% == install goto doInstall
if /i %SERVICE_CMD% == remove goto doRemove
if /i %SERVICE_CMD% == start goto doStart

## Consequences

* X
* Y
* Z
```

## Status

ACCEPTED

## Consequences

* We start to use Architectural Decision Records
* We use the proposed template from this ADR
* We locate `.md` files in the folder `/architecture/standards`
* We highly encourage usage of ADR to communicate decisions

                    copyBeanToBean(entity, form, copyOp -> {
                        copyOp.excludeNull();
                        copyOp.exclude(Stream.concat(Stream.of(Constants.COMMON_CONVERSION_RULE),
                                Stream.of(Constants.PERMISSIONS, Constants.VIRTUAL_HOSTS)).toArray(n -> new String[n]));
                    });

/**
 * The logical branch.
 * For non-merge-queue branches this is the same as {@link #buildBranch}.
 * For merge-queue branches, this is the base branch.
 *
 * For example, for the merge queue branch "gh-readonly-queue/master/pr-12345-1a2b3c4d" the logical branch is "master".
 */
val Project.logicalBranch: Provider<String>

              "io",
              "math",
              "net",
              "primitives",
              "reflect",
              "util.concurrent",
              "xml")
          .transform("com.google.common."::concat)
          .toSet();

  public void testClassesHaveOverrides() throws Exception {
    for (ClassInfo info : ClassPath.from(getClass().getClassLoader()).getAllClasses()) {