diff options
Diffstat (limited to 'framework/src/maven/apache-maven-3.3.3/maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java')
| -rw-r--r-- | framework/src/maven/apache-maven-3.3.3/maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java | 597 |
1 files changed, 597 insertions, 0 deletions
diff --git a/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java new file mode 100644 index 00000000..e3e42c0a --- /dev/null +++ b/framework/src/maven/apache-maven-3.3.3/maven-artifact/src/main/java/org/apache/maven/artifact/DefaultArtifact.java @@ -0,0 +1,597 @@ +package org.apache.maven.artifact; + +/* + * 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. + */ + +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 java.util.regex.Matcher; + +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<String> dependencyTrail; + + private volatile String version; + + private VersionRange versionRange; + + private volatile boolean resolved; + + private boolean release; + + private List<ArtifactVersion> availableVersions; + + private Map<Object, ArtifactMetadata> 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 ); + } + + 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<Object, ArtifactMetadata>(); + } + + ArtifactMetadata m = metadataMap.get( metadata.getKey() ); + if ( m != null ) + { + m.merge( metadata ); + } + else + { + metadataMap.put( metadata.getKey(), metadata ); + } + } + + public Collection<ArtifactMetadata> getMetadataList() + { + if ( metadataMap == null ) + { + return Collections.emptyList(); + } + + return 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 ) + { + Matcher m = VERSION_FILE_PATTERN.matcher( baseVersion ); + + if ( m.matches() ) + { + this.baseVersion = m.group( 1 ) + "-" + SNAPSHOT_VERSION; + } + else + { + this.baseVersion = 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<String> getDependencyTrail() + { + return dependencyTrail; + } + + public void setDependencyTrail( List<String> 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<ArtifactVersion> getAvailableVersions() + { + return availableVersions; + } + + public void setAvailableVersions( List<ArtifactVersion> 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; + } + +} |