Xcode versions are formed of multiple components, separated by periods, for example {@code * 4.5.6} or {@code 5.0.1beta2}. Components must start with a non-negative integer and at least one * component must be present. * *
Specifically, the format of a component is {@code \d+([a-z0-9]*?)?(\d+)?}. * *
If this smells a lot like semver, it does, but Xcode versions are sometimes special. This is * why this class is in the {@code apple} package and has to remain as such. * *
Dotted versions are ordered using natural integer sorting on components in order from first to * last where any missing element is considered to have the value 0 if they don't contain any * non-numeric characters. For example: * *
* 3.1.25 > 3.1.1 * 3.1.20 > 3.1.2 * 3.1.1 > 3.1 * 3.1 == 3.1.0.0 * 3.2 > 3.1.8 ** *
If the component contains any alphabetic characters after the leading integer, it is * considered smaller than any components with the same integer but larger than any * component with a smaller integer. If the integers are the same, the alphabetic sequences are * compared lexicographically, and if they turn out to be the same, the final (optional) * integer is compared. As with the leading integer, this final integer is considered to be 0 if not * present. For example: * *
* 3.1.1 > 3.1.1beta3 * 3.1.1beta1 > 3.1.0 * 3.1 > 3.1.0alpha1 * * 3.1.0beta0 > 3.1.0alpha5.6 * 3.4.2alpha2 > 3.4.2alpha1 * 3.4.2alpha2 > 3.4.2alpha1.5 * 3.1alpha1 > 3.1alpha ** *
This class is immutable and can safely be shared among threads.
*/
@Immutable
public final class DottedVersion implements DottedVersionApi This is necessary because Bazel assumes that {@link
* com.google.devtools.build.lib.analysis.config.FragmentOptions} that are equal yield fragments
* that are the same. However, this does not hold if the options hold a {@link DottedVersion}
* because trailing zeroes are not considered significant when comparing them, but they do matter
* in configuration fragments (for example, they end up in output directory names).
*
* When read from the {@code settings} dictionary in a Starlark transition function, these
* values are effectively opaque and need to be converted to strings for further use, such as
* comparing them by passing the string to {@code apple_common.dotted_version} to construct an
* instance of the actual version object.
*/
@Immutable
public static final class Option implements StarlarkValue {
private final DottedVersion version;
private Option(DottedVersion version) {
this.version = Preconditions.checkNotNull(version);
}
public DottedVersion get() {
return version;
}
@Override
public boolean isImmutable() {
return true;
}
@Override
public void repr(Printer printer) {
printer.append(version.toString());
}
@Override
public String toString() {
return version.toString();
}
@Override
public int hashCode() {
return version.stringRepresentation.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Option)) {
return false;
}
return version.stringRepresentation.equals(((Option) o).version.stringRepresentation);
}
}
@Nullable
public static DottedVersion maybeUnwrap(DottedVersion.Option option) {
return option != null ? option.get() : null;
}
@Nullable
public static Option option(DottedVersion version) {
return version == null ? null : new Option(version);
}
private static final Splitter DOT_SPLITTER = Splitter.on('.');
private static final Pattern COMPONENT_PATTERN =
Pattern.compile("(\\d+)([a-z0-9]*?)?(\\d+)?", Pattern.CASE_INSENSITIVE);
private static final Pattern DESCRIPTIVE_COMPONENT_PATTERN =
Pattern.compile("([a-z]\\w*)", Pattern.CASE_INSENSITIVE);
private static final String ILLEGAL_VERSION =
"Dotted version components must all start with the form \\d+([a-z0-9]*?)?(\\d+)? "
+ "but got '%s'";
private static final String NO_ALPHA_SEQUENCE = null;
private static final Component ZERO_COMPONENT = new Component(0, NO_ALPHA_SEQUENCE, 0, "0");
/** Exception thrown when parsing an invalid dotted version. */
public static class InvalidDottedVersionException extends Exception {
InvalidDottedVersionException(String msg) {
super(msg);
}
InvalidDottedVersionException(String msg, Throwable cause) {
super(msg, cause);
}
}
/**
* Create a dotted version by parsing the given version string. Throws an unchecked exception if
* the argument is malformed.
*/
public static DottedVersion fromStringUnchecked(String version) {
try {
return fromString(version);
} catch (InvalidDottedVersionException e) {
throw new IllegalArgumentException(e);
}
}
/**
* Generates a new dotted version from the given version string.
*
* @throws InvalidDottedVersionException if the passed string is not a valid dotted version
*/
public static DottedVersion fromString(String version) throws InvalidDottedVersionException {
if (Strings.isNullOrEmpty(version)) {
throw new InvalidDottedVersionException(String.format(ILLEGAL_VERSION, version));
}
ArrayList For example, a dotted version of "7.3.0" will return "7" if one is requested, "7.3" if two
* are requested, "7.3.0" if three are requested, and "7.3.0.0" if four are requested.
*
* @param numComponents a positive number of dot-separated numbers that should be present in the
* returned string representation
*/
public String toStringWithComponents(int numComponents) {
Preconditions.checkArgument(numComponents > 0,
"Can't serialize as a version with %s components", numComponents);
ImmutableList.Builder For example, a dotted version of "7.3" will return "7.3" with either one or two components
* requested, "7.3.0" if three are requested, and "7.3.0.0" if four are requested.
*
* Trailing zero components at the end of a string representation will not be removed. For
* example, a dotted version of "1.0.0" will return "1.0.0" if only one or two components are
* requested.
*
* @param numMinComponents the minimum number of dot-separated numbers that should be present in
* the returned string representation
*/
public String toStringWithMinimumComponents(int numMinComponents) {
return toStringWithComponents(Math.max(this.numOriginalComponents, numMinComponents));
}
/**
* Returns true if this version number has any alphabetic characters, such as 'alpha' in
* "7.3alpha.2".
*/
public boolean hasAlphabeticCharacters() {
for (Component component : components) {
if (!Objects.equals(component.alphaSequence, NO_ALPHA_SEQUENCE)) {
return true;
}
}
return false;
}
/**
* Returns the number of components in this version number. For example, "7.3.0" has three
* components.
*/
public int numComponents() {
return components.size();
}
@Override
public String toString() {
return stringRepresentation;
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other == null || getClass() != other.getClass()) {
return false;
}
return compareTo((DottedVersion) other) == 0;
}
@Override
public int hashCode() {
return Objects.hash(components);
}
private Component getComponent(int groupIndex) {
if (components.size() > groupIndex) {
return components.get(groupIndex);
}
return ZERO_COMPONENT;
}
@Override
public void repr(Printer printer) {
printer.append(stringRepresentation);
}
private static final class Component implements Comparable