| package org.apache.maven.artifact.versioning; |
| |
| /* |
| * 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.util.StringTokenizer; |
| import java.util.regex.Pattern; |
| import java.util.NoSuchElementException; |
| |
| /** |
| * Default implementation of artifact versioning. |
| * |
| * @author <a href="mailto:brett@apache.org">Brett Porter</a> |
| */ |
| public class DefaultArtifactVersion |
| implements ArtifactVersion |
| { |
| private Integer majorVersion; |
| |
| private Integer minorVersion; |
| |
| private Integer incrementalVersion; |
| |
| private Integer buildNumber; |
| |
| private String qualifier; |
| |
| private ComparableVersion comparable; |
| |
| public DefaultArtifactVersion( String version ) |
| { |
| parseVersion( version ); |
| } |
| |
| @Override |
| public int hashCode() |
| { |
| return 11 + comparable.hashCode(); |
| } |
| |
| @Override |
| public boolean equals( Object other ) |
| { |
| if ( this == other ) |
| { |
| return true; |
| } |
| |
| if ( !( other instanceof ArtifactVersion ) ) |
| { |
| return false; |
| } |
| |
| return compareTo( (ArtifactVersion) other ) == 0; |
| } |
| |
| public int compareTo( ArtifactVersion otherVersion ) |
| { |
| if ( otherVersion instanceof DefaultArtifactVersion ) |
| { |
| return this.comparable.compareTo( ( (DefaultArtifactVersion) otherVersion ).comparable ); |
| } |
| else |
| { |
| return compareTo( new DefaultArtifactVersion( otherVersion.toString() ) ); |
| } |
| } |
| |
| public int getMajorVersion() |
| { |
| return majorVersion != null ? majorVersion : 0; |
| } |
| |
| public int getMinorVersion() |
| { |
| return minorVersion != null ? minorVersion : 0; |
| } |
| |
| public int getIncrementalVersion() |
| { |
| return incrementalVersion != null ? incrementalVersion : 0; |
| } |
| |
| public int getBuildNumber() |
| { |
| return buildNumber != null ? buildNumber : 0; |
| } |
| |
| public String getQualifier() |
| { |
| return qualifier; |
| } |
| |
| public final void parseVersion( String version ) |
| { |
| comparable = new ComparableVersion( version ); |
| |
| int index = version.indexOf( '-' ); |
| |
| String part1; |
| String part2 = null; |
| |
| if ( index < 0 ) |
| { |
| part1 = version; |
| } |
| else |
| { |
| part1 = version.substring( 0, index ); |
| part2 = version.substring( index + 1 ); |
| } |
| |
| if ( part2 != null ) |
| { |
| try |
| { |
| if ( ( part2.length() == 1 ) || !part2.startsWith( "0" ) ) |
| { |
| buildNumber = Integer.valueOf( part2 ); |
| } |
| else |
| { |
| qualifier = part2; |
| } |
| } |
| catch ( NumberFormatException e ) |
| { |
| qualifier = part2; |
| } |
| } |
| |
| if ( ( !part1.contains( "." ) ) && !part1.startsWith( "0" ) ) |
| { |
| try |
| { |
| majorVersion = Integer.valueOf( part1 ); |
| } |
| catch ( NumberFormatException e ) |
| { |
| // qualifier is the whole version, including "-" |
| qualifier = version; |
| buildNumber = null; |
| } |
| } |
| else |
| { |
| boolean fallback = false; |
| |
| StringTokenizer tok = new StringTokenizer( part1, "." ); |
| try |
| { |
| majorVersion = getNextIntegerToken( tok ); |
| if ( tok.hasMoreTokens() ) |
| { |
| minorVersion = getNextIntegerToken( tok ); |
| } |
| if ( tok.hasMoreTokens() ) |
| { |
| incrementalVersion = getNextIntegerToken( tok ); |
| } |
| if ( tok.hasMoreTokens() ) |
| { |
| qualifier = tok.nextToken(); |
| fallback = Pattern.compile( "\\d+" ).matcher( qualifier ).matches(); |
| } |
| |
| // string tokenizer won't detect these and ignores them |
| if ( part1.contains( ".." ) || part1.startsWith( "." ) || part1.endsWith( "." ) ) |
| { |
| fallback = true; |
| } |
| } |
| catch ( NumberFormatException e ) |
| { |
| fallback = true; |
| } |
| |
| if ( fallback ) |
| { |
| // qualifier is the whole version, including "-" |
| qualifier = version; |
| majorVersion = null; |
| minorVersion = null; |
| incrementalVersion = null; |
| buildNumber = null; |
| } |
| } |
| } |
| |
| private static Integer getNextIntegerToken( StringTokenizer tok ) |
| { |
| try |
| { |
| String s = tok.nextToken(); |
| if ( ( s.length() > 1 ) && s.startsWith( "0" ) ) |
| { |
| throw new NumberFormatException( "Number part has a leading 0: '" + s + "'" ); |
| } |
| return Integer.valueOf( s ); |
| } |
| catch ( NoSuchElementException e ) |
| { |
| throw new NumberFormatException( "Number is invalid" ); |
| } |
| } |
| |
| @Override |
| public String toString() |
| { |
| return comparable.toString(); |
| } |
| } |