*
     * @param id the unique identifier of the user
     * @return an OptionalEntity containing the user if found
     */
    public OptionalEntity<User> getUser(final String id) {
        return userBhv.selectByPK(id).map(u -> ComponentUtil.getAuthenticationManager().load(u));
    }

    /**
     * Retrieves a user by their username.
     *
     * @param username the username to search for

//
// FIXME: It currently only lists `minio_` prefixed metrics.
func (h *metricsV3Server) listMetrics(path string) http.Handler {
	// First collect all matching MetricsGroup's
	matchingMG := make(map[collectorPath]*MetricsGroup)
	for _, collPath := range h.metricsData.collectorPaths {
		if collPath.isDescendantOf(path) {
			if v, ok := h.metricsData.mgMap[collPath]; ok {
				matchingMG[collPath] = v

                        changed = true;
                    }
                    if ( updateSnapshotVersions )
                    {
                        java.util.Map<String, SnapshotVersion> versions = new java.util.LinkedHashMap<>();
                        // never convert from legacy to new format if either source or target is legacy format

	newKeys := make([][]byte, 0, sz)
	newVals := make([][]byte, 0, sz)
	var removeKey func(s []byte) bool

	// Copy if big number of compares...
	if len(keys) > 5 && sz > 5 {
		mKeys := make(map[string]struct{}, len(keys))
		for _, key := range keys {
			mKeys[key] = struct{}{}
		}
		removeKey = func(s []byte) bool {
			_, ok := mKeys[string(s)]
			return ok
		}
	} else {

        }

        @Override
        public jakarta.servlet.ServletRegistration getServletRegistration(String servletName) {
            return null;
        }

        @Override
        public java.util.Map<String, ? extends jakarta.servlet.ServletRegistration> getServletRegistrations() {
            return null;
        }

        @Override

    val ephemeral_keys_supported: Boolean,
    val rating: String,
    val tls_version: String,
    val able_to_detect_n_minus_one_splitting: Boolean,
    val insecure_cipher_suites: Map<String, List<String>>,
    val given_cipher_suites: List<String>?,
  )

  @Test
  @Disabled
  fun testSSLFeatures() {
    assumeNetwork()

     */
    default Stream<Phase> allPhases() {
        return phases().stream().flatMap(Phase::allPhases);
    }

    /**
     * Collection of aliases for this lifecycle.
     * Aliases map Maven 3 phase names to their Maven 4 equivalents.
     *
     * @return the collection of phase aliases
     */
    Collection<Alias> aliases();

    /**
     * A phase in the lifecycle.
     *

		NumVersions:      1,
		SuccessorModTime: time.Time{},
	}
	fi.SetTierFreeVersionID(uuid.New().String())
	// Test if free version is created when SkipTier wasn't set on fi
	j := xlMetaV2Object{}
	j.MetaSys = make(map[string][]byte)
	j.MetaSys[metaTierName] = []byte("WARM-1")
	j.MetaSys[metaTierStatus] = []byte(lifecycle.TransitionComplete)
	j.MetaSys[metaTierObjName] = []byte("obj-1")
	if _, ok := j.InitFreeVersion(fi); !ok {

        FileEntry e;
        HashMap map;

        if (p.lastIndexOf('/') != p.length() - 1) {
            throw new SmbException(url.toString() + " directory must end with '/'");
        }
        if (getType() != TYPE_SERVER) {
            throw new SmbException("The requested list operations is invalid: " + url.toString());
        }

        map = new HashMap();

        <codeSegment>
          <version>4.1.0+</version>
          <code>
            <![CDATA[
    volatile Map<String, Plugin> pluginMap;

    /**
     * @return a Map of plugins field with {@code Plugins#getKey()} as key
     * @see Plugin#getKey()
     */
    public Map<String, Plugin> getPluginsAsMap() {
        if (pluginMap == null) {
            synchronized (this) {