Checks that the given resource should not be included under any circumstances.
519395
public static boolean isProtectedExtension(String path) {
		for(String extension : PROTECTED_EXTENSIONS) {
			if(path.endsWith(extension)) return true;
		}
		return false;
	}
1263212
private void uncacheResource(CmsResource resource) {

        if (resource == null) {
            return;
        }
        if ((m_serializationPolicyPath != null) && resource.getRootPath().equals(m_serializationPolicyPath)) {
            m_serPolicyOffline = null;
        }
    }
557612
function(permissions, negative) {
            if (!negative) {
              negative = false;
            }
            if (permissions !== null && Array.isArray(permissions)) {
              if (negative) {
                this.permissions.exclude = permissions;
              } else {
                this.permissions.include = permissions;
              }
            }
          }
563593
public static boolean resourceExists(String name) {
        Objects.requireNonNull(name, Required.NAME.toString());
        
        URL resource = null;
        try {
            resource = Resources.getResource(name);            
        } catch (IllegalArgumentException e) { // NOSONAR Intentionally not logging or throwing this exception
           // Intentionally left blank
        }
        
        return resource != null;
    }
143296
protected boolean excludeRequest(HttpServletRequest request) {
        if (ArrayUtils.isNotEmpty(urlsToExclude)) {
            for (String pathPattern : urlsToExclude) {
                if (pathMatcher.match(pathPattern, HttpUtils.getRequestUriWithoutContextPath(request))) {
                    return true;
                }
            }
        }

        return false;
    }
651945
boolean isGuarded(T resource) {
    // Check if this polyfill is already guarded.  If so, return true right away.
    if (guarded.contains(resource)) {
      return true;
    }

    // If not, see if this is itself a feature check guard.  This is
    // defined as a usage of the polyfill in such a way that throws
    // away the actual value and only cares about its truthiness or
    // typeof.  We walk up the ancestor tree through a small set of
    // node types and if this is detected to be a guard, then the
    // conditional node is marked as a guard for this polyfill.
    Context context = contextStack.peek();
    if (!context.safe) {
      return false;
    }

    // Loop over all the linked conditionals and register this as a guard.
    while (context != null && context.conditional != null) {
      registeredGuards.put(context.conditional, resource);
      context = context.linked;
    }
    return true;
  }
220378
public boolean isIncluded(String endpoint) {
        for (int i = 0; i < inclusions.size(); i++) {
            if (inclusions.get(i).test(endpoint)) {
                return true;
            }
        }
        return false;
    }
872297
public boolean isValid() {
        if (valid == null) {
            valid = (this.resource != null);
            if (valid) {
                valid = (getResourceResolver().getResource(getPath()) != null);
            }
        }
        return valid;
    }
1271175
def _sanitize_resources(cls, resources):
        """"""

        try:
            for resource in cls._loop_raw(resources):
                cls._sanitize_resource(resource)
        except (KeyError, TypeError):
            _LOGGER.debug("no shade data available")
            return None
1160974
private boolean isExcluded(String name, String cmpname, String value) {
        return exclude.contains(excludeKey(name, null, value)) || exclude.contains(excludeKey(name, cmpname, value));
    }
445523
def check_inclusions(item, included=[], excluded=[]):
    """"""
    if (len(included) == 0):
        if len(excluded) == 0 or item not in excluded:
            return True
        else:
            return False
    else:
        if item in included:
            return True
    return False
949575
protected void validateResourceState(Resource resource) {
		if (resource instanceof StorageAwareResource && ((StorageAwareResource) resource).isLoadedFromStorage()) {
			LOG.error("Discouraged attempt to compute types for resource that was loaded from storage. Resource was : "+resource.getURI(), new Exception());
		}
	}
119379
private boolean resourceExists(CmsObject cms, String resource) {

        try {
            cms.readResource(resource, CmsResourceFilter.ALL);
            return true;
        } catch (CmsException e) {
            return false;
        }
    }
560762
public boolean checkResource(RequiredOrientResource resource, Action action)
	{
		if(!resource.action().equals(action.getName())) return true;
		OSecurityUser user = OrientDbWebSession.get().getEffectiveUser();
		if(user==null) return false;
		int iOperation = OrientPermission.combinedPermission(resource.permissions());
		ORule.ResourceGeneric value = OSecurityHelper.getResourceGeneric(resource.value());
		String specific = resource.specific();
		if(Strings.isEmpty(specific)) specific = null;
		if(user.checkIfAllowed(value, specific, iOperation)!=null) return true;
		while(!Strings.isEmpty(specific=Strings.beforeLastPathComponent(specific, '.')))
		{
			if(user.checkIfAllowed(value, specific+"."+ODatabaseSecurityResources.ALL, iOperation)!=null) return true;
		}
		return false;
	}
931206
public static boolean isExcluded(Artifact artifact) {
        Set<String> excluded = EXCLUSIONS.get(artifact.getGroupId());
        return excluded != null && excluded.contains(artifact.getArtifactId());
    }
771719
def should_exclude(type_or_instance, exclusion_list):
    
    if type_or_instance in exclusion_list: # Check class definition
        return True
    if type(type_or_instance) in exclusion_list: # Check instance type
        return True
    try:
        if type_or_instance.__class__ in exclusion_list: # Check instance class
            return True
    except:
        pass

    return False
855866
public boolean isExcluded(String path) {
        if (inclusions != null && !inclusions.isEmpty()) {
            if (!matchesList(path, inclusions, false)) {
                log.debug("{} does not match an inclusion: skipping...", path);
                return true;
            }
        }

        if (exclusions == null) {
            return false;
        }

        if (matchesList(path, exclusions, true)) {
            log.debug("{} matches exclusions: skipping...", path);
            return true;
        }
        return false;
    }