Map<Object, InputLocation> locations;
        Map<Object, InputLocation> sourceLocations = source.locations;
        Map<Object, InputLocation> targetLocations = target.locations;
        if (sourceLocations == null) {
            locations = targetLocations;
        } else if (targetLocations == null) {
            locations = sourceLocations;
        } else {
            locations = new LinkedHashMap<>();

    ImmutableSet<ClassPath.LocationInfo> locations =
        ClassPath.locationsFrom(getClass().getClassLoader());
    assertThat(locations).isNotEmpty();
    for (ClassPath.LocationInfo location : locations) {
      ImmutableSet<ResourceInfo> resources = location.scanResources();
      assertThat(location.scanResources()).containsExactlyElementsIn(resources);
    }
  }

     * <ul>
     *   <li>Normalizing the relative path for the current platform</li>
     *   <li>Resolving the path against the current POM's location</li>
     *   <li>Using the model locator to find an existing POM at the resolved location</li>
     * </ul>
     *
     * @param modelLocator the locator to use for finding the related POM file
     * @param relative the relative path to resolve

        return getPath("WEB-INF/", "env/" + envName, names);
    }

    /**
     * Gets the path by trying multiple locations in order of preference.
     * First tries to get the real path from servlet context, then checks various
     * fallback locations including source and target directories.
     *
     * @param root the root directory (e.g., "WEB-INF/")

package org.apache.maven.api;

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

/**
 * <p>In Maven, repositories are locations where project artifacts (such as JAR files, POM files, and other
 * resources) are stored and retrieved. There are two primary types of repositories:
 * {@linkplain LocalRepository local repositories} and

    InputStream openStream() throws IOException;

    /**
     * Returns a human-readable description of where this source came from,
     * used primarily for error messages and debugging.
     * <p>
     * Examples of locations:
     * <ul>
     *   <li>Absolute file path: {@code /path/to/pom.xml}</li>
     *   <li>Relative file path: {@code ../parent/pom.xml}</li>
     *   <li>URL: {@code https://repo.maven.org/.../pom.xml}</li>

     */
    public static void write(XmlNode node, Writer writer) throws IOException {
        getService().doWrite(node, writer);
    }

    /**
     * Interface for building input locations during XML parsing.
     */
    public interface InputLocationBuilder {
        Object toInputLocation(XMLStreamReader parser);
    }

    /**

set_java_home() {
  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
  if [ -n "${JAVA_HOME-}" ]; then
    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
      # IBM's JDK on AIX uses strange locations for the executables
      JAVACMD="$JAVA_HOME/jre/sh/java"
      JAVACCMD="$JAVA_HOME/jre/sh/javac"
    else
      JAVACMD="$JAVA_HOME/bin/java"
      JAVACCMD="$JAVA_HOME/bin/javac"

## Migration from another search provider

Please see [MIGRATION.md](MIGRATION.md).

## Data Store

Currently, Fess supports crawling the following [storage locations and APIs](https://fess.codelibs.org/15.0/admin/dataconfig-guide.html):

 - [Confluence/Jira](https://github.com/codelibs/fess-ds-atlassian)
 - [Box](https://github.com/codelibs/fess-ds-box)

  <name>MavenToolchains</name>
  <description><![CDATA[
    This is a reference for the Maven Toolchains descriptor.
    <p>The default location for the toolchains file is {@code ~/.m2/toolchains.xml}
    <p>A Toolchain is a preconfigured object that Maven plugins can use for tool configuration retrieval (location and other information).
    <p>The <a href="/plugins/maven-toolchains-plugin/">toolchains-plugin</a> can read available toolchains on the user's computer