Java tutorial
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.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.WeakHashMap; import java.util.Objects; import org.apache.maven.artifact.Artifact; /** * Construct a version range from a specification. * * @author <a href="mailto:brett@apache.org">Brett Porter</a> */ public class VersionRange { private static final Map<String, VersionRange> CACHE_SPEC = Collections .<String, VersionRange>synchronizedMap(new WeakHashMap<String, VersionRange>()); private static final Map<String, VersionRange> CACHE_VERSION = Collections .<String, VersionRange>synchronizedMap(new WeakHashMap<String, VersionRange>()); private final ArtifactVersion recommendedVersion; private final List<Restriction> restrictions; private VersionRange(ArtifactVersion recommendedVersion, List<Restriction> restrictions) { this.recommendedVersion = recommendedVersion; this.restrictions = restrictions; } public ArtifactVersion getRecommendedVersion() { return recommendedVersion; } public List<Restriction> getRestrictions() { return restrictions; } /** * @deprecated VersionRange is immutable, cloning is not useful and even more an issue against the cache * @return a clone */ @Deprecated public VersionRange cloneOf() { List<Restriction> copiedRestrictions = null; if (restrictions != null) { copiedRestrictions = new ArrayList<>(); if (!restrictions.isEmpty()) { copiedRestrictions.addAll(restrictions); } } return new VersionRange(recommendedVersion, copiedRestrictions); } /** * <p> * Create a version range from a string representation * </p> * Some spec examples are: * <ul> * <li><code>1.0</code> Version 1.0</li> * <li><code>[1.0,2.0)</code> Versions 1.0 (included) to 2.0 (not included)</li> * <li><code>[1.0,2.0]</code> Versions 1.0 to 2.0 (both included)</li> * <li><code>[1.5,)</code> Versions 1.5 and higher</li> * <li><code>(,1.0],[1.2,)</code> Versions up to 1.0 (included) and 1.2 or higher</li> * </ul> * * @param spec string representation of a version or version range * @return a new {@link VersionRange} object that represents the spec * @throws InvalidVersionSpecificationException * */ public static VersionRange createFromVersionSpec(String spec) throws InvalidVersionSpecificationException { if (spec == null) { return null; } VersionRange cached = CACHE_SPEC.get(spec); if (cached != null) { return cached; } List<Restriction> restrictions = new ArrayList<>(); String process = spec; ArtifactVersion version = null; ArtifactVersion upperBound = null; ArtifactVersion lowerBound = null; while (process.startsWith("[") || process.startsWith("(")) { int index1 = process.indexOf(')'); int index2 = process.indexOf(']'); int index = index2; if (index2 < 0 || index1 < index2) { if (index1 >= 0) { index = index1; } } if (index < 0) { throw new InvalidVersionSpecificationException("Unbounded range: " + spec); } Restriction restriction = parseRestriction(process.substring(0, index + 1)); if (lowerBound == null) { lowerBound = restriction.getLowerBound(); } if (upperBound != null) { if (restriction.getLowerBound() == null || restriction.getLowerBound().compareTo(upperBound) < 0) { throw new InvalidVersionSpecificationException("Ranges overlap: " + spec); } } restrictions.add(restriction); upperBound = restriction.getUpperBound(); process = process.substring(index + 1).trim(); if (process.length() > 0 && process.startsWith(",")) { process = process.substring(1).trim(); } } if (process.length() > 0) { if (restrictions.size() > 0) { throw new InvalidVersionSpecificationException( "Only fully-qualified sets allowed in multiple set scenario: " + spec); } else { version = new DefaultArtifactVersion(process); restrictions.add(Restriction.EVERYTHING); } } cached = new VersionRange(version, restrictions); CACHE_SPEC.put(spec, cached); return cached; } private static Restriction parseRestriction(String spec) throws InvalidVersionSpecificationException { boolean lowerBoundInclusive = spec.startsWith("["); boolean upperBoundInclusive = spec.endsWith("]"); String process = spec.substring(1, spec.length() - 1).trim(); Restriction restriction; int index = process.indexOf(','); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new InvalidVersionSpecificationException("Single version must be surrounded by []: " + spec); } ArtifactVersion version = new DefaultArtifactVersion(process); restriction = new Restriction(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new InvalidVersionSpecificationException("Range cannot have identical boundaries: " + spec); } ArtifactVersion lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = new DefaultArtifactVersion(lowerBound); } ArtifactVersion upperVersion = null; if (upperBound.length() > 0) { upperVersion = new DefaultArtifactVersion(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new InvalidVersionSpecificationException("Range defies version ordering: " + spec); } restriction = new Restriction(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return restriction; } public static VersionRange createFromVersion(String version) { VersionRange cached = CACHE_VERSION.get(version); if (cached == null) { List<Restriction> restrictions = Collections.emptyList(); cached = new VersionRange(new DefaultArtifactVersion(version), restrictions); CACHE_VERSION.put(version, cached); } return cached; } /** * Creates and returns a new <code>VersionRange</code> that is a restriction of this * version range and the specified version range. * <p> * Note: Precedence is given to the recommended version from this version range over the * recommended version from the specified version range. * </p> * * @param restriction the <code>VersionRange</code> that will be used to restrict this version * range. * @return the <code>VersionRange</code> that is a restriction of this version range and the * specified version range. * <p> * The restrictions of the returned version range will be an intersection of the restrictions * of this version range and the specified version range if both version ranges have * restrictions. Otherwise, the restrictions on the returned range will be empty. * </p> * <p> * The recommended version of the returned version range will be the recommended version of * this version range, provided that ranges falls within the intersected restrictions. If * the restrictions are empty, this version range's recommended version is used if it is not * <code>null</code>. If it is <code>null</code>, the specified version range's recommended * version is used (provided it is non-<code>null</code>). If no recommended version can be * obtained, the returned version range's recommended version is set to <code>null</code>. * </p> * @throws NullPointerException if the specified <code>VersionRange</code> is * <code>null</code>. */ public VersionRange restrict(VersionRange restriction) { List<Restriction> r1 = this.restrictions; List<Restriction> r2 = restriction.restrictions; List<Restriction> restrictions; if (r1.isEmpty() || r2.isEmpty()) { restrictions = Collections.emptyList(); } else { restrictions = Collections.unmodifiableList(intersection(r1, r2)); } ArtifactVersion version = null; if (restrictions.size() > 0) { for (Restriction r : restrictions) { if (recommendedVersion != null && r.containsVersion(recommendedVersion)) { // if we find the original, use that version = recommendedVersion; break; } else if (version == null && restriction.getRecommendedVersion() != null && r.containsVersion(restriction.getRecommendedVersion())) { // use this if we can, but prefer the original if possible version = restriction.getRecommendedVersion(); } } } // Either the original or the specified version ranges have no restrictions else if (recommendedVersion != null) { // Use the original recommended version since it exists version = recommendedVersion; } else if (restriction.recommendedVersion != null) { // Use the recommended version from the specified VersionRange since there is no // original recommended version version = restriction.recommendedVersion; } /* TODO should throw this immediately, but need artifact else { throw new OverConstrainedVersionException( "Restricting incompatible version ranges" ); } */ return new VersionRange(version, restrictions); } private List<Restriction> intersection(List<Restriction> r1, List<Restriction> r2) { List<Restriction> restrictions = new ArrayList<>(r1.size() + r2.size()); Iterator<Restriction> i1 = r1.iterator(); Iterator<Restriction> i2 = r2.iterator(); Restriction res1 = i1.next(); Restriction res2 = i2.next(); boolean done = false; while (!done) { if (res1.getLowerBound() == null || res2.getUpperBound() == null || res1.getLowerBound().compareTo(res2.getUpperBound()) <= 0) { if (res1.getUpperBound() == null || res2.getLowerBound() == null || res1.getUpperBound().compareTo(res2.getLowerBound()) >= 0) { ArtifactVersion lower; ArtifactVersion upper; boolean lowerInclusive; boolean upperInclusive; // overlaps if (res1.getLowerBound() == null) { lower = res2.getLowerBound(); lowerInclusive = res2.isLowerBoundInclusive(); } else if (res2.getLowerBound() == null) { lower = res1.getLowerBound(); lowerInclusive = res1.isLowerBoundInclusive(); } else { int comparison = res1.getLowerBound().compareTo(res2.getLowerBound()); if (comparison < 0) { lower = res2.getLowerBound(); lowerInclusive = res2.isLowerBoundInclusive(); } else if (comparison == 0) { lower = res1.getLowerBound(); lowerInclusive = res1.isLowerBoundInclusive() && res2.isLowerBoundInclusive(); } else { lower = res1.getLowerBound(); lowerInclusive = res1.isLowerBoundInclusive(); } } if (res1.getUpperBound() == null) { upper = res2.getUpperBound(); upperInclusive = res2.isUpperBoundInclusive(); } else if (res2.getUpperBound() == null) { upper = res1.getUpperBound(); upperInclusive = res1.isUpperBoundInclusive(); } else { int comparison = res1.getUpperBound().compareTo(res2.getUpperBound()); if (comparison < 0) { upper = res1.getUpperBound(); upperInclusive = res1.isUpperBoundInclusive(); } else if (comparison == 0) { upper = res1.getUpperBound(); upperInclusive = res1.isUpperBoundInclusive() && res2.isUpperBoundInclusive(); } else { upper = res2.getUpperBound(); upperInclusive = res2.isUpperBoundInclusive(); } } // don't add if they are equal and one is not inclusive if (lower == null || upper == null || lower.compareTo(upper) != 0) { restrictions.add(new Restriction(lower, lowerInclusive, upper, upperInclusive)); } else if (lowerInclusive && upperInclusive) { restrictions.add(new Restriction(lower, lowerInclusive, upper, upperInclusive)); } //noinspection ObjectEquality if (upper == res2.getUpperBound()) { // advance res2 if (i2.hasNext()) { res2 = i2.next(); } else { done = true; } } else { // advance res1 if (i1.hasNext()) { res1 = i1.next(); } else { done = true; } } } else { // move on to next in r1 if (i1.hasNext()) { res1 = i1.next(); } else { done = true; } } } else { // move on to next in r2 if (i2.hasNext()) { res2 = i2.next(); } else { done = true; } } } return restrictions; } public ArtifactVersion getSelectedVersion(Artifact artifact) throws OverConstrainedVersionException { ArtifactVersion version; if (recommendedVersion != null) { version = recommendedVersion; } else { if (restrictions.size() == 0) { throw new OverConstrainedVersionException("The artifact has no valid ranges", artifact); } version = null; } return version; } public boolean isSelectedVersionKnown(Artifact artifact) throws OverConstrainedVersionException { boolean value = false; if (recommendedVersion != null) { value = true; } else { if (restrictions.size() == 0) { throw new OverConstrainedVersionException("The artifact has no valid ranges", artifact); } } return value; } public String toString() { if (recommendedVersion != null) { return recommendedVersion.toString(); } else { StringBuilder buf = new StringBuilder(); for (Iterator<Restriction> i = restrictions.iterator(); i.hasNext();) { Restriction r = i.next(); buf.append(r.toString()); if (i.hasNext()) { buf.append(','); } } return buf.toString(); } } public ArtifactVersion matchVersion(List<ArtifactVersion> versions) { // TODO could be more efficient by sorting the list and then moving along the restrictions in order? ArtifactVersion matched = null; for (ArtifactVersion version : versions) { if (containsVersion(version)) { // valid - check if it is greater than the currently matched version if (matched == null || version.compareTo(matched) > 0) { matched = version; } } } return matched; } public boolean containsVersion(ArtifactVersion version) { for (Restriction restriction : restrictions) { if (restriction.containsVersion(version)) { return true; } } return false; } public boolean hasRestrictions() { return !restrictions.isEmpty() && recommendedVersion == null; } public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof VersionRange)) { return false; } VersionRange other = (VersionRange) obj; return Objects.equals(recommendedVersion, other.recommendedVersion) && Objects.equals(restrictions, other.restrictions); } public int hashCode() { int hash = 7; hash = 31 * hash + (recommendedVersion == null ? 0 : recommendedVersion.hashCode()); hash = 31 * hash + (restrictions == null ? 0 : restrictions.hashCode()); return hash; } }