001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *   http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied.  See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 */
019package org.eclipse.aether.internal.impl.collect.bf;
020
021import javax.inject.Inject;
022import javax.inject.Named;
023import javax.inject.Singleton;
024
025import java.io.Closeable;
026import java.util.ArrayDeque;
027import java.util.ArrayList;
028import java.util.Arrays;
029import java.util.Collections;
030import java.util.LinkedHashMap;
031import java.util.List;
032import java.util.Map;
033import java.util.Optional;
034import java.util.Queue;
035import java.util.Set;
036import java.util.concurrent.Callable;
037import java.util.concurrent.CompletableFuture;
038import java.util.concurrent.ConcurrentHashMap;
039import java.util.concurrent.Future;
040import java.util.concurrent.atomic.AtomicReference;
041import java.util.function.Supplier;
042import java.util.stream.Collectors;
043import java.util.stream.Stream;
044
045import org.eclipse.aether.RepositorySystemSession;
046import org.eclipse.aether.RequestTrace;
047import org.eclipse.aether.artifact.Artifact;
048import org.eclipse.aether.collection.CollectRequest;
049import org.eclipse.aether.collection.DependencyCollectionException;
050import org.eclipse.aether.collection.DependencyManager;
051import org.eclipse.aether.collection.DependencySelector;
052import org.eclipse.aether.collection.DependencyTraverser;
053import org.eclipse.aether.collection.VersionFilter;
054import org.eclipse.aether.graph.DefaultDependencyNode;
055import org.eclipse.aether.graph.Dependency;
056import org.eclipse.aether.graph.DependencyNode;
057import org.eclipse.aether.impl.ArtifactDescriptorReader;
058import org.eclipse.aether.impl.RemoteRepositoryManager;
059import org.eclipse.aether.impl.VersionRangeResolver;
060import org.eclipse.aether.internal.impl.collect.DataPool;
061import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollectionContext;
062import org.eclipse.aether.internal.impl.collect.DefaultDependencyCollector;
063import org.eclipse.aether.internal.impl.collect.DefaultVersionFilterContext;
064import org.eclipse.aether.internal.impl.collect.DependencyCollectorDelegate;
065import org.eclipse.aether.internal.impl.collect.PremanagedDependency;
066import org.eclipse.aether.repository.RemoteRepository;
067import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
068import org.eclipse.aether.resolution.ArtifactDescriptorResult;
069import org.eclipse.aether.resolution.VersionRangeRequest;
070import org.eclipse.aether.resolution.VersionRangeResult;
071import org.eclipse.aether.spi.artifact.decorator.ArtifactDecoratorFactory;
072import org.eclipse.aether.util.ConfigUtils;
073import org.eclipse.aether.util.artifact.ArtifactIdUtils;
074import org.eclipse.aether.util.concurrency.SmartExecutor;
075import org.eclipse.aether.util.concurrency.SmartExecutorUtils;
076import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
077import org.eclipse.aether.version.Version;
078
079import static org.eclipse.aether.internal.impl.collect.DefaultDependencyCycle.find;
080
081/**
082 * Breadth-first {@link org.eclipse.aether.impl.DependencyCollector}
083 *
084 * @since 1.8.0
085 */
086@Singleton
087@Named(BfDependencyCollector.NAME)
088public class BfDependencyCollector extends DependencyCollectorDelegate {
089    public static final String NAME = "bf";
090
091    private static final String CONFIG_PROPS_PREFIX = DefaultDependencyCollector.CONFIG_PROPS_PREFIX + NAME + ".";
092
093    /**
094     * The key in the repository session's {@link RepositorySystemSession#getConfigProperties()
095     * configuration properties} used to store a {@link String} flag controlling the resolver's skip mode.
096     * Supported modes are "versionless" (default), "versioned" and "false" to not use skipper. The first two modes
097     * are defining "function" how to map artifact coordinates to (String) key while deciding "skip" logic.
098     * The "versionless" uses {@code G:A:C:E} coordinate elements only (without version), while "versioned" uses
099     * all {@code G:A:C:E:V} artifact coordinates.
100     *
101     * @since 1.8.0
102     * @configurationSource {@link RepositorySystemSession#getConfigProperties()}
103     * @configurationType {@link java.lang.String}
104     * @configurationDefaultValue {@link #DEFAULT_SKIPPER}
105     */
106    public static final String CONFIG_PROP_SKIPPER = CONFIG_PROPS_PREFIX + "skipper";
107
108    public static final String NONE_SKIPPER = "false";
109    public static final String VERSIONLESS_SKIPPER = "versionless";
110    public static final String VERSIONED_SKIPPER = "versioned";
111
112    /**
113     * The default value for {@link #CONFIG_PROP_SKIPPER}, {@code true}.
114     *
115     * @since 1.8.0
116     */
117    public static final String DEFAULT_SKIPPER = VERSIONLESS_SKIPPER;
118
119    /**
120     * The count of threads to be used when collecting POMs in parallel.
121     *
122     * @since 1.9.0
123     * @configurationSource {@link RepositorySystemSession#getConfigProperties()}
124     * @configurationType {@link java.lang.Integer}
125     * @configurationDefaultValue {@link #DEFAULT_THREADS}
126     */
127    public static final String CONFIG_PROP_THREADS = CONFIG_PROPS_PREFIX + "threads";
128
129    /**
130     * The default value for {@link #CONFIG_PROP_THREADS}, default value 5.
131     *
132     * @since 1.9.0
133     */
134    public static final int DEFAULT_THREADS = 5;
135
136    @Inject
137    public BfDependencyCollector(
138            RemoteRepositoryManager remoteRepositoryManager,
139            ArtifactDescriptorReader artifactDescriptorReader,
140            VersionRangeResolver versionRangeResolver,
141            Map<String, ArtifactDecoratorFactory> artifactDecoratorFactories) {
142        super(remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver, artifactDecoratorFactories);
143    }
144
145    @SuppressWarnings("checkstyle:parameternumber")
146    @Override
147    protected void doCollectDependencies(
148            RepositorySystemSession session,
149            RequestTrace trace,
150            DataPool pool,
151            DefaultDependencyCollectionContext context,
152            DefaultVersionFilterContext versionContext,
153            CollectRequest request,
154            DependencyNode node,
155            List<RemoteRepository> repositories,
156            List<Dependency> dependencies,
157            List<Dependency> managedDependencies,
158            Results results)
159            throws DependencyCollectionException {
160        String skipperMode = ConfigUtils.getString(session, DEFAULT_SKIPPER, CONFIG_PROP_SKIPPER);
161        Supplier<DependencyResolutionSkipper> skipperSupplier;
162        if (NONE_SKIPPER.equals(skipperMode)) {
163            logger.debug("Collector skip mode disabled");
164            skipperSupplier = DependencyResolutionSkipper::neverSkipper;
165        } else if (VERSIONLESS_SKIPPER.equals(skipperMode)) {
166            logger.debug("Collector skip mode enabled: {} (key function GACE)", skipperMode);
167            skipperSupplier = DependencyResolutionSkipper::defaultGACESkipper;
168        } else if (VERSIONED_SKIPPER.equals(skipperMode)) {
169            logger.debug("Collector skip mode enabled: {} (key function GACEV)", skipperMode);
170            skipperSupplier = DependencyResolutionSkipper::defaultGACEVSkipper;
171        } else {
172            throw new IllegalArgumentException("Unknown skipper mode: " + skipperMode + "; known are "
173                    + Arrays.asList(VERSIONLESS_SKIPPER, VERSIONED_SKIPPER, NONE_SKIPPER));
174        }
175
176        try (DependencyResolutionSkipper skipper = skipperSupplier.get();
177                ParallelDescriptorResolver parallelDescriptorResolver =
178                        new ParallelDescriptorResolver(SmartExecutorUtils.smartExecutor(
179                                session,
180                                null, // we don't know ahead of time; we want global executor
181                                ConfigUtils.getInteger(session, DEFAULT_THREADS, CONFIG_PROP_THREADS),
182                                getClass().getSimpleName() + "-"))) {
183            Args args = new Args(session, pool, context, versionContext, request, skipper, parallelDescriptorResolver);
184
185            DependencySelector rootDepSelector = session.getDependencySelector() != null
186                    ? session.getDependencySelector().deriveChildSelector(context)
187                    : null;
188            DependencyManager rootDepManager = session.getDependencyManager() != null
189                    ? session.getDependencyManager().deriveChildManager(context)
190                    : null;
191            DependencyTraverser rootDepTraverser = session.getDependencyTraverser() != null
192                    ? session.getDependencyTraverser().deriveChildTraverser(context)
193                    : null;
194            VersionFilter rootVerFilter = session.getVersionFilter() != null
195                    ? session.getVersionFilter().deriveChildFilter(context)
196                    : null;
197
198            List<DependencyNode> parents = Collections.singletonList(node);
199            for (Dependency dependency : dependencies) {
200                if (rootDepSelector != null && !rootDepSelector.selectDependency(dependency)) {
201                    continue;
202                }
203                RequestTrace childTrace =
204                        collectStepTrace(trace, args.request.getRequestContext(), parents, dependency);
205                DependencyProcessingContext processingContext = new DependencyProcessingContext(
206                        rootDepSelector,
207                        rootDepManager,
208                        rootDepTraverser,
209                        rootVerFilter,
210                        childTrace,
211                        repositories,
212                        managedDependencies,
213                        parents,
214                        dependency,
215                        PremanagedDependency.create(rootDepManager, dependency, false, args.premanagedState));
216                processingContext.withDependency(processingContext.premanagedDependency.getManagedDependency());
217                resolveArtifactDescriptorAsync(args, processingContext, results);
218                args.dependencyProcessingQueue.add(processingContext);
219            }
220
221            while (!args.dependencyProcessingQueue.isEmpty()) {
222                processDependency(
223                        args, results, args.dependencyProcessingQueue.remove(), Collections.emptyList(), false);
224            }
225
226            if (args.interruptedException.get() != null) {
227                // Thread.interrupted() cleared the flag when the interrupt was detected; restore it for the caller
228                Thread.currentThread().interrupt();
229                throw new DependencyCollectionException(
230                        results.getResult(), "Collection interrupted", args.interruptedException.get());
231            }
232        }
233    }
234
235    @SuppressWarnings("checkstyle:parameternumber")
236    private void processDependency(
237            Args args,
238            Results results,
239            DependencyProcessingContext context,
240            List<Artifact> relocations,
241            boolean disableVersionManagement) {
242        if (Thread.interrupted()) {
243            args.interruptedException.set(new InterruptedException());
244        }
245        if (args.interruptedException.get() != null) {
246            return;
247        }
248        Dependency dependency = context.dependency;
249        PremanagedDependency preManaged = context.premanagedDependency;
250
251        boolean noDescriptor = isLackingDescriptor(args.session, dependency.getArtifact());
252        boolean traverse =
253                !noDescriptor && (context.depTraverser == null || context.depTraverser.traverseDependency(dependency));
254
255        Future<DescriptorResolutionResult> resolutionResultFuture = args.resolver.find(dependency.getArtifact());
256        DescriptorResolutionResult resolutionResult;
257        VersionRangeResult rangeResult;
258        try {
259            resolutionResult = resolutionResultFuture.get();
260            rangeResult = resolutionResult.rangeResult;
261        } catch (Exception e) {
262            results.addException(dependency, e, context.parents);
263            return;
264        }
265
266        Set<Version> versions = resolutionResult.descriptors.keySet();
267        for (Version version : versions) {
268            Artifact originalArtifact = dependency.getArtifact().setVersion(version.toString());
269            Dependency d = dependency.setArtifact(originalArtifact);
270
271            final ArtifactDescriptorResult descriptorResult = resolutionResult.descriptors.get(version);
272            if (descriptorResult != null) {
273                d = d.setArtifact(descriptorResult.getArtifact());
274
275                int cycleEntry = find(context.parents, d.getArtifact());
276                if (cycleEntry >= 0) {
277                    results.addCycle(context.parents, cycleEntry, d);
278                    DependencyNode cycleNode = context.parents.get(cycleEntry);
279                    if (cycleNode.getDependency() != null) {
280                        DefaultDependencyNode child = createDependencyNode(
281                                relocations, preManaged, rangeResult, version, d, descriptorResult, cycleNode);
282                        context.getParent().getChildren().add(child);
283                        continue;
284                    }
285                }
286
287                if (!descriptorResult.getRelocations().isEmpty()) {
288                    if (context.depSelector == null || context.depSelector.selectDependency(d)) {
289                        boolean disableVersionManagementSubsequently = originalArtifact
290                                        .getGroupId()
291                                        .equals(d.getArtifact().getGroupId())
292                                && originalArtifact
293                                        .getArtifactId()
294                                        .equals(d.getArtifact().getArtifactId());
295
296                        PremanagedDependency premanagedDependency = PremanagedDependency.create(
297                                context.depManager, d, disableVersionManagementSubsequently, args.premanagedState);
298                        DependencyProcessingContext relocatedContext = new DependencyProcessingContext(
299                                context.depSelector,
300                                context.depManager,
301                                context.depTraverser,
302                                context.verFilter,
303                                context.trace,
304                                context.repositories,
305                                descriptorResult.getManagedDependencies(),
306                                context.parents,
307                                d,
308                                premanagedDependency);
309
310                        relocatedContext.withDependency(premanagedDependency.getManagedDependency());
311                        resolveArtifactDescriptorAsync(args, relocatedContext, results);
312                        processDependency(
313                                args,
314                                results,
315                                relocatedContext,
316                                descriptorResult.getRelocations(),
317                                disableVersionManagementSubsequently);
318                    }
319                    continue;
320                } else {
321                    d = args.pool.intern(d.setArtifact(args.pool.intern(d.getArtifact())));
322
323                    List<RemoteRepository> repos =
324                            getRemoteRepositories(rangeResult.getRepository(version), context.repositories);
325
326                    DefaultDependencyNode child = createDependencyNode(
327                            relocations,
328                            preManaged,
329                            rangeResult,
330                            version,
331                            d,
332                            descriptorResult.getAliases(),
333                            repos,
334                            args.request.getRequestContext());
335
336                    context.getParent().getChildren().add(child);
337
338                    boolean recurse =
339                            traverse && !descriptorResult.getDependencies().isEmpty();
340                    DependencyProcessingContext parentContext = context.withDependency(d);
341                    if (recurse) {
342                        doRecurse(args, parentContext, descriptorResult, child, results, disableVersionManagement);
343                    } else if (!args.skipper.skipResolution(child, parentContext.parents)) {
344                        List<DependencyNode> parents = new ArrayList<>(parentContext.parents.size() + 1);
345                        parents.addAll(parentContext.parents);
346                        parents.add(child);
347                        args.skipper.cache(child, parents);
348                    }
349                }
350            } else {
351                List<RemoteRepository> repos =
352                        getRemoteRepositories(rangeResult.getRepository(version), context.repositories);
353                DefaultDependencyNode child = createDependencyNode(
354                        relocations,
355                        preManaged,
356                        rangeResult,
357                        version,
358                        d,
359                        null,
360                        repos,
361                        args.request.getRequestContext());
362                context.getParent().getChildren().add(child);
363            }
364        }
365    }
366
367    @SuppressWarnings("checkstyle:parameternumber")
368    private void doRecurse(
369            Args args,
370            DependencyProcessingContext parentContext,
371            ArtifactDescriptorResult descriptorResult,
372            DefaultDependencyNode child,
373            Results results,
374            boolean disableVersionManagement) {
375        DefaultDependencyCollectionContext context = args.collectionContext.get();
376        args.collectionContext.compareAndSet(
377                context, context.set(parentContext.dependency, descriptorResult.getManagedDependencies()));
378        context = args.collectionContext.get();
379
380        DependencySelector childSelector =
381                parentContext.depSelector != null ? parentContext.depSelector.deriveChildSelector(context) : null;
382        DependencyTraverser childTraverser =
383                parentContext.depTraverser != null ? parentContext.depTraverser.deriveChildTraverser(context) : null;
384        VersionFilter childFilter =
385                parentContext.verFilter != null ? parentContext.verFilter.deriveChildFilter(context) : null;
386
387        final List<RemoteRepository> childRepos = args.ignoreRepos
388                ? parentContext.repositories
389                : remoteRepositoryManager.aggregateRepositories(
390                        args.session, parentContext.repositories, descriptorResult.getRepositories(), true, true);
391
392        // Optimization: try pool cache with the parent manager as a speculative key BEFORE
393        // calling deriveChildManager. When deriveChildManager returns `this` (the common case —
394        // no new management data at this depth), the parent manager IS the child manager, so
395        // this speculative key matches any previously stored entry. On pool hit, we skip
396        // deriveChildManager entirely, saving even the memoization cache lookup.
397        Object speculativeKey = args.pool.toKey(
398                parentContext.dependency.getArtifact(),
399                childRepos,
400                childSelector,
401                parentContext.depManager,
402                childTraverser,
403                childFilter);
404        List<DependencyNode> children = args.pool.getChildren(speculativeKey);
405        if (children != null) {
406            child.setChildren(children);
407            return;
408        }
409
410        // Speculative miss — compute the actual derived manager
411        DependencyManager childManager =
412                parentContext.depManager != null ? parentContext.depManager.deriveChildManager(context) : null;
413
414        Object key;
415        if (childManager == parentContext.depManager) {
416            // Manager unchanged — speculative key was correct, already checked and missed
417            key = speculativeKey;
418        } else {
419            // Manager changed — recompute key and check pool again with the correct manager
420            key = args.pool.toKey(
421                    parentContext.dependency.getArtifact(),
422                    childRepos,
423                    childSelector,
424                    childManager,
425                    childTraverser,
426                    childFilter);
427            children = args.pool.getChildren(key);
428            if (children != null) {
429                child.setChildren(children);
430                return;
431            }
432        }
433
434        // True cache miss — do full resolution
435        boolean skipResolution = args.skipper.skipResolution(child, parentContext.parents);
436        if (!skipResolution) {
437            List<DependencyNode> parents = new ArrayList<>(parentContext.parents.size() + 1);
438            parents.addAll(parentContext.parents);
439            parents.add(child);
440            for (Dependency dependency : descriptorResult.getDependencies()) {
441                if (childSelector != null && !childSelector.selectDependency(dependency)) {
442                    continue;
443                }
444                RequestTrace childTrace =
445                        collectStepTrace(parentContext.trace, args.request.getRequestContext(), parents, dependency);
446                PremanagedDependency premanagedDependency = PremanagedDependency.create(
447                        childManager, dependency, disableVersionManagement, args.premanagedState);
448                DependencyProcessingContext processingContext = new DependencyProcessingContext(
449                        childSelector,
450                        childManager,
451                        childTraverser,
452                        childFilter,
453                        childTrace,
454                        childRepos,
455                        descriptorResult.getManagedDependencies(),
456                        parents,
457                        dependency,
458                        premanagedDependency);
459                // resolve descriptors ahead for managed dependency
460                processingContext.withDependency(processingContext.premanagedDependency.getManagedDependency());
461                resolveArtifactDescriptorAsync(args, processingContext, results);
462                args.dependencyProcessingQueue.add(processingContext);
463            }
464            args.pool.putChildren(key, child.getChildren());
465            args.skipper.cache(child, parents);
466        }
467    }
468
469    private void resolveArtifactDescriptorAsync(Args args, DependencyProcessingContext context, Results results) {
470        Dependency dependency = context.dependency;
471        args.resolver.resolveDescriptors(dependency.getArtifact(), () -> {
472            VersionRangeRequest rangeRequest = createVersionRangeRequest(
473                    args.request.getRequestContext(), context.trace, context.repositories, dependency);
474            VersionRangeResult rangeResult = cachedResolveRangeResult(rangeRequest, args.pool, args.session);
475            List<? extends Version> versions =
476                    filterVersions(dependency, rangeResult, context.verFilter, args.versionContext);
477
478            // resolve newer version first to maximize benefits of skipper
479            Collections.reverse(versions);
480
481            Map<Version, ArtifactDescriptorResult> descriptors = new ConcurrentHashMap<>(versions.size());
482            Stream<? extends Version> stream = versions.size() > 1 ? versions.parallelStream() : versions.stream();
483            stream.forEach(version -> Optional.ofNullable(
484                            resolveDescriptorForVersion(args, context, results, dependency, version))
485                    .ifPresent(r -> descriptors.put(version, r)));
486
487            DescriptorResolutionResult resolutionResult =
488                    new DescriptorResolutionResult(dependency.getArtifact(), rangeResult);
489            // keep original sequence
490            versions.forEach(version -> resolutionResult.descriptors.put(version, descriptors.get(version)));
491            // populate for versions in version range
492            resolutionResult.flatten().forEach(dr -> args.resolver.cacheVersionRangeDescriptor(dr.artifact, dr));
493
494            return resolutionResult;
495        });
496    }
497
498    private ArtifactDescriptorResult resolveDescriptorForVersion(
499            Args args, DependencyProcessingContext context, Results results, Dependency dependency, Version version) {
500        Artifact original = dependency.getArtifact();
501        Artifact newArtifact = original.setVersion(version.toString());
502        Dependency newDependency =
503                new Dependency(newArtifact, dependency.getScope(), dependency.isOptional(), dependency.getExclusions());
504        DependencyProcessingContext newContext = context.copy();
505
506        ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest(
507                args.request.getRequestContext(), context.trace, newContext.repositories, newDependency);
508        return isLackingDescriptor(args.session, newArtifact)
509                ? new ArtifactDescriptorResult(descriptorRequest)
510                : resolveCachedArtifactDescriptor(
511                        args.pool,
512                        descriptorRequest,
513                        args.session,
514                        newContext.withDependency(newDependency).dependency,
515                        results,
516                        context.parents);
517    }
518
519    static class ParallelDescriptorResolver implements Closeable {
520        private final SmartExecutor smartExecutor;
521
522        /**
523         * Artifact ID -> Future of DescriptorResolutionResult
524         */
525        private final Map<String, Future<DescriptorResolutionResult>> results = new ConcurrentHashMap<>(256);
526
527        ParallelDescriptorResolver(SmartExecutor smartExecutor) {
528            this.smartExecutor = smartExecutor;
529        }
530
531        void resolveDescriptors(Artifact artifact, Callable<DescriptorResolutionResult> callable) {
532            results.computeIfAbsent(ArtifactIdUtils.toId(artifact), key -> smartExecutor.submit(callable));
533        }
534
535        void cacheVersionRangeDescriptor(Artifact artifact, DescriptorResolutionResult resolutionResult) {
536            results.computeIfAbsent(
537                    ArtifactIdUtils.toId(artifact), key -> CompletableFuture.completedFuture(resolutionResult));
538        }
539
540        Future<DescriptorResolutionResult> find(Artifact artifact) {
541            return results.get(ArtifactIdUtils.toId(artifact));
542        }
543
544        @Override
545        public void close() {
546            smartExecutor.close();
547        }
548    }
549
550    static class DescriptorResolutionResult {
551        Artifact artifact;
552
553        VersionRangeResult rangeResult;
554
555        Map<Version, ArtifactDescriptorResult> descriptors;
556
557        DescriptorResolutionResult(Artifact artifact, VersionRangeResult rangeResult) {
558            this.artifact = artifact;
559            this.rangeResult = rangeResult;
560            this.descriptors = new LinkedHashMap<>(rangeResult.getVersions().size());
561        }
562
563        DescriptorResolutionResult(
564                VersionRangeResult rangeResult, Version version, ArtifactDescriptorResult descriptor) {
565            // NOTE: In case of A1 -> A2 relocation this happens:
566            // ArtifactDescriptorResult read by ArtifactDescriptorResultReader for A1
567            // will return instance that will have artifact = A2 (as RelocatedArtifact).
568            // So to properly "key" this instance, we need to use "originally requested" A1 instead!
569            // In short:
570            // ArtifactDescriptorRequest.artifact != ArtifactDescriptorResult.artifact WHEN relocation in play
571            // otherwise (no relocation), they are EQUAL.
572            this(descriptor.getRequest().getArtifact(), rangeResult);
573            this.descriptors.put(version, descriptor);
574        }
575
576        List<DescriptorResolutionResult> flatten() {
577            if (descriptors.size() > 1) {
578                return descriptors.entrySet().stream()
579                        .map(e -> new DescriptorResolutionResult(rangeResult, e.getKey(), e.getValue()))
580                        .collect(Collectors.toList());
581            } else {
582                return Collections.emptyList();
583            }
584        }
585    }
586
587    static class Args {
588
589        final RepositorySystemSession session;
590
591        final boolean ignoreRepos;
592
593        final boolean premanagedState;
594
595        final DataPool pool;
596
597        final Queue<DependencyProcessingContext> dependencyProcessingQueue = new ArrayDeque<>(128);
598
599        final AtomicReference<DefaultDependencyCollectionContext> collectionContext;
600
601        final DefaultVersionFilterContext versionContext;
602
603        final CollectRequest request;
604
605        final DependencyResolutionSkipper skipper;
606
607        final ParallelDescriptorResolver resolver;
608
609        final AtomicReference<InterruptedException> interruptedException;
610
611        Args(
612                RepositorySystemSession session,
613                DataPool pool,
614                DefaultDependencyCollectionContext collectionContext,
615                DefaultVersionFilterContext versionContext,
616                CollectRequest request,
617                DependencyResolutionSkipper skipper,
618                ParallelDescriptorResolver resolver) {
619            this.session = session;
620            this.request = request;
621            this.ignoreRepos = session.isIgnoreArtifactDescriptorRepositories();
622            this.premanagedState = ConfigUtils.getBoolean(session, false, DependencyManagerUtils.CONFIG_PROP_VERBOSE);
623            this.pool = pool;
624            this.collectionContext = new AtomicReference<>(collectionContext);
625            this.versionContext = versionContext;
626            this.skipper = skipper;
627            this.resolver = resolver;
628            this.interruptedException = new AtomicReference<>(null);
629        }
630    }
631}