import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; //导入依赖的package包/类
@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;
}
 

import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; //导入依赖的package包/类
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;
	}
}
 

import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; //导入依赖的package包/类
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;
	}
 

import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; //导入依赖的package包/类
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;
	}