| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.maven.artifact.resolver; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.maven.artifact.Artifact; |
| import org.apache.maven.artifact.repository.ArtifactRepository; |
| import org.apache.maven.artifact.versioning.OverConstrainedVersionException; |
| |
| /** |
| * Specific problems during resolution that we want to account for: |
| * <ul> |
| * <li>missing metadata</li> |
| * <li>version range violations</li> |
| * <li>version circular dependencies</li> |
| * <li>missing artifacts</li> |
| * <li>network/transfer errors</li> |
| * <li>file system errors: permissions</li> |
| * </ul> |
| * |
| * TODO carlos: all these possible has*Exceptions and get*Exceptions methods make the clients too |
| * complex requiring a long list of checks, need to create a parent/interface/encapsulation |
| * for the types of exceptions |
| */ |
| @Deprecated |
| public class ArtifactResolutionResult { |
| private static final String LS = System.lineSeparator(); |
| |
| private Artifact originatingArtifact; |
| |
| private List<Artifact> missingArtifacts; |
| |
| // Exceptions |
| |
| private List<Exception> exceptions; |
| |
| private List<Exception> versionRangeViolations; |
| |
| private List<ArtifactResolutionException> metadataResolutionExceptions; |
| |
| private List<CyclicDependencyException> circularDependencyExceptions; |
| |
| private List<ArtifactResolutionException> errorArtifactExceptions; |
| |
| // file system errors |
| |
| private List<ArtifactRepository> repositories; |
| |
| private Set<Artifact> artifacts; |
| |
| private Set<ResolutionNode> resolutionNodes; |
| |
| public Artifact getOriginatingArtifact() { |
| return originatingArtifact; |
| } |
| |
| public ArtifactResolutionResult setOriginatingArtifact(final Artifact originatingArtifact) { |
| this.originatingArtifact = originatingArtifact; |
| |
| return this; |
| } |
| |
| public void addArtifact(Artifact artifact) { |
| if (artifacts == null) { |
| artifacts = new LinkedHashSet<>(); |
| } |
| |
| artifacts.add(artifact); |
| } |
| |
| public Set<Artifact> getArtifacts() { |
| if (artifacts == null) { |
| artifacts = new LinkedHashSet<>(); |
| } |
| |
| return artifacts; |
| } |
| |
| public void setArtifacts(Set<Artifact> artifacts) { |
| this.artifacts = artifacts; |
| } |
| |
| public Set<ResolutionNode> getArtifactResolutionNodes() { |
| if (resolutionNodes == null) { |
| resolutionNodes = new LinkedHashSet<>(); |
| } |
| |
| return resolutionNodes; |
| } |
| |
| public void setArtifactResolutionNodes(Set<ResolutionNode> resolutionNodes) { |
| this.resolutionNodes = resolutionNodes; |
| } |
| |
| public boolean hasMissingArtifacts() { |
| return missingArtifacts != null && !missingArtifacts.isEmpty(); |
| } |
| |
| public List<Artifact> getMissingArtifacts() { |
| return missingArtifacts == null ? Collections.emptyList() : Collections.unmodifiableList(missingArtifacts); |
| } |
| |
| public ArtifactResolutionResult addMissingArtifact(Artifact artifact) { |
| missingArtifacts = initList(missingArtifacts); |
| |
| missingArtifacts.add(artifact); |
| |
| return this; |
| } |
| |
| public ArtifactResolutionResult setUnresolvedArtifacts(final List<Artifact> unresolvedArtifacts) { |
| this.missingArtifacts = unresolvedArtifacts; |
| |
| return this; |
| } |
| |
| public boolean isSuccess() { |
| return !(hasMissingArtifacts() || hasExceptions()); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Exceptions |
| // ------------------------------------------------------------------------ |
| |
| public boolean hasExceptions() { |
| return exceptions != null && !exceptions.isEmpty(); |
| } |
| |
| public List<Exception> getExceptions() { |
| return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Version Range Violations |
| // ------------------------------------------------------------------------ |
| |
| public boolean hasVersionRangeViolations() { |
| return versionRangeViolations != null; |
| } |
| |
| /** |
| * TODO this needs to accept a {@link OverConstrainedVersionException} as returned by |
| * {@link #getVersionRangeViolation(int)} but it's not used like that in |
| * DefaultLegacyArtifactCollector |
| * |
| * @param e an exception |
| * @return {@code this} |
| */ |
| public ArtifactResolutionResult addVersionRangeViolation(Exception e) { |
| versionRangeViolations = initList(versionRangeViolations); |
| |
| versionRangeViolations.add(e); |
| |
| exceptions = initList(exceptions); |
| |
| exceptions.add(e); |
| |
| return this; |
| } |
| |
| public OverConstrainedVersionException getVersionRangeViolation(int i) { |
| return (OverConstrainedVersionException) versionRangeViolations.get(i); |
| } |
| |
| public List<Exception> getVersionRangeViolations() { |
| return versionRangeViolations == null |
| ? Collections.emptyList() |
| : Collections.unmodifiableList(versionRangeViolations); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Metadata Resolution Exceptions: ArtifactResolutionExceptions |
| // ------------------------------------------------------------------------ |
| |
| public boolean hasMetadataResolutionExceptions() { |
| return metadataResolutionExceptions != null; |
| } |
| |
| public ArtifactResolutionResult addMetadataResolutionException(ArtifactResolutionException e) { |
| metadataResolutionExceptions = initList(metadataResolutionExceptions); |
| |
| metadataResolutionExceptions.add(e); |
| |
| exceptions = initList(exceptions); |
| |
| exceptions.add(e); |
| |
| return this; |
| } |
| |
| public ArtifactResolutionException getMetadataResolutionException(int i) { |
| return metadataResolutionExceptions.get(i); |
| } |
| |
| public List<ArtifactResolutionException> getMetadataResolutionExceptions() { |
| return metadataResolutionExceptions == null |
| ? Collections.emptyList() |
| : Collections.unmodifiableList(metadataResolutionExceptions); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // ErrorArtifactExceptions: ArtifactResolutionExceptions |
| // ------------------------------------------------------------------------ |
| |
| public boolean hasErrorArtifactExceptions() { |
| return errorArtifactExceptions != null; |
| } |
| |
| public ArtifactResolutionResult addErrorArtifactException(ArtifactResolutionException e) { |
| errorArtifactExceptions = initList(errorArtifactExceptions); |
| |
| errorArtifactExceptions.add(e); |
| |
| exceptions = initList(exceptions); |
| |
| exceptions.add(e); |
| |
| return this; |
| } |
| |
| public List<ArtifactResolutionException> getErrorArtifactExceptions() { |
| if (errorArtifactExceptions == null) { |
| return Collections.emptyList(); |
| } |
| |
| return Collections.unmodifiableList(errorArtifactExceptions); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Circular Dependency Exceptions |
| // ------------------------------------------------------------------------ |
| |
| public boolean hasCircularDependencyExceptions() { |
| return circularDependencyExceptions != null; |
| } |
| |
| public ArtifactResolutionResult addCircularDependencyException(CyclicDependencyException e) { |
| circularDependencyExceptions = initList(circularDependencyExceptions); |
| |
| circularDependencyExceptions.add(e); |
| |
| exceptions = initList(exceptions); |
| |
| exceptions.add(e); |
| |
| return this; |
| } |
| |
| public CyclicDependencyException getCircularDependencyException(int i) { |
| return circularDependencyExceptions.get(i); |
| } |
| |
| public List<CyclicDependencyException> getCircularDependencyExceptions() { |
| if (circularDependencyExceptions == null) { |
| return Collections.emptyList(); |
| } |
| |
| return Collections.unmodifiableList(circularDependencyExceptions); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Repositories |
| // ------------------------------------------------------------------------ |
| |
| public List<ArtifactRepository> getRepositories() { |
| if (repositories == null) { |
| return Collections.emptyList(); |
| } |
| |
| return Collections.unmodifiableList(repositories); |
| } |
| |
| public ArtifactResolutionResult setRepositories(final List<ArtifactRepository> repositories) { |
| this.repositories = repositories; |
| |
| return this; |
| } |
| |
| // |
| // Internal |
| // |
| |
| private <T> List<T> initList(final List<T> l) { |
| if (l == null) { |
| return new ArrayList<>(); |
| } |
| return l; |
| } |
| |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| |
| if (artifacts != null) { |
| int i = 1; |
| sb.append("---------").append(LS); |
| sb.append(artifacts.size()).append(LS); |
| for (Artifact a : artifacts) { |
| sb.append(i).append(' ').append(a).append(LS); |
| i++; |
| } |
| sb.append("---------"); |
| } |
| |
| return sb.toString(); |
| } |
| } |