Returns true if a given feature is supported in the given layout version
@param f Feature
@param lv LayoutVersion
@return true if {@code f} is supported in layout version {@code lv}
766576
public static boolean supports(final Feature f, final int lv) {
    final EnumSet<Feature> set =  map.get(lv);
    return set != null && set.contains(f);
  }
727673
public boolean hasStyleRelationship(String featureTable) {
		return hasStyleRelationship(
				getMappingTableName(TABLE_MAPPING_STYLE, featureTable),
				featureTable, StyleTable.TABLE_NAME);
	}
1225372
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
    public static boolean hasLandscapeScreenFeature(Context context) {
        return hasLandscapeScreenFeature(context.getPackageManager());
    }
999605
def support(self, version):
        

        if not self._known_version(version):
            warn("unknown feature: %s"%version)
            return True
        else:
            if not self._get_featureset_support(version):
                warn("You are not supporting %s anymore "%str(version), UserWarning, self.level)
            if self._alone_version(version):
                warn("%s is the last supported feature of this group, you can simplifiy this logic. "%str(version), UserWarning,self.level)
                
            return self.predicates.get(version, True)




        if (not self.PY3_supported) or (not self.PY2_supported):
            warn("You are only supporting 1 version of Python", UserWarning, self.level)

        if version == PY3:
            return sys.version_info.major == 3
        elif version == PY2:
            return sys.version_info.major == 2
257929
public boolean canBeImplemented(Page page) {
        Integer implementedVersion = getImplementedVersion(page);
        return implementedVersion == null || page.getVersion() != implementedVersion;
    }
253480
private boolean hasToShowNotice(String versionDownloadable) {
        SharedPreferences prefs = mActivity.getSharedPreferences(PREFS_FILENAME, 0);
        String prefKey = SUCCESSFUL_CHEKS_PREF_KEY + versionDownloadable;
        int mChecksMade = prefs.getInt(prefKey, 0);
        if (mChecksMade % mSuccessfulChecksRequired == 0 || mChecksMade == 0) {
            saveNumberOfChecksForUpdatedVersion(versionDownloadable, mChecksMade);
            return true;
        } else {
            saveNumberOfChecksForUpdatedVersion(versionDownloadable, mChecksMade);
            return false;
        }
    }
399122
@Deprecated
    public static boolean isSupportedImageFile(final String lcasefn) {
        for (final String ext: supportedImageExtensions) {
            if (lcasefn.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }
404022
public static final boolean supports(String view)
    {
        Set<String> supportedFileAttributeViews = FileSystems.getDefault().supportedFileAttributeViews();
        return supportedFileAttributeViews.contains(view);
    }
1185022
public boolean sameFeature(JFeature f){
		return this.name.equals(f.name) && this.type.equals(f.type);
	}
441067
public boolean hasTableStyleRelationship(String featureTable) {
		return hasStyleRelationship(
				getMappingTableName(TABLE_MAPPING_TABLE_STYLE, featureTable),
				ContentsId.TABLE_NAME, StyleTable.TABLE_NAME);
	}
225276
public boolean isModifiedOnVersion(String version) {
		if( this.modificationHistory.isModifiedOnVersion(version)
				|| this.outParameter.isModifiedOnVersion(version) ) {
			return true;
		}
		for(APIParameter inParameter : inParameters) {
			if(inParameter.isModifiedOnVersion(version)) {
				return true;
			}
		}
		return false;
	}
540771
@Deprecated
    public static boolean isResourceFile(final String lcasefn) {
        for (final String ext: supportedResourceExtensions) {
            if (lcasefn.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }
1013424
private static boolean requiredByPlatformFeature(ContentBasedLocalBundleRepository br, File baseDir, File b) {
        try {
            Map<String, ProvisioningFeatureDefinition> features = new Product(baseDir).getFeatureDefinitions();
            for (ProvisioningFeatureDefinition fd : features.values()) {
                if (fd.isKernel()) {
                    if (requiredByJar(br, fd, b))
                        return true;
                }
            }
        } catch (Exception e) {
        }
        return false;
    }
1032966
public static boolean supportsStyle(String style) {
		String styleFileName = style;
		if (!styleFileName.endsWith(".csl")) {
			styleFileName = styleFileName + ".csl";
		}
		if (!styleFileName.startsWith("/")) {
			styleFileName = "/" + styleFileName;
		}
		URL url = CSL.class.getResource(styleFileName);
		return (url != null);
	}
1002329
public boolean isModifiedOnVersion(String version) {
		if (version == null || version.isEmpty()) {
			return true;
		}
		if (this.history != null && this.history.isModifiedOnVersion(version)) {
			return true;
		}
		if (this.fields != null) {
			for (APIParameter param : this.fields) {
				if (param.isModifiedOnVersion(version)) {
					return true;
				}
			}
		}
		return false;
	}
1144071
public function isSupported(string $feature): bool
    {
        if (!array_key_exists($feature, $this->supported)) {
            if (!isset($this->features[$feature])) {
                throw new UndefinedFeatureException($feature);
            }

            $this->supported[$feature] =
                (bool) $this->features[$feature]($this);
        }

        return $this->supported[$feature];
    }
213545
public boolean supportsConfigMode(PortletDefinitionForm form) {
        final Tuple<String, String> portletDescriptorKeys = this.getPortletDescriptorKeys(form);
        if (portletDescriptorKeys == null) {
            logger.trace("Unable to determine supportsConfig - portletDescriptorKeys is null.");
            return false;
        }
        final String portletAppId = portletDescriptorKeys.first;
        final String portletName = portletDescriptorKeys.second;

        final PortletRegistryService portletRegistryService =
                this.portalDriverContainerServices.getPortletRegistryService();
        final PortletDefinition portletDescriptor;
        try {
            portletDescriptor = portletRegistryService.getPortlet(portletAppId, portletName);
        } catch (PortletContainerException e) {
            this.logger.warn(
                    "Unable to determine supportsConfig - Failed to load portlet descriptor for appId='"
                            + portletAppId
                            + "', portletName='"
                            + portletName
                            + "'",
                    e);
            return false;
        }

        if (portletDescriptor == null) {
            logger.trace("Unable to determine supportsConfig - portletDescriptor is null.");
            return false;
        }
        logger.trace(
                "Checking supportsConfig for portlet ID=[{}] and Name=[{}].",
                portletAppId,
                portletName);

        // Iterate over supported portlet modes, this ignores the content types for now
        final List<? extends Supports> supports = portletDescriptor.getSupports();
        for (final Supports support : supports) {
            logger.trace("Checking Supports instance:  {}", support.getMimeType());
            final List<String> portletModes = support.getPortletModes();
            for (final String portletMode : portletModes) {
                logger.trace("Checking portletMode {}.", portletMode);
                if (IPortletRenderer.CONFIG.equals(PortletUtils.getPortletMode(portletMode))) {
                    logger.trace("Returning supportsConfig is true.");
                    return true;
                }
            }
        }
        logger.trace("Returning supportsConfig is false.");
        return false;
    }