*/
    public static String fromUNIBytes(final byte[] src, final int srcIndex, final int len) {
        return new String(src, srcIndex, len, UNI_ENCODING);
    }

    /**
     * Finds the null termination in a UTF-16LE encoded string buffer.
     *
     * @param buffer the byte buffer to search
     * @param bufferIndex the starting position in the buffer
     * @param maxLen the maximum length to search

        return editor.insertMavenElement(parent, name, content);
    }

    /**
     * Finds a child element by name under the specified parent.
     *
     * @param parent the parent element
     * @param name the child element name to find
     * @return the child element if found, null otherwise
     *
     */

        if (directive == null) {
            return 0;
        }
        return directive.getCrawlDelay();
    }

    /**
     * Returns the most specific directive matching the given user agent.
     * The method finds the longest matching user agent pattern in the directives,
     * excluding the general "*" pattern which matches all bots.
     *
     * @param userAgent the user agent string to match against directives,

    public void setSuperClassName(String superClassName) {
        this.superClassName = superClassName;
    }

    public ClassMetaData getSuperClass() {
        return superClassName == null ? null : metaDataRepository.find(superClassName);
    }

    public List<String> getInterfaceNames() {
        return interfaceNames;
    }

    public void addInterfaceName(String name) {
        interfaceNames.add(name);
    }

    //
    /**
     *
     * @param artifact an artifact
     * @return found artifact
     * @since 3.0-alpha-3
     */
    Artifact find(Artifact artifact);

    /**
     * Finds the versions of the specified artifact that are available in this repository.
     *
     * @param artifact The artifact whose available versions should be determined, must not be {@code null}.

        NdrShort ns = new NdrShort(0xABCD); // value & 0xFF => 0xCD
        buf.reset();
        int startIndex = buf.getIndex();
        ns.encode(buf);

        // Find where the actual data starts (after alignment)
        int alignmentBytes = 0;
        if (startIndex % 2 != 0) {
            alignmentBytes = 1; // Need 1 byte of padding for 2-byte alignment
        }

	if err = l.LDAP.LookupBind(conn); err != nil {
		return nil, nil, err
	}

	// Lookup user DN
	lookupRes, err := l.LDAP.LookupUsername(conn, username)
	if err != nil {
		errRet := fmt.Errorf("Unable to find user DN: %w", err)
		return nil, nil, errRet
	}

	groups, err := l.LDAP.SearchForUserGroups(conn, username, lookupRes.ActualDN)
	if err != nil {
		return nil, nil, err
	}

	return lookupRes, groups, nil
}

	}
	for _, relations := range embeddedRelations.EmbeddedRelations {
		names = append(names, embeddedValues(relations)...)
	}
	return names
}

// preloadEntryPoint enters layer by layer. It will call real preload if it finds the right entry point.
// If the current relationship is embedded or joined, current query will be ignored.
//
//nolint:cyclop

     * the basis for the Method map.
     */
    private final Class<?> clazz;

    /**
     * Cache of Methods, or CACHE_MISS, keyed by method
     * name and actual arguments used to find it.
     */
    private final Map<String, Object> methodCache = new Hashtable<>();

    private MethodMap methodMap = new MethodMap();

    /**
     * Standard constructor
     * @param clazz The class.
     */

        Path tempDir = Files.createTempDirectory("mvnup-project-");
        context.debug("Created temp project directory: " + tempDir);

        // Find the common root of all POM paths to preserve relative structure
        Path commonRoot = findCommonRoot(pomMap.keySet());
        context.debug("Common root: " + commonRoot);