Java 类net.minecraftforge.fml.common.versioning.ComparableVersion 实例源码

public static void updateCheck(final String mod, final String version) {
    updateCheck("http://www.chickenbones.net/Files/notification/version.php?" +
            "version=" + mcVersion() + "&" +
            "file=" + mod, new Function<String, Void>() {
        @Override
        public Void apply(String ret) {
            if (!ret.startsWith("Ret: ")) {
                CodeChickenCorePlugin.logger.error("Failed to check update for " + mod + " returned: " + ret);
                return null;
            }
            ComparableVersion newVersion = new ComparableVersion(ret.substring(5));
            if (newVersion.compareTo(new ComparableVersion(version)) > 0) {
                ModDescriptionEnhancer.setUpdateStatus(mod, ForgeVersion.Status.OUTDATED, newVersion);
                addUpdateMessage("Version " + newVersion + " of " + mod + " is available");
            }
            return null;
        }
    });
}

public Map<ComparableVersion, String> getAllChanges() {
    final LinkedHashMap<ComparableVersion, String> changes = new LinkedHashMap<ComparableVersion, String>();

    if (this.builds != null) {
        Collections.sort(this.builds, new Comparator<BuildData>() {
            @Override
            public int compare(final BuildData a, final BuildData b) {
                return b.getVersion().compareTo(a.getVersion());
            }
        });

        for (final BuildData build : this.builds) {
            changes.put(build.getVersion(), build.getChanges());
        }

        return changes;
    }

    if (this.latest != null) {
        changes.put(this.latest.getVersion(), this.latest.getChanges());

        return changes;
    }

    return changes;
}

private CheckResult(Status status, ComparableVersion target, Map<ComparableVersion, String> changes, String url)
{
    this.status = status;
    this.target = target;
    this.changes = changes == null ? null : Collections.unmodifiableMap(changes);
    this.url = url;
}

public VersionedFile(String filename, Pattern pattern) {
    this.pattern = pattern;
    this.filename = filename;
    Matcher m = pattern.matcher(filename);
    if (m.matches()) {
        name = m.group(1);
        version = new ComparableVersion(m.group(2));
    } else {
        name = null;
        version = null;
    }
}

public static void setUpdateStatus(String modId, Status status, ComparableVersion version) {
    try {
        ModContainer modContainer = FMLCommonHandler.instance().findContainerFor(modId);
        Map<ComparableVersion, String> changes = new HashMap<ComparableVersion, String>();
        CheckResult result = ReflectionManager.newInstance(CheckResult.class, status, version, changes, "");
        setUpdateStatus(modContainer, result);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static int compareVersions(@Nonnull final String v1, @Nonnull final String v2) {
    if (StringUtils.isNullOrEmpty(v1) || v1.charAt(0) == '@')
        return -1;
    else if (StringUtils.isNullOrEmpty(v2) || v2.charAt(0) == '@')
        return 1;

    final ComparableVersion ver1 = new ComparableVersion(v1);
    final ComparableVersion ver2 = new ComparableVersion(v2);
    return ver1.compareTo(ver2);
}

private static void updateCheck() {
    final ComparableVersion ccv = new ComparableVersion(R.MF_VERSION);
    try {
        final JsonObject je = MCFluxNetwork.downloadGistJSON("97a48d6a61b29171938abf2f6bf9f985", "versions.json");
        final String v = je.getAsJsonObject("mc").getAsJsonPrimitive(Loader.MC_VERSION).getAsString();
        if (new ComparableVersion(v).compareTo(ccv) > 0) {
            L.info("A newer Minecraft-Flux version is available (" + v + ")");
            NEWER_VERSION = v;
        }
        UPDATE_CHECK_FINISHED = true;
    } catch (Throwable t) {
        MCFluxReport.sendException(t, "Update Check");
    }
}

public VersionedFile(String filename, Pattern pattern) {
    this.pattern = pattern;
    this.filename = filename;
    Matcher m = pattern.matcher(filename);
    if (m.matches()) {
        name = m.group(1);
        version = new ComparableVersion(m.group(2));
    } else {
        name = null;
        version = null;
    }
}

public static ForgeVersion.Status getStatus(final ComparableVersion versionRemote, final ComparableVersion versionLocal) {
    final int diff = versionRemote.compareTo(versionLocal);

    if (diff == 0) {
        return ForgeVersion.Status.UP_TO_DATE;
    }

    if (diff > 0) {
        return ForgeVersion.Status.OUTDATED;
    }

    return ForgeVersion.Status.AHEAD;
}

public static void notify(final ModContainer container, final ForgeVersion.Status status, final ComparableVersion target, final Map<ComparableVersion, String> changes, final String url) {
    try {
        final Map<ModContainer, ForgeVersion.CheckResult> versionMap = getVersionMap();
        final ForgeVersion.CheckResult checkResult = getCheckResult(status, target, changes, url);

        if (versionMap != null && checkResult != null) {
            versionMap.put(container, checkResult);
        }
    } catch (final Throwable t) {
        Reference.logger.error("Failed to notify Forge!", t);
    }
}

private static ForgeVersion.CheckResult getCheckResult(final ForgeVersion.Status status, final ComparableVersion target, final Map<ComparableVersion, String> changes, final String url) throws ReflectiveOperationException {
    try {
        final Constructor<?> constructor = ForgeVersion.CheckResult.class.getDeclaredConstructor(ForgeVersion.Status.class, ComparableVersion.class, Map.class, String.class);
        constructor.setAccessible(true);
        return (ForgeVersion.CheckResult) constructor.newInstance(status, target, changes, url);
    } catch (final Throwable t) {
        Reference.logger.error("Failed to construct the CheckResult object!", t);
    }

    return null;
}

public ComparableVersion getVersion() {
    return new ComparableVersion(this.version);
}