This will check if the current instance version is <code>&gt;</code> the
given version.

@param version The version to compare with.
@return true or false.
482178
public boolean isGreaterThan(String version) {
        JenkinsVersion create = create(version);
        return this.cv.compareTo(create.cv) > 0;
    }
685269
public static boolean isCompatibleJREVersion(String version) {
		if (version != null && !version.isEmpty()) {
			final Version current = Version.parseVersion(version);
			if (current != null) {
				final Version minJdk = Version.parseVersion(SARLVersion.MINIMAL_JDK_VERSION);
				assert minJdk != null;
				if (current.compareTo(minJdk) >= 0) {
					final Version maxJdk = Version.parseVersion(SARLVersion.MAXIMAL_JDK_VERSION);
					assert maxJdk != null;
					return current.compareTo(maxJdk) <= 0;
				}
			}
		}
		return false;
	}
953876
public boolean isSupported(ICalVersion version) {
		for (ICalVersion supportedVersion : supportedVersions) {
			if (supportedVersion == version) {
				return true;
			}
		}
		return false;
	}
773964
public static function isValidProtocolVersion($version)
    {
        if (!is_string($version) || empty($version)) {
            return false;
        }

        return (bool) preg_match('#^(1\.[01]|2)$#', $version);
    }
1055911
public int compareTo(Version version) {
        int mine = (1000 * major) + (100 * minor) + (revision * 10);
        int theirs = (1000 * version.major) + (100 * version.minor) + (version.revision * 10);

        if (mine == theirs && tag != null && version.tag != null) {
            return version.tag.compareTo(tag);
        } else if (mine == theirs && tag == null && version.tag != null) {
            return -1;
        } else if (mine == theirs && tag != null && version.tag == null) {
            return 1;
        } else {
            return mine - theirs;
        }
    }
113054
public int compareTo(Version that) {

    if (that == null) {
      return 1;
    }

    if (major != that.major) {
      return major - that.major;
    }

    if (minor != that.minor) {
      return minor - that.minor;
    }

    if (bugfix != that.bugfix) {
      return bugfix - that.bugfix;
    }

    if (build != that.build) {
      return build - that.build;
    }

    return 0;
  }
1298992
public static boolean isAtLeast(String version, String requiredVersion) {
        if (version != null) {
            SemanticVersion thisVersion = new SemanticVersion(version);
            SemanticVersion otherVersion = new SemanticVersion(requiredVersion);
            return thisVersion.compareTo(otherVersion) != -1;
        }
        return false;
    }
1055448
private boolean checkDatabaseVersion(String databaseName) {
        final Version softwareVersion = this.requiredProductVersions.get(databaseName);
        if (softwareVersion == null) {
            throw new IllegalStateException("No version number is configured for: " + databaseName);
        }

        final Version databaseVersion = this.versionDao.getVersion(databaseName);
        if (databaseVersion == null) {
            throw new IllegalStateException(
                    "No version number is exists in the database for: " + databaseName);
        }

        return softwareVersion.equals(databaseVersion);
    }
1166654
def check(self, version):
        

        for disjunct in self._disjuncts:
            if self._check_insersection(version, disjunct):
                return True

        return False
1135428
public static boolean isJavaVersionOK() {
        boolean isJavaVersionOK = true;
        String versionStr = System.getProperty("java.version");
        String[] parts;
        double version;
        if (versionStr.contains(".")) {
          parts = versionStr.split("\\.");
	}
	else {
          parts = new String[]{versionStr};
	}
	if (parts.length == 1) {
          try {
            version = Double.parseDouble(parts[0]);
	  }
	  catch (Exception e) {
            System.err.println("Unparsable Java version: " + versionStr);
            return false;
	  }
	}
	else {
          try {
            version = Double.parseDouble(parts[0]) + Double.parseDouble(parts[1]) / 10;
	  }
	  catch (Exception e) {
            System.err.println("Unparsable Java version: " + versionStr);
            return false;
	  }
	}
        if (version < 1.8) {
            isJavaVersionOK = false;
            System.err.println();
            System.err.println(Globals.getWorkbenchInfoString());
            System.err.println();
            System.err.print("Java 8 or higher is required to run MOA. ");
            System.err.println("Java version " + versionStr + " found");
        }
        return isJavaVersionOK;
    }
558045
public boolean isLessThan(String version) {
        JenkinsVersion create = create(version);
        return this.cv.compareTo(create.cv) < 0;
    }
1322911
public static VersionNumber parseVersion(@Nonnull final String version) {
		Check.notNull(version, "version");

		VersionNumber result = new VersionNumber(new ArrayList<String>(0), version);
		final Matcher matcher = VERSIONSTRING.matcher(version);
		if (matcher.find()) {
			final List<String> groups = Arrays.asList(matcher.group(MAJOR_INDEX).split("\\."));
			final String extension = matcher.group(EXTENSION_INDEX) == null ? VersionNumber.EMPTY_EXTENSION : trimRight(matcher
					.group(EXTENSION_INDEX));
			result = new VersionNumber(groups, extension);
		}

		return result;
	}
347827
public static boolean isSnapshot(Version version)
   {
      Assert.notNull(version, "Version must not be null.");
      return version.toString().endsWith(SNAPSHOT_SUFFIX);
   }
1014317
public function isVersion($phpVersion)
	{
		$compare = version_compare($this->getVersion(), $phpVersion);
		return ($compare === 1 || $compare === 0) ? true : false;
	}
206096
public static boolean greaterOrEqualsVersion(String versionA, String versionB) {
        String largerVersion = extractLargerVersion(versionA, versionB);
        return largerVersion != null && largerVersion.equals(versionA);
    }
1273441
public static Version copy(Version version) {
        if (version == null) {
            return null;
        }
        Version result = new Version();
        result.labels = new LinkedList<String>(version.labels);
        result.numbers = new LinkedList<Integer>(version.numbers);
        result.snapshot = version.snapshot;
        return result;
    }
1318087
public boolean isModifiedOnVersion(String version) {
		if (version == null || version.isEmpty()) {
			return true;
		}
		for (ModificationRecord record : this.modificationRecordList) {
			if (record.isModifiedOnVersion(version)) {
				return true;
			}
		}
		return false;
	}