import org.eclipse.aether.util.version.GenericVersionScheme; //导入依赖的package包/类
private static void validateVersion(String version, String key) {
    if (version == null) {
        throw new ManifestParsingException(
                "%s should not be empty. Please correct %s in manifest.yml or package.json.", key, key);
    }

    try {
        VersionScheme scheme = new GenericVersionScheme();
        scheme.parseVersionConstraint(version);
    }
    catch (InvalidVersionSpecificationException e) {
        throw new ManifestParsingException(
                "%s is not a valid version/version range. Please correct %s in manifest.yml or package.json.",
                version, key);
    }
}
 

import org.eclipse.aether.util.version.GenericVersionScheme; //导入依赖的package包/类
public static Optional<String> newerVersion() {
    try {
        VersionScheme scheme = new GenericVersionScheme();
        Version runningVersion = scheme.parseVersion(readVersion().orElse("0.0.0"));
        Version onlineVersion = scheme.parseVersion(readOnlineVersion().orElse("0.0.0"));
        return (onlineVersion.compareTo(runningVersion) > 0
                ? Optional.of(onlineVersion.toString())
                : Optional.empty());
    }
    catch (InvalidVersionSpecificationException e) {
    }
    return Optional.empty();
}
 

import org.eclipse.aether.util.version.GenericVersionScheme; //导入依赖的package包/类
public MetadataBuilder() {
  this.versionScheme = new GenericVersionScheme();
  // G
  this.plugins = new ArrayList<>();
  // A
  this.baseVersions = new TreeSet<>();
  // V
  this.latestVersionCoordinatesMap = new HashMap<>();
}
 

import org.eclipse.aether.util.version.GenericVersionScheme; //导入依赖的package包/类
@Override
public boolean isNewer(Plugin first, Plugin second) {
    try {
        GenericVersionScheme versionScheme = new GenericVersionScheme();
        Version firstVersion = versionScheme.parseVersion(first.getArtifactVersion());
        Version secondVersion = versionScheme.parseVersion(second.getArtifactVersion());
        return firstVersion.compareTo(secondVersion) > 0;
    } catch (Exception e) {
        return false;
    }
}
 

import org.eclipse.aether.util.version.GenericVersionScheme; //导入依赖的package包/类
private boolean verifyVersionRange(ArtifactDescriptor extension,
        List<ArtifactDescriptor> dependencies) {
    Optional<ArtifactDescriptor> cliDependency = dependencies.stream().filter(
            d -> d.group().equals(Constants.GROUP) && d.artifact().equals(Constants.ARTIFACT))
            .findFirst();

    if (cliDependency.isPresent()) {
        try {
            VersionScheme scheme = new GenericVersionScheme();
            VersionConstraint constraint = scheme
                    .parseVersionConstraint(cliDependency.get().version());
            Version cliVersion = scheme.parseVersion(VersionUtils.readVersion().get());
            if (constraint.containsVersion(cliVersion)) {
                return true;
            }
            else {
                if (cliVersion.toString().endsWith("-SNAPSHOT")) {
                    Version cliSnapshotVersion = scheme.parseVersion(
                            StringUtils.removeEnd(cliVersion.toString(), "-SNAPSHOT"));
                    if (constraint.containsVersion(cliSnapshotVersion)) {
                        log.warn(
                                "Assuming this CLI SNAPSHOT is compatible with the extension...",
                                extension.group(), extension.artifact(), extension.version(),
                                constraint.toString(), Constants.GROUP, Constants.ARTIFACT,
                                cliVersion);
                        return true;
                    }
                }
                log.warn("Extension %s:%s (%s) requires %s of %s:%s, but current version is %s",
                        extension.group(), extension.artifact(), extension.version(),
                        constraint.toString(), Constants.GROUP, Constants.ARTIFACT, cliVersion);
                return false;

            }
        }
        catch (InvalidVersionSpecificationException e) {
            // This will be captured earlier when resolving the dependencies.
        }
    }
    return true;
}