compiler/src/main/java/org/apache/royale/utils/Version.java

/*
 *
 *  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.royale.utils;

/**
 * Represents a four-part version number, such as <code>4.5.12.12345</code>.
 * <p>
 * The second, third, and fourth parts, representing a minor version, 
 * a bug-fix version, and a build version, are optional.
 * When comparing versions, a missing part is considered to be 0.
 */
public class Version implements Comparable<Version>
{
    /**
     * Compares two possibly-null Integer values,
     * considering a null Integer to be 0.
     */
    private static int cmp(Integer i1, Integer i2)
    {
        // For comparison purposes, consider a null Integer to be 0.
        int j1 = i1 != null ? i1 : 0;
        int j2 = i2 != null ? i2 : 0;
        
        if (j1 > j2)
            return 1;
        else if (j1 < j2)
            return -1;
        
        return 0;
    }
    
    /**
     * Constructs a new <code>Version</code> instance with all four parts.
     * 
     * @param major The major version number.
     * @param minor The minor version number.
     * @param bugFix The bug-fix version number.
     * @param build The build version number or <code>null</code>.
     */
    public Version(Integer major, Integer minor, Integer bugFix, Integer build)
    {
        assert major >= 0 : "major version number cannot be negative";
        assert minor == null || minor >= 0 : "minor version number cannot be negative";
        assert bugFix == null || bugFix >= 0 : "bugFix version number cannot be negative";
        assert build == null || build >= 0 : "build version number cannot be negative";
        
        this.major = major;
        this.minor = minor;
        this.bugFix = bugFix;
        this.build = build;        
    }
    
    /**
     * Constructs a new <code>Version</code> instance with three parts.
     * 
     * @param major The major version number.
     * @param minor The minor version number or <code>null</code>.
     * @param bugFix The bug-fix version number or <code>null</code>.
     */
    public Version(int major, int minor, int bugFix)
    {
        this(major, minor, bugFix, null);
    }
    
    /**
     * Constructs a new <code>Version</code> instance with two parts.
     * 
     * @param major The major version number.
     * @param minor The minor version number or <code>null</code>.
     */
    public Version(int major, int minor)
    {
        this(major, minor, null, null);
    }
    
    /**
     * Constructs a new <code>Version</code> instance with one part.
     * 
     * @param major The major version number.
     */
    public Version(int major)
    {
        this(major, null, null, null);
    }
    
    /**
     * Constructs a new <code>Version</code> instance from a
     * one-, two-, three-, or four-part dotted version string.
     */
    public Version(String versionString)
    {
        this(versionString.split("\\."));
    }
    
    private Version(String[] parts)
    {
        int n = parts.length;
        assert 1 <= n && n <= 4 : "version string should have 1-4 parts";
        
        this.major = Integer.parseInt(parts[0]);
        this.minor = n >= 2 ? Integer.parseInt(parts[1]) : null;
        this.bugFix = n >= 3 ? Integer.parseInt(parts[2]) : null;
        this.build = n == 4 ? Integer.parseInt(parts[3]) : null;
    }
    
    private final Integer major;
    private final Integer minor;
    private final Integer bugFix;
    private final Integer build;
    
    @Override
    public String toString()
    {
        return getDisplayString();
    }

    @Override
    public int compareTo(Version other)
    {
        int compareBugFix = compareBugFixVersionTo(other);
        if (compareBugFix != 0)
            return compareBugFix;
        
        return cmp(build, other.build);
    }
    
    /**
     * Gets the major version number.
     * 
     * @return An <code>Integer</code> for the major version.
     */
    public Integer getMajor()
    {
        return major;
    }
    
    /**
     * Gets the minor version number number.
     * 
     * @return An <code>Integer</code> for the minor version or <code>null</code>.
     */
    public Integer getMinor()
    {
        return minor;
    }
    
    /**
     * Gets the bug-fix version number.
     * 
     * @return An <code>Integer</code> for the bug-fix version or <code>null</code>.
     */
    public Integer getBugFix()
    {
        return bugFix;
    }
    
    /**
     * Gets the build version number.
     * 
     * @return An <code>Integer</code> for the build version or <code>null</code>.
     */
    public Integer getBuild()
    {
        return build;
    }
    
    /**
     * Converts this <code>Version<code> to a string for display.
     * <p>
     * Null parts of the version are not displayed.
     * 
     * @return A String such as <code>"1.2"</code>.
     */
    public String getDisplayString()
    {
        StringBuilder sb = new StringBuilder();
        
        sb.append(major);
        
        if (minor != null)
        {
            sb.append('.');
            sb.append(minor);
        }
        
        if (bugFix != null)
        {
            sb.append('.');
            sb.append(bugFix);
        }
        
        if (build != null)
        {
            sb.append('.');
            sb.append(build);
        }
        
        return sb.toString();
    }
 
    /**
     * Compares this <code>Version</code> to another,
     * considering only the major part.
     * 
     * @param other Another <code>Version</code> object.
     * @return 1 if greater, -1 if lesser, 0 if equal
     */
    public int compareMajorVersionTo(Version other)
    {
        return cmp(major, other.major);
    }
    
    /**
     * Compares this <code>Version</code> to another,
     * considering only the major and minor parts.
     * 
     * @param other Another <code>Version</code> object.
     * @return 1 if greater, -1 if lesser, 0 if equal
     */
    public int compareMinorVersionTo(Version other)
    {
        int compareMajor = compareMajorVersionTo(other);
        if (compareMajor != 0)
            return compareMajor;
        
        return cmp(minor, other.minor);
    }
    
    /**
     * Compares this <code>Version</code> to another,
     * considering only the major, minor, and bug-fix parts.
     * 
     * @param other Another <code>Version</code> object.
     * @return 1 if greater, -1 if lesser, 0 if equal
     */
    public int compareBugFixVersionTo(Version other)
    {
        int compareMinor = compareMinorVersionTo(other);
        if (compareMinor != 0)
            return compareMinor;
        
        return cmp(bugFix, other.bugFix);
    }
}