p1 = path1.lastIndexOf('/');
        p2 = path2.lastIndexOf('/');
        l1 = path1.length() - p1;
        l2 = path2.length() - p2;

        // anything with dots voids comparison
        if ((l1 > 1 && path1.charAt(p1 + 1) == '.') || (l2 > 1 && path2.charAt(p2 + 1) == '.')) {
            return true;
        }

        return l1 == l2 && path1.regionMatches(true, p1, path2, p2, l1);
    }

		return
	}

	vars := mux.Vars(r)

	var args dsync.LockArgs
	var lockers []dsync.NetLocker
	for path := range strings.SplitSeq(vars["paths"], ",") {
		if path == "" {
			continue
		}
		args.Resources = append(args.Resources, path)
	}

	for _, lks := range z.serverPools[0].erasureLockers {
		lockers = append(lockers, lks...)
	}

	for _, locker := range lockers {

    public void setPaths_Equal(String paths) {
        setPaths_Term(paths, null);
    }

    public void setPaths_Equal(String paths, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setPaths_Term(paths, opLambda);
    }

    public void setPaths_Term(String paths) {
        setPaths_Term(paths, null);
    }

    public void setPaths_Term(String paths, ConditionOptionCall<TermQueryBuilder> opLambda) {

     * @throws SmbException if an error occurs while resolving the DFS path
     */
    public String getDfsPath() throws SmbException {
        try {
            String path = this.treeConnection.ensureDFSResolved(this.fileLocator).getDfsPath();
            if (path != null && isDirectory()) {
                path += '/';
            }
            return path;
        } catch (final CIFSException e) {

            if dependant.call
            else EndpointContext()
        )

        if dependant.path:
            # For mounted sub-apps, include the mount path prefix
            mount_path = request.scope.get("root_path", "").rstrip("/")
            endpoint_ctx["path"] = f"{request.method} {mount_path}{dependant.path}"

        # Read body and auto-close files
        try:
            body: Any = None

			if err != nil {
				err = msgp.WrapError(err, "Paths")
				return
			}
			if cap(z.Paths) >= int(zb0002) {
				z.Paths = (z.Paths)[:zb0002]
			} else {
				z.Paths = make([]string, zb0002)
			}
			for za0001 := range z.Paths {
				z.Paths[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Paths", za0001)
					return
				}
			}
		default:

            </ul>

            <p>If this property is specified but is a relative path,
            then the path is resolved against the above-cited default value.</p>

            <p>When a target path is explicitly specified, the values of the {@code module} and {@code targetVersion}
            elements are not used for inferring the path (they are still used as compiler options however).

    /**
     * Adds an index configuration file path to be loaded.
     *
     * @param path path to the index configuration file
     */
    public void addIndexConfig(final String path) {
        indexConfigList.add(path);
    }

    /**
     * Adds a configuration file for a specific index.
     *
     * @param index the index name
     * @param path  path to the configuration file
     */

    }

    public void setPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
        setPaths_Terms("paths", opLambda, null);
    }

    public void setPaths_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFileConfigCA> aggsLambda) {
        setPaths_Terms("paths", opLambda, aggsLambda);
    }

  limitations](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md#kubernetes-v15-release-cri-v1alpha1)
* getDeviceNameFromMount() function doesn't return the volume path correctly when the volume path contains spaces [#37712](https://github.com/kubernetes/kubernetes/issues/37712)
* Federation alpha features do not have feature gates defined and
are hence enabled by default. This will be fixed in a future release.