while (urlpath.charAt(i) != '/') {
                i--;
            }
            return urlpath.substring(i + 1);
        }
        if (shr != null) {
            return shr + '/';
        }
        if (this.url.getHost().length() > 0) {
            return this.url.getHost() + '/';
        }
        return "smb://";
    }

    /**
     * {@inheritDoc}
     *

     */
    private samr() {
        // Utility class
    }

    /**
     * Returns the RPC interface syntax UUID and version for SAMR protocol.
     *
     * @return The SAMR interface UUID string
     */
    public static String getSyntax() {
        return "12345778-1234-abcd-ef00-0123456789ac:1.0";
    }

    /** Account control bit flag: Account is disabled */

    assertTrue(Files.isFile().apply(asciiFile));
  }

  /** Returns a root path for the file system. */
  private static File root() {
    return File.listRoots()[0];
  }

  /** Returns a {@code File} object for the given path parts. */
  private static File file(String first, String... more) {
    return file(new File(first), more);
  }

  /** Returns a {@code File} object for the given path parts. */

{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}

### Gérer les valeurs de retour { #return-values }

Elles peuvent retourner des valeurs ou non, ces valeurs ne seront pas utilisées.

Vous pouvez donc réutiliser une dépendance normale (qui retourne une valeur) que vous utilisez déjà ailleurs ; même si la valeur n'est pas utilisée, la dépendance sera exécutée :

   * returned by {@link CacheLoader#loadAll} will be stored in the cache, over-writing any
   * previously cached values. This method will throw an exception if {@link CacheLoader#loadAll}
   * returns {@code null}, returns a map containing null keys or values, or fails to return an entry
   * for each requested key.
   *
   * <p>Note that duplicate elements in {@code keys}, as determined by {@link Object#equals}, will
   * be ignored.
   *

            chain.doFilter(request, response);
            return;
        }

        final short cpuPercent = ComponentUtil.getSystemHelper().getSearchEngineCpuPercent();

        if (cpuPercent < threshold) {
            chain.doFilter(request, response);
            return;
        }

        if (logger.isInfoEnabled()) {

			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
		return
	}

	if err = httpWriter.Close(); err != nil {
		if !httpWriter.HasWritten() { // write error response only if no data or headers has been written to client yet
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
		return
	}
}

  public final V getValue() {
    return super.getValue();
  }

  @Override
  @ParametricNullness
  public final V setValue(@ParametricNullness V value) {
    return super.setValue(value);
  }

  @Nullable ImmutableMapEntry<K, V> getNextInKeyBucket() {
    return null;
  }

  @Nullable ImmutableMapEntry<K, V> getNextInValueBucket() {
    return null;
  }

  /**

        this.targetClass = targetClass;
    }

    /**
     * Returns the target class.
     *
     * @return Target class
     */
    public Class<?> getTargetClass() {
        return targetClass;
    }

package mountinfo

// CheckCrossDevice - check if any input path has multiple sub-mounts.
// this is a dummy function and returns nil for now.
func CheckCrossDevice(paths []string) error {
	return nil
}

// IsLikelyMountPoint determines if a directory is a mountpoint.
func IsLikelyMountPoint(file string) bool {
	return false