Returns true if this frame is in any of the specified versions of ID3.
354797
def _in_version(self, *versions):
        ""
        for version in versions:
            if (self._version == version
                or (isinstance(self._version, collections.Container) 
                    and version in self._version)):
                return True
        return False
433669
private static boolean ensureVersion(Version existing, Version expected) {
        return existing != Version.UNDEFINED && existing.greaterThanOrEqualTo(expected);
    }
780357
def has_override(self, addr):
        """"""
        override = False
        if self._overrides.get(addr, None) is not None:
            override = True
        return override
1284248
@Override
  public boolean contains(IVersion version)
  {
    for (IVersionRange range : ranges) {
      if (range.contains(version)) {
        return true;
      }
    }
    return false;
  }
151718
public static boolean checkIfClassVersionApplicable(Object cacheEntry, boolean useStructuredCache) {
        if (!useStructuredCache && cacheEntry instanceof CacheEntry) {
            return true;
        }

        if (useStructuredCache && cacheEntry instanceof Map) {
            return true;
        }
        return false;
    }
1083402
function checkIfVersionUpdated() {

        var latestBuildNumber = updateJsonHandler.get("latestBuildNumber"),
            currentBuildNumber = Number(/-([0-9]+)/.exec(brackets.metadata.version)[1]);

        return latestBuildNumber === currentBuildNumber;
    }
733679
def i2s_frameid(x):
    
    try:
        return PNIO_FRAME_IDS[x]
    except KeyError:
        pass
    if 0x0100 <= x < 0x1000:
        return "RT_CLASS_3 (%4x)" % x
    if 0x8000 <= x < 0xC000:
        return "RT_CLASS_1 (%4x)" % x
    if 0xC000 <= x < 0xFC00:
        return "RT_CLASS_UDP (%4x)" % x
    if 0xFF80 <= x < 0xFF90:
        return "FragmentationFrameID (%4x)" % x
    return x
469524
private static void checkOrcVersion(OrcDataSource orcDataSource, List<Integer> version)
    {
        if (version.size() >= 1) {
            int major = version.get(0);
            int minor = 0;
            if (version.size() > 1) {
                minor = version.get(1);
            }

            if (major > CURRENT_MAJOR_VERSION || (major == CURRENT_MAJOR_VERSION && minor > CURRENT_MINOR_VERSION)) {
                log.warn("ORC file %s was written by a newer Hive version %s. This file may not be readable by this version of Hive (%s.%s).",
                        orcDataSource,
                        Joiner.on('.').join(version),
                        CURRENT_MAJOR_VERSION,
                        CURRENT_MINOR_VERSION);
            }
        }
    }
739144
def iddversiontuple(afile):
    """"""
    def versiontuple(vers):
        """version tuple"""
        return tuple([int(num) for num in vers.split(".")])
    try:
        fhandle = open(afile, 'rb')
    except TypeError:
        fhandle = afile
    line1 = fhandle.readline()
    try:
        line1 = line1.decode('ISO-8859-2')
    except AttributeError:
        pass
    line = line1.strip()
    if line1 == '':
        return (0,)
    vers = line.split()[-1]
    return versiontuple(vers)
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;
    }
1085189
private boolean checkDefaultFileAlterDiscard()
	{
		return	id.equals(ID3v2Frames.AUDIO_SEEK_POINT_INDEX) || 
				id.equals(ID3v2Frames.AUDIO_ENCRYPTION) || 
				id.equals(ID3v2Frames.EVENT_TIMING_CODES) || 
				id.equals(ID3v2Frames.EQUALISATION) || 
				id.equals(ID3v2Frames.MPEG_LOCATION_LOOKUP_TABLE) || 
				id.equals(ID3v2Frames.POSITION_SYNCHRONISATION_FRAME) || 
				id.equals(ID3v2Frames.SEEK_FRAME) || 
				id.equals(ID3v2Frames.SYNCHRONISED_LYRIC) || 
				id.equals(ID3v2Frames.SYNCHRONISED_TEMPO_CODES) || 
				id.equals(ID3v2Frames.RELATIVE_VOLUME_ADJUSTMENT) || 
				id.equals(ID3v2Frames.ENCODED_BY) || 
				id.equals(ID3v2Frames.LENGTH);
	}
1256364
boolean isNegotiable(ProtocolVersion protocolVersion) {
        if (activeProtocols == null) {
            activeProtocols = getActiveProtocols();
        }

        return activeProtocols.contains(protocolVersion);
    }
1297456
public static boolean isMinHadoopVersion(int major, int minor) throws FlinkRuntimeException {
		String versionString = VersionInfo.getVersion();
		String[] versionParts = versionString.split("\\.");

		if (versionParts.length < 2) {
			throw new FlinkRuntimeException(
					"Cannot determine version of Hadoop, unexpected version string: " + versionString);
		}

		int maj = Integer.parseInt(versionParts[0]);
		int min = Integer.parseInt(versionParts[1]);

		return maj > major || (maj == major && min >= minor);
	}
126374
function hasPlayerVersion(rv) {
		var pv = ua.pv, v = rv.split(".");
		v[0] = parseInt(v[0], 10);
		v[1] = parseInt(v[1], 10) || 0; // supports short notation, e.g. "9" instead of "9.0.0"
		v[2] = parseInt(v[2], 10) || 0;
		return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false;
	}
189416
public static boolean isSkipped(Coordinate coordinate)
    {
        for (Entry<Coordinate, VersionRange> entry : map.entrySet())
        {
            Coordinate pattern = entry.getKey();
            VersionRange range = entry.getValue();

            if (isPatternMatch(pattern.getGroupId(), coordinate.getGroupId())
                        && isPatternMatch(pattern.getArtifactId(), coordinate.getArtifactId())
                        && isPatternMatch(pattern.getClassifier(), coordinate.getClassifier()))
            {
                if (range.isEmpty() || range.includes(new SingleVersion(coordinate.getVersion())))
                    return true;
            }
        }
        return false;
    }
1277716
public boolean isPrefixMatch( VersionID vid )
    {

        if ( _isCompound )
        {
            if ( !_rest.isPrefixMatch( vid ) )
            {
                return false;
            }
        }
        // Make sure that vid is at least as long as the prefix
        String[] t2 = normalize( vid._tuple, _tuple.length );

        for ( int i = 0; i < _tuple.length; i++ )
        {
            Object e1 = _tuple[i];
            Object e2 = t2[i];
            if ( e1.equals( e2 ) )
            {
                // So far so good
            }
            else
            {
                // Not a prefix
                return false;
            }
        }
        return true;
    }
101785
public static boolean isValidVersion(final String version) {
        return StringUtils.isNotBlank(version)
                && (ALTERNATE_PATTERN.matcher(version).matches() || STANDARD_PATTERN
                        .matcher(version).matches());
    }