Returns <code>true</code> if the IFixInfo applies the current installation version.

@param productVersion

@param iFixInfo
@return
510049
private boolean isIFixApplicable(Version productVersion, IFixInfo iFixInfo) throws VersionParsingException {
        // If we don't know the product version just return true
        if (productVersion == null) {
            return true;
        }

        // Get the applicability for the iFix
        Applicability applicability = iFixInfo.getApplicability();
        if (applicability == null) {
            throw new VersionParsingException(getMessage("compare.unable.to.find.offering", iFixInfo.getId()));
        }
        List<Offering> offerings = applicability.getOfferings();
        if (offerings == null || offerings.isEmpty()) {
            throw new VersionParsingException(getMessage("compare.unable.to.find.offering", iFixInfo.getId()));
        }

        // All offerings do not have the same version range so we need to iterate to see if we match
        // an of the applicable ranges
        boolean matches = false;
        for (Offering offering : offerings) {
            String tolerance = offering.getTolerance();
            VersionRange toleranceRange = VersionRange.parseVersionRange(tolerance);

            // Make sure the product version is in the range of the tolerance
            if (toleranceRange.matches(productVersion)) {
                matches = true;
                break;
            }
        }
        return matches;
    }
420847
final public static function checkFrameworkBuildVersion()
    {
        $f = json_decode(file_get_contents(__DIR__."/../../elements/config_files/core/framework.config.json"));

        if (!property_exists($f, 'installation')) {
            return (json_encode(array("code" => 500, "results" => "NOK", "fv" => "unknow",
                "msg" => "Property [installation] is undefined in framework.config.json file")));
        }

        if ($f->installation != null) {
            return (json_encode(array("code" => 500, "results" => "NOK", "fv" => "unknow",
                "msg" => "Cannot use iumio installer because you have already one app installed.")));
        }

        $v = $f->edition_version;
        $build = $f->edition_build;
        $e = $f->edition_fullname;
        $st = $f->edition_stage;

        if ($build >= self::$framework_build_accept) {
            $_SESSION['version'] = trim($v);
            return (json_encode(array("code" => 200, "results" => "OK", "fv" => trim($v), "edition" => $e,
                'stage' => $st)));
        } else {
            return (json_encode(array("code" => 500, "results" => "NOK", "fv" => trim($v),
                "msg" => "The version of iumio Framework is incompatible with iumio installer.
                 You must have at least version " . self::$framework_version_accept .
                    " of iumio Framework on your web server.")));
        }
    }
101785
public static boolean isValidVersion(final String version) {
        return StringUtils.isNotBlank(version)
                && (ALTERNATE_PATTERN.matcher(version).matches() || STANDARD_PATTERN
                        .matcher(version).matches());
    }
1127689
private boolean isProductExtensionInstalled(String inputString, String productExtension) {
        if ((productExtension == null) || (inputString == null)) {
            return false;
        }
        int msgIndex = inputString.indexOf("CWWKF0012I: The server installed the following features:");
        if (msgIndex == -1) {
            return false;
        }

        String msgString = inputString.substring(msgIndex);
        int leftBracketIndex = msgString.indexOf("[");
        int rightBracketIndex = msgString.indexOf("]");
        if ((leftBracketIndex == -1) ||
            (rightBracketIndex == -1) ||
            (rightBracketIndex < leftBracketIndex)) {
            return false;
        }

        String features = msgString.substring(leftBracketIndex, rightBracketIndex);
        Log.info(c, "isProductExtensionInstalled", features);
        if (features.indexOf(productExtension) == -1) {
            return false;
        }
        return true;
    }
177377
static boolean isNewerVersion(String version, String newestVersion, boolean isEarlyAccess) {

        if (version == null)
            return false;
        String[] versionAry = version.split("\\.");

        if (!!!isEarlyAccess && versionAry[0].length() == 4)
            return false;

        if (isEarlyAccess && versionAry[0].length() != 4)
            return false;

        if (newestVersion == null)
            return true;

        String[] newestVersionAry = newestVersion.split("\\.");
        for (int i = 0; i < versionAry.length; i++) {
            if (Integer.parseInt(versionAry[i]) > Integer.parseInt(newestVersionAry[i]))
                return true;
            else if (Integer.parseInt(versionAry[i]) < Integer.parseInt(newestVersionAry[i]))
                return false;
        }
        return false;

    }
817330
private static boolean isKnxInterfaceId(final String device)
	{
		boolean knownVendor = false;
		boolean knownProduct = false;
		final String[] split = device.split(":", -1);
		try {
			final int vend = Integer.parseInt(split[0], 16);
			final int prod = Integer.parseInt(split[1], 16);
			for (final int v : vendorIds)
				knownVendor |= v == vend;
			for (final int p : productIds)
				knownProduct |= p == prod;
		}
		catch (final NumberFormatException ignore) {}
		return knownVendor && knownProduct;
	}
831252
public Version getVersion(String product) throws IllegalArgumentException {
		String three = properties.getProperty(product);
		if(three==null) throw new IllegalArgumentException(accessor.getMessage("PropertiesVersions.getVersion.productNotFound", product));
		return Version.valueOf(three+"."+getBuild());
	}
357304
def __get_dbms_version(self, make_connection=True):
        
        if not self.connection and make_connection:
            self.connect()
        with self.connection.cursor() as cursor:
            cursor.execute("SELECT SERVERPROPERTY('productversion')")
            return cursor.fetchone()[0]
