Java 类cpw.mods.fml.common.versioning.InvalidVersionSpecificationException 实例源码

@NetworkCheckHandler
public final boolean networkCheck(Map<String, String> remoteVersions, Side side) throws InvalidVersionSpecificationException {

    if (!requiresRemoteFrom(side)) {
        return true;
    }
    Mod mod = getClass().getAnnotation(Mod.class);
    String _modid = mod.modid();
    if (!remoteVersions.containsKey(_modid)) {
        return false;
    }
    String remotes = mod.acceptableRemoteVersions();
    if (!"*".equals(remotes)) {

        String remote = remoteVersions.get(_modid);
        if (Strings.isNullOrEmpty(remotes)) {
            return getModVersion().equalsIgnoreCase(remote);
        }

        return ModRange.createFromVersionSpec(_modid, remotes).containsVersion(new ModVersion(_modid, remote));
    }
    return true;
}

public boolean isAcceptibleVersion(final String version) {
    try {
        final VersionRange range = VersionRange.createFromVersionSpec(version);
        return range.containsVersion(this.mod.getArtifactVersion());
    } catch (InvalidVersionSpecificationException e) {
        e.printStackTrace();
        return false;
    }
}

public static VersionRange createFromVersionSpec(String label, String spec) throws InvalidVersionSpecificationException {

        if (spec == null) {
            return null;
        }

        List<Restriction> restrictions = new ArrayList<Restriction>();
        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) & index1 >= 0) {
                index = index1;
            }

            if (index < 0) {
                throw new InvalidVersionSpecificationException("Unbounded range: " + spec);
            }

            Restriction restriction = parseRestriction(label, 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 = getArtifactVersion(label, process);
                restrictions.add(Restriction.EVERYTHING);
            }
        }

        try {
            return VersionRange.newRange(version, restrictions);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

private static Restriction parseRestriction(String label, 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 = getArtifactVersion(label, 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 = getArtifactVersion(label, lowerBound);
            }
            ArtifactVersion upperVersion = null;
            if (upperBound.length() > 0) {
                upperVersion = getArtifactVersion(label, 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;
    }