counter++
        }

        //updating/modifying the metadata and making sure every type reference across the metadata is fully qualified
        //so, the superClassName, interfaces and types needed by declared properties and declared methods will have fully qualified name
        TypeNameResolver resolver = new TypeNameResolver(repository)
        repository.each { name, metaData ->

 * at {@code META-INF/maven/org.apache.maven.api.di.Inject} containing the fully qualified
 * names of these classes.
 *
 * @since 4.0.0
 */
@SupportedAnnotationTypes("org.apache.maven.api.di.Named")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class DiIndexProcessor extends AbstractProcessor {

    /**
     * Set of fully qualified class names that have been processed and contain the {@link Named} annotation.

import org.gradle.internal.UncheckedException;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Resolves partial type names into fully qualified type names.
 */
public class TypeNameResolver {
    private final Set<String> primitiveTypes = new HashSet<String>();
    private final List<String> groovyImplicitImportPackages = new ArrayList<String>();

 * that allows for efficient discovery of injectable components at runtime.
 * <p>
 * The generated index is stored at {@code META-INF/maven/org.apache.maven.api.di.Inject} and contains
 * the fully qualified names of all classes annotated with {@code @Named}.
 *
 * @since 4.0.0
 */

            @TempDir(cleanup = CleanupMode.ON_SUCCESS) Path userHome)
            throws Exception {
        invoke(cwd, userHome, List.of("verify"), List.of());
    }

    @Disabled("Enable it when fully moved to NIO2 with Path/Filesystem (ie MavenExecutionRequest)")
    @Test
    void jimFs() throws Exception {
        try (FileSystem fs = Jimfs.newFileSystem(Configuration.unix())) {

 * using the information provided in an {@link InvokerRequest}. This interface is central
 * to the construction and invocation of Maven commands and builds, and it fully parses arguments.
 *
 * <p>The Invoker is designed to be flexible, allowing for different implementations
 * that can handle various types of {@link InvokerRequest InvokerRequests}. It also implements

    @Override
    public Artifact find(Artifact artifact) {
        File artifactFile = new File(localRepository.getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {

     * <strong>Important:</strong> This method returns the target path as specified in the configuration,
     * which may be relative or absolute. It does <strong>not</strong> perform any path resolution.
     * For the fully resolved absolute path, use {@link #targetPath(Project)} instead.
     * </p>
     * <p>
     * <strong>Return Value Semantics:</strong>
     * </p>
     * <ul>

In subsequent releases we are planning to extend this to provide things like

- Reload() of MinIO server arguments without fully restarting the process.

- Expanding 1 node at a time by automating the process of creating a new pool
  and decommissioning to provide a functionality that smaller deployments
  care about.

     * @return the parsed invoker request. Caller must start by checking {@link InvokerRequest#parsingFailed()} as
     * if there are parser errors, this request may not be fully processed and should immediately be failed.
     */
    @Nonnull
    InvokerRequest parseInvocation(@Nonnull ParserRequest parserRequest);