928513
private Version getSimpleVersion(String product) {
        final Tuple coreNumbers;
        try {
            final TypedQuery<Tuple> coreNumbersQuery =
                    this.createQuery(this.findCoreVersionNumbers);
            coreNumbersQuery.setParameter(this.productParameter, product);
            coreNumbers = DataAccessUtils.singleResult(coreNumbersQuery.getResultList());
        } catch (SQLGrammarException e) {
            logger.warn("UP_VERSION table doesn't exist, returning null for version of " + product);
            return null;
        }

        if (coreNumbers == null) {
            // Table exists but no version data for the product
            return null;
        }

        // Pull out the maj/min/pat values
        final Integer major =
                coreNumbers.get(
                        VersionImpl_.major.getName(), VersionImpl_.major.getBindableJavaType());
        final Integer minor =
                coreNumbers.get(
                        VersionImpl_.minor.getName(), VersionImpl_.minor.getBindableJavaType());
        final Integer patch =
                coreNumbers.get(
                        VersionImpl_.patch.getName(), VersionImpl_.patch.getBindableJavaType());

        // See if the optional local version value exists
        Integer local;
        try {
            final TypedQuery<Integer> localNumberQuery =
                    this.createQuery(this.findLocalVersionNumber);
            localNumberQuery.setParameter(this.productParameter, product);
            local = DataAccessUtils.singleResult(localNumberQuery.getResultList());
        } catch (PersistenceException e) {
            local = null;
        }

        return new VersionImpl(product, major, minor, patch, local);
    }
171852
public boolean isVersion128() {
    String mwversion = "Mediawiki 1.27 or before";
    try {
      mwversion = this.getVersion();
    } catch (Exception e) {
      LOGGER.log(Level.INFO,
          "Could not retrieve Mediawiki Version via API - will assume "
              + mwversion
              + " you might want to set the Version actively if you are on 1.28 and have the api blocked for non-logged in users");
    }
    boolean result = mwversion.compareToIgnoreCase("Mediawiki 1.28") >= 0;
    return result;
  }
515661
public static boolean isCompatibleSARLLibraryVersion(String version) {
		if (version != null) {
			final Version currentVersion = Version.parseVersion(SARLVersion.SPECIFICATION_RELEASE_VERSION_STRING);
			final Version paramVersion = Version.parseVersion(version);
			return currentVersion.getMajor() == paramVersion.getMajor()
					&& currentVersion.getMinor() == paramVersion.getMinor();
		}
		return false;
	}
1327812
private boolean releaseIdUpdated(ReleaseId oldReleaseId, ReleaseId newReleaseId) {
        if (oldReleaseId == null && newReleaseId == null) {
            return false;
        }
        if (oldReleaseId == null && newReleaseId != null) {
            return true;
        }
        // now both releaseIds are non-null, so it is safe to call equals()
        return !oldReleaseId.equals(newReleaseId);
    }
53892
public function isNewVersionAvailable($currentVersion = '') : bool
    {
        $version = $currentVersion ?: $this->getVersionInstalled();

        if (! $version) {
            throw new \InvalidArgumentException('No currently installed version specified.');
        }

        // Remove the version file to forcefully update current version
        $this->deleteVersionFile();

        if (version_compare($version, $this->getVersionAvailable(), '<')) {
            if (! $this->versionFileExists()) {
                $this->setVersionFile($this->getVersionAvailable());
                event(new UpdateAvailable($this->getVersionAvailable()));
            }

            return true;
        }

        return false;
    }
1317355
@FFDCIgnore(NumberFormatException.class)
    private static boolean determineIsJava8Before161(String version) {
        try {
            return version != null 
                && version.startsWith("1.8.0_")
                && Integer.parseInt(version.substring(6)) < 161;
        } catch (NumberFormatException ex) {
            //no-op
        }
        return false;
    }
1011541
public static function isNewestVersionAvailable()
    {
        $latestVersion = self::getLatestVersion();
        if (!empty($latestVersion)
            && version_compare(Version::VERSION, $latestVersion) == -1
        ) {
            return $latestVersion;
        }
        return false;
    }
1298887
private Version getProductVersion(File wlpInstallationDirectory) throws VersionParsingException {
        // First get the properties
        Map<String, ProductInfo> productProperties = VersionUtils.getAllProductInfo(wlpInstallationDirectory);

        // Get the properties for WAS
        ProductInfo wasProperties = productProperties.get("com.ibm.websphere.appserver");
        if (wasProperties == null) {
            throw new VersionParsingException(getMessage("compare.no.was.properties.found"));
        }

        Version version = convertVersion(wasProperties);

        return version;
    }
591230
static boolean supportedJavaVersion(String javaVersion, String javaVendor, int major, int minor, String point) {
        String[] versionParts = javaVersion.split("\\.");
        int currentMajor = Integer.parseInt(versionParts[0]);
        int currentMinor = Integer.parseInt(versionParts[1]);
        String currentPoint = versionParts[2];

        if (currentMajor > major) {
            return true;
        } else if (currentMajor == major) {
            if (currentMinor > minor) {
                return true;
            } else if (currentMinor == minor) {
                // java.version point version is not a version number and for Azul (zing) it does not follow the
                // the number_number... format used by Oracle and Open JDK (e.g. 1.7.0-zing_5.10.1.0). So just
                // allow any zing version that starts with major.minor.
                return javaVendor.startsWith("Azul") || currentPoint.compareTo(point) >= 0;
            }
        }

        return false;
    }