* or does not contain a POM file, the return value indicates the expected path to the POM file. Subdirectories of
     * the project directory will not be considered when locating the POM file. The return value will be an absolute
     * path if the project directory is given as an absolute path.
     *

  <description>Flat directory structure case: module = ../child directory path + child directory path != child-artifact-id</description>

  <modules>
    <module>../inheritance</module><!-- current directory == inheritance -->
  </modules>

  <!-- 5 urls in the pom will be inherited with path added -->
  <url>http://www.apache.org/path/to/parent/</url>
  <scm>
    <connection>scm:my-scm:http://domain.org/base</connection>

For that you need to access the request directly.

{* ../../docs_src/using_request_directly/tutorial001_py310.py hl[1,7:8] *}

By declaring a *path operation function* parameter with the type being the `Request` **FastAPI** will know to pass the `Request` in that parameter.

/// tip

Note that in this case, we are declaring a path parameter beside the request parameter.

import (
	"bytes"
	"context"
	"fmt"
	"testing"
)

// Test if various paths work as expected when converted to UNC form
func TestUNCPaths(t *testing.T) {
	testCases := []struct {
		objName string
		pass    bool
	}{
		{"/abcdef", true},
		{"/a/b/c/d/e/f/g", true},
		{string(bytes.Repeat([]byte("界"), 85)), true},
		// Each path component must be <= 255 bytes long.
		{string(bytes.Repeat([]byte("界"), 280)), false},

 *
 * @author taedium
 */
public interface ResourceHandler {

    /**
     * Processes a resource.
     *
     * @param path the path
     * @param is the {@link InputStream} to read the resource
     */
    void processResource(String path, InputStream is);

                }
            }
            return builder.build()
        }

        private
        fun processDirectory(dir: Path, builder: Trie.Builder) {
            Files.walkFileTree(dir, object : SimpleFileVisitor<Path>() {
                override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
                    val zipEntry = ZipEntry(dir.relativize(file).toString())

                    type.getLanguage().id(),
                    type.getPathTypes().contains(JavaPathType.CLASSES));
            // TODO: watch out for module path
        });

        // Note: here, type decides is artifact added to "build path" (for example during resolution)
        // and "build path" is intermediate data that is used to create actual Java classpath/modulepath
        // but to create those, proper filtering should happen via Type properties.

        this.basedir = basedir(url);
    }

    public MavenArtifactRepository(
            String id,
            Path path,
            ArtifactRepositoryLayout layout,
            ArtifactRepositoryPolicy snapshots,
            ArtifactRepositoryPolicy releases) {
        this.id = id;
        this.url = path.toUri().toString();
        this.layout = layout;
        this.snapshots = snapshots;
        this.releases = releases;

/**
 * Search request body for path mapping administration API.
 */
public class SearchBody extends BaseSearchBody {

    /**
     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    /** Regular expression pattern for path mapping */
    public String regex;

    /** Replacement pattern for path mapping */
    public String replacement;

                }
                if (line ==~ /-{4,}\s*/) { // Four dashes looks like a snippet
                    if (snippet == null) {
                        Path path = docs.dir.toPath().relativize(file.toPath())
                        snippet = new Snippet(path: path, start: lineNumber, testEnv: testEnv, name: name)
                        if (lastLanguageLine == lineNumber - 1) {
                            snippet.language = lastLanguage