Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.apache.maven.artifact.DefaultArtifact Maven / Gradle / Ivy
/*
* 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;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.metadata.ArtifactMetadata;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;
import org.apache.maven.artifact.versioning.VersionRange;
import org.codehaus.plexus.util.StringUtils;
/**
* @author Jason van Zyl
*/
public class DefaultArtifact implements Artifact {
private String groupId;
private String artifactId;
private String baseVersion;
private final String type;
private final String classifier;
private volatile String scope;
private volatile File file;
private ArtifactRepository repository;
private String downloadUrl;
private ArtifactFilter dependencyFilter;
private ArtifactHandler artifactHandler;
private List dependencyTrail;
private volatile String version;
private VersionRange versionRange;
private volatile boolean resolved;
private boolean release;
private List availableVersions;
private Map metadataMap;
private boolean optional;
public DefaultArtifact(
String groupId,
String artifactId,
String version,
String scope,
String type,
String classifier,
ArtifactHandler artifactHandler) {
this(
groupId,
artifactId,
VersionRange.createFromVersion(version),
scope,
type,
classifier,
artifactHandler,
false);
}
public DefaultArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String scope,
String type,
String classifier,
ArtifactHandler artifactHandler) {
this(groupId, artifactId, versionRange, scope, type, classifier, artifactHandler, false);
}
@SuppressWarnings("checkstyle:parameternumber")
public DefaultArtifact(
String groupId,
String artifactId,
VersionRange versionRange,
String scope,
String type,
String classifier,
ArtifactHandler artifactHandler,
boolean optional) {
this.groupId = groupId;
this.artifactId = artifactId;
this.versionRange = versionRange;
selectVersionFromNewRangeIfAvailable();
this.artifactHandler = artifactHandler;
this.scope = scope;
this.type = type;
if (classifier == null) {
classifier = artifactHandler.getClassifier();
}
this.classifier = classifier;
this.optional = optional;
validateIdentity();
}
private void validateIdentity() {
if (empty(groupId)) {
throw new InvalidArtifactRTException(
groupId, artifactId, getVersion(), type, "The groupId cannot be empty.");
}
if (artifactId == null) {
throw new InvalidArtifactRTException(
groupId, artifactId, getVersion(), type, "The artifactId cannot be empty.");
}
if (type == null) {
throw new InvalidArtifactRTException(groupId, artifactId, getVersion(), type, "The type cannot be empty.");
}
if ((version == null) && (versionRange == null)) {
throw new InvalidArtifactRTException(
groupId, artifactId, getVersion(), type, "The version cannot be empty.");
}
}
private boolean empty(String value) {
return (value == null) || (value.trim().length() < 1);
}
public String getClassifier() {
return classifier;
}
public boolean hasClassifier() {
return StringUtils.isNotEmpty(classifier);
}
public String getScope() {
return scope;
}
public String getGroupId() {
return groupId;
}
public String getArtifactId() {
return artifactId;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
setBaseVersionInternal(version);
versionRange = null;
}
public String getType() {
return type;
}
public void setFile(File file) {
this.file = file;
}
public File getFile() {
return file;
}
public ArtifactRepository getRepository() {
return repository;
}
public void setRepository(ArtifactRepository repository) {
this.repository = repository;
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public String getId() {
return getDependencyConflictId() + ":" + getBaseVersion();
}
public String getDependencyConflictId() {
StringBuilder sb = new StringBuilder(128);
sb.append(getGroupId());
sb.append(':');
appendArtifactTypeClassifierString(sb);
return sb.toString();
}
private void appendArtifactTypeClassifierString(StringBuilder sb) {
sb.append(getArtifactId());
sb.append(':');
sb.append(getType());
if (hasClassifier()) {
sb.append(':');
sb.append(getClassifier());
}
}
public void addMetadata(ArtifactMetadata metadata) {
if (metadataMap == null) {
metadataMap = new HashMap<>();
}
ArtifactMetadata m = metadataMap.get(metadata.getKey());
if (m != null) {
m.merge(metadata);
} else {
metadataMap.put(metadata.getKey(), metadata);
}
}
public Collection getMetadataList() {
if (metadataMap == null) {
return Collections.emptyList();
}
return Collections.unmodifiableCollection(metadataMap.values());
}
// ----------------------------------------------------------------------
// Object overrides
// ----------------------------------------------------------------------
public String toString() {
StringBuilder sb = new StringBuilder();
if (getGroupId() != null) {
sb.append(getGroupId());
sb.append(':');
}
appendArtifactTypeClassifierString(sb);
sb.append(':');
if (getBaseVersionInternal() != null) {
sb.append(getBaseVersionInternal());
} else {
sb.append(versionRange.toString());
}
if (scope != null) {
sb.append(':');
sb.append(scope);
}
return sb.toString();
}
public int hashCode() {
int result = 17;
result = 37 * result + groupId.hashCode();
result = 37 * result + artifactId.hashCode();
result = 37 * result + type.hashCode();
if (version != null) {
result = 37 * result + version.hashCode();
}
result = 37 * result + (classifier != null ? classifier.hashCode() : 0);
return result;
}
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof Artifact)) {
return false;
}
Artifact a = (Artifact) o;
if (!a.getGroupId().equals(groupId)) {
return false;
} else if (!a.getArtifactId().equals(artifactId)) {
return false;
} else if (!a.getVersion().equals(version)) {
return false;
} else if (!a.getType().equals(type)) {
return false;
} else if (a.getClassifier() == null
? classifier != null
: !a.getClassifier().equals(classifier)) {
return false;
}
// We don't consider the version range in the comparison, just the resolved version
return true;
}
public String getBaseVersion() {
if (baseVersion == null && version != null) {
setBaseVersionInternal(version);
}
return baseVersion;
}
protected String getBaseVersionInternal() {
if ((baseVersion == null) && (version != null)) {
setBaseVersionInternal(version);
}
return baseVersion;
}
public void setBaseVersion(String baseVersion) {
setBaseVersionInternal(baseVersion);
}
protected void setBaseVersionInternal(String baseVersion) {
this.baseVersion = ArtifactUtils.toSnapshotVersion(baseVersion);
}
public int compareTo(Artifact a) {
int result = groupId.compareTo(a.getGroupId());
if (result == 0) {
result = artifactId.compareTo(a.getArtifactId());
if (result == 0) {
result = type.compareTo(a.getType());
if (result == 0) {
if (classifier == null) {
if (a.getClassifier() != null) {
result = 1;
}
} else {
if (a.getClassifier() != null) {
result = classifier.compareTo(a.getClassifier());
} else {
result = -1;
}
}
if (result == 0) {
// We don't consider the version range in the comparison, just the resolved version
result = new DefaultArtifactVersion(version)
.compareTo(new DefaultArtifactVersion(a.getVersion()));
}
}
}
}
return result;
}
public void updateVersion(String version, ArtifactRepository localRepository) {
setResolvedVersion(version);
setFile(new File(localRepository.getBasedir(), localRepository.pathOf(this)));
}
public String getDownloadUrl() {
return downloadUrl;
}
public void setDownloadUrl(String downloadUrl) {
this.downloadUrl = downloadUrl;
}
public ArtifactFilter getDependencyFilter() {
return dependencyFilter;
}
public void setDependencyFilter(ArtifactFilter artifactFilter) {
dependencyFilter = artifactFilter;
}
public ArtifactHandler getArtifactHandler() {
return artifactHandler;
}
public List getDependencyTrail() {
return dependencyTrail;
}
public void setDependencyTrail(List dependencyTrail) {
this.dependencyTrail = dependencyTrail;
}
public void setScope(String scope) {
this.scope = scope;
}
public VersionRange getVersionRange() {
return versionRange;
}
public void setVersionRange(VersionRange versionRange) {
this.versionRange = versionRange;
selectVersionFromNewRangeIfAvailable();
}
private void selectVersionFromNewRangeIfAvailable() {
if ((versionRange != null) && (versionRange.getRecommendedVersion() != null)) {
selectVersion(versionRange.getRecommendedVersion().toString());
} else {
version = null;
baseVersion = null;
}
}
public void selectVersion(String version) {
this.version = version;
setBaseVersionInternal(version);
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public void setArtifactId(String artifactId) {
this.artifactId = artifactId;
}
public boolean isSnapshot() {
return getBaseVersion() != null
&& (getBaseVersion().endsWith(SNAPSHOT_VERSION)
|| getBaseVersion().equals(LATEST_VERSION));
}
public void setResolved(boolean resolved) {
this.resolved = resolved;
}
public boolean isResolved() {
return resolved;
}
public void setResolvedVersion(String version) {
this.version = version;
// retain baseVersion
}
public void setArtifactHandler(ArtifactHandler artifactHandler) {
this.artifactHandler = artifactHandler;
}
public void setRelease(boolean release) {
this.release = release;
}
public boolean isRelease() {
return release;
}
public List getAvailableVersions() {
return availableVersions;
}
public void setAvailableVersions(List availableVersions) {
this.availableVersions = availableVersions;
}
public boolean isOptional() {
return optional;
}
public ArtifactVersion getSelectedVersion() throws OverConstrainedVersionException {
return versionRange.getSelectedVersion(this);
}
public boolean isSelectedVersionKnown() throws OverConstrainedVersionException {
return versionRange.isSelectedVersionKnown(this);
}
public void setOptional(boolean optional) {
this.optional = optional;
}
}
