Test whether or not a particular ME is of a version compatible with this one.

@param me The ME to test.
@return True if ME is of a compatible version
172389
public boolean isCompatibleME(SIBUuid8 meUuid, ProtocolVersion version) 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "isCompatibleME", new Object[] {meUuid});
      
    boolean result = false;
    MPConnection conn = findMPConnection(meUuid);    
    if (conn!=null)
    {
      // If the other ME is an older version then we are incompatible
      ProtocolVersion otherVersion = conn.getVersion();
      if (otherVersion != null && otherVersion.compareTo(version) >= 0)
        result = true;      
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "isCompatibleME", Boolean.valueOf(result));
      
    return result;
  }
1325470
public boolean containsGreaterThan( VersionID m )
    {
        for ( Object _versionId : _versionIds )
        {
            VersionID vi = (VersionID) _versionId;
            boolean check = vi.isGreaterThan( m );
            if ( check )
            {
                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;
    }
716547
private void ensureMavenCompatibility(final ClassLoader classLoader) throws MojoExecutionException {
    Version mavenVersion = mavenVersionHelper.detectVersion(classLoader);
    if (mavenVersion == null) {
      // complain and continue
      log.error("Unable to determine Maven version");
    }
    else {
      log.debug("Detected Maven version: {}", mavenVersion);
      if (versionHelper.before(3).containsVersion(mavenVersion)) {
        throw new MojoExecutionException("Unsupported Maven version: " + mavenVersion);
      }
    }
  }
801404
public boolean isEquivalentTo(Semver version) {
        // Get versions without build
        Semver sem1 = this.getBuild() == null ? this : new Semver(this.getValue().replace("+" + this.getBuild(), ""));
        Semver sem2 = version.getBuild() == null ? version : new Semver(version.getValue().replace("+" + version.getBuild(), ""));
        // Compare those new versions
        return sem1.isEqualTo(sem2);
    }
474587
public boolean dependesOn(CmsModuleDependency other) {

        if (!m_name.equals(other.m_name)) {
            // not same name means no dependency
            return false;
        }

        // same name: result depends on version numbers
        return (m_version.compareTo(other.m_version) <= 0);
    }
617099
public boolean isModifiedOnVersion(String version) {
		if (version == null || version.isEmpty()) {
			return true;
		}
		return version.equalsIgnoreCase(this.version);
	}
977501
public boolean isUpdateForVersionCode() {
		Set<Integer> uniques = new HashSet<Integer>();
		for (VersionHistoryItem item : versionHistoryItems) {
			uniques.add(item.getVersionCode());
		}
		return uniques.size() > 1;
	}
136046
public boolean isOldVersion()
    {
        if (_unexpectedFormat)
        {
            return false;
        }
        else
        {
            final long version = _uuidHigh & _VERSION_MASK;

            return (version >= _OLD_VERSION_ID && version < _CURRENT_VERSION_ID);
        }
    }
344225
public boolean match( Artifact artifact )
        throws InvalidVersionSpecificationException
    {
        for ( Pattern pattern : patterns )
        {
            if ( pattern.match( artifact ) )
            {
                for ( Pattern ignorePattern : ignorePatterns )
                {
                    if ( ignorePattern.match( artifact ) )
                    {
                        return false;
                    }
                }
                return true;
            }
        }
        return false;
    }
171039
public boolean contains( VersionID m )
    {
        for ( Object _versionId : _versionIds )
        {
            VersionID vi = (VersionID) _versionId;
            boolean check = vi.match( m );
            if ( check )
            {
                return true;
            }
        }
        return false;
    }
199454
public boolean isSatisfiedBy(Semver version) {
        if (this.range != null) {
            // We are on a leaf
            return this.range.isSatisfiedBy(version);
        } else {
            // We have several sub-requirements
            switch (this.op) {
                case AND:
                    try {
                        List<Range> set = getAllRanges(this, new ArrayList<Range>());
                        for (Range range : set) {
                            if (!range.isSatisfiedBy(version)) {
                                return false;
                            }
                        }
                        if (version.getSuffixTokens().length > 0) {
                            // Find the set of versions that are allowed to have prereleases
                            // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
                            // That should allow `1.2.3-pr.2` to pass.
                            // However, `1.2.4-alpha.notready` should NOT be allowed,
                            // even though it's within the range set by the comparators.
                            for (Range range : set) {
                                if (range.version == null) {
                                    continue;
                                }
                                if (range.version.getSuffixTokens().length>0) {
                                    Semver allowed = range.version;
                                    if (Objects.equals(version.getMajor(), allowed.getMajor()) &&
                                            Objects.equals(version.getMinor(), allowed.getMinor()) &&
                                            Objects.equals(version.getPatch(), allowed.getPatch())) {
                                        return true;
                                    }
                                }
                            }
                            // Version has a -pre, but it's not one of the ones we like.
                            return false;
                        }
                        return true;
                    } catch (Exception e) {
                        // Could be that we have a OR in AND - fallback to default test
                        return this.req1.isSatisfiedBy(version) && this.req2.isSatisfiedBy(version);
                    }
                case OR:
                    return this.req1.isSatisfiedBy(version) || this.req2.isSatisfiedBy(version);
            }
            throw new RuntimeException("Code error. Unknown RequirementOperator: " + this.op); // Should never happen
        }
    }
1187692
public boolean areCompatible(Keys<?> other) throws IncompatibleKeysException {

		TypeInformation<?>[] thisKeyFieldTypes = this.getKeyFieldTypes();
		TypeInformation<?>[] otherKeyFieldTypes = other.getKeyFieldTypes();

		if (thisKeyFieldTypes.length != otherKeyFieldTypes.length) {
			throw new IncompatibleKeysException(IncompatibleKeysException.SIZE_MISMATCH_MESSAGE);
		} else {
			for (int i = 0; i < thisKeyFieldTypes.length; i++) {
				if (!thisKeyFieldTypes[i].equals(otherKeyFieldTypes[i])) {
					throw new IncompatibleKeysException(thisKeyFieldTypes[i], otherKeyFieldTypes[i] );
				}
			}
		}
		return true;
	}
322506
public synchronized boolean compatible(List<PType> to, List<PType> from)
	{
		done.clear();
		return allCompatible(to, from, false) == Result.Yes;
	}
1350496
function checkCompatible(type, modulePath, location) {
    var adapterPackage = require(path.join(modulePath, 'package.json'));
    var adapterJuttleVersion = adapterPackage.juttleAdapterAPI;
    if (!adapterJuttleVersion) {
        throw errors.compileError('INCOMPATIBLE-ADAPTER', {
            type,
            adapterJuttleVersion: '(unknown)',
            apiVersion: JuttleAdapterAPI.version,
            location
        });
    }

    if (!semver.satisfies(JuttleAdapterAPI.version, adapterJuttleVersion)) {
        throw errors.compileError('INCOMPATIBLE-ADAPTER', {
            type,
            adapterJuttleVersion,
            apiVersion: JuttleAdapterAPI.version,
            location
        });
    }
}
510817
public boolean compatibleWith(PipelineConfiguration oth) {
        if (oth == null)
            return false;
        if (pipelineSteps.length != oth.pipelineSteps.length)
            return false;
        for (int i = 0; i < pipelineSteps.length; ++i)
            if (!pipelineSteps[i].compatibleWith(oth.pipelineSteps[i]))
                return false;
        return true;
    }
155006
public boolean isForeachCompatible(Class<?> clazz) {
        if (clazz == null) {
            return false;
        }

        return (clazz.isArray() || 
                Collection.class.isAssignableFrom(clazz));         
    }