Returns true if access to the plugin is restricted.

@return True if access to the plugin is restricted.
192252
public boolean isForbidden() {
        if (authorities.size() == 0) {
            return false; // If no restrictions, return false
        }

        boolean result = true;

        for (Authority priv : authorities) {
            result = !SecurityUtil.isGranted(priv.name);

            if (requiresAll == result) {
                break;
            }
        }

        return result;
    }
1237573
def is_restricted(self, assets, dt):
        
        if isinstance(assets, Asset):
            return self._is_restricted_for_asset(assets, dt)

        is_restricted = partial(self._is_restricted_for_asset, dt=dt)
        return pd.Series(
            index=pd.Index(assets),
            data=vectorize(is_restricted, otypes=[bool])(assets)
        )
1138111
protected function isAllowed()
    {
        if ($this->verifyCookie() || $this->allowAdmins() || $this->allowUsers() || $this->allowedIpAddress()) {
            return true;
        }

        return false;
    }
713463
public boolean isSendAllowed()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "isSendAllowed");
    
    boolean isSendAllowed = aliasDest.isSendAllowed();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "isSendAllowed", new Boolean(isSendAllowed));
    
    return isSendAllowed;
  }
904080
public boolean isProtected() {
        List<String> requiredRoles = null;
        return !webRequest.isUnprotectedURI() &&
               webRequest.getMatchResponse() != null &&
               (requiredRoles = webRequest.getRequiredRoles()) != null &&
               !requiredRoles.isEmpty();
    }
648875
protected boolean isAccessPermitted(String resourceName) {

		boolean accessible = true;
		if (resourceName.startsWith(JawrConstant.WEB_INF_DIR_PREFIX)) {
			if (resourceName.startsWith(JawrConstant.WEB_INF_DIR_PREFIX + GRAILS_APP_DIR)
					&& resourceName.endsWith(GrailsLocaleUtils.MSG_RESOURCE_BUNDLE_SUFFIX)) {
				accessible = true;
			} else {
				accessible = false;
			}
		}

		return accessible;
	}
704455
public boolean isValidAndEnabled() {

        return (getMode() != null)
            && (getMode() != Mode.disabled)
            && (getPort() > -1)
            && !CmsStringUtil.isEmptyOrWhitespaceOnly(getCertConfigPath())
            && !CmsStringUtil.isEmptyOrWhitespaceOnly(getHost());
    }
322090
static boolean isEclipsePluginDisabled(String pluginId, Map<URI, Plugin> allPlugins) {
        for (Plugin plugin : allPlugins.values()) {
            if(pluginId.equals(plugin.getPluginId())) {
                return false;
            }
        }
        return true;
    }
443161
public boolean allowAccess(String user) {

        try {
            return m_cms.getPermissions(m_root, user).requiresViewPermission();
        } catch (CmsException e) {
            LOG.error(e.getLocalizedMessage(), e);
            return true;
        }
    }
919794
public boolean isRemoteAccessAllowed(String pRemoteHost, String pRemoteAddr) {
        return restrictor.isRemoteAccessAllowed(pRemoteHost != null ?
                                                        new String[] { pRemoteHost, pRemoteAddr } :
                                                        new String[] { pRemoteAddr });
    }
496462
public static boolean isEditRestricted(@NotNull ComponentContext wcmComponentContext) {
    Page page = wcmComponentContext.getPage();
    if (page == null) {
      return false;
    }
    ResourceResolver resourceResolver = wcmComponentContext.getResource().getResourceResolver();
    Template template = page.getTemplate();

    if (template == null || isPageInTemplateDefinition(page) || !isEditableTemplate(template)) {
      return false;
    }

    // check if the current resource path already points to a structure path in the editable template
    String resourcePath = wcmComponentContext.getResource().getPath();
    String templateStructurePath = template.getPath() + "/" + NN_EDITABLE_TEMPLATE_STRUCTURE + "/" + JCR_CONTENT;
    String resourcePathInStructure = null;
    if (StringUtils.startsWith(resourcePath, templateStructurePath + "/")) {
      resourcePathInStructure = resourcePath;
    }
    else {
      // resource path points to the current page, build structure path from path in page
      String relativePathInPage = StringUtils.substringAfter(resourcePath, page.getContentResource().getPath());
      if (StringUtils.isNotEmpty(relativePathInPage)) {
        resourcePathInStructure = templateStructurePath + relativePathInPage;
      }
    }
    if (resourcePathInStructure == null) {
      return false;
    }

    Resource resourceInStructure = resourceResolver.getResource(resourcePathInStructure);
    if (resourceInStructure == null) {
      return false;
    }
    return !resourceInStructure.getValueMap().get(PN_EDITABLE, false);
  }
1077720
public boolean isNullable() {

        boolean isNullable = super.isNullable();

        if (isNullable) {
            if (dataType.isDomainType()) {
                return dataType.userTypeModifier.isNullable();
            }
        }

        return isNullable;
    }
1134737
public boolean isDisabled() {
		if (super.isDisabled()) 
			return true;
		UIComponent ancestor = getParent();
		while (ancestor!=null) {
			if (ancestor instanceof IContentDisabled) {
				if (((IContentDisabled)ancestor).isContentDisabled()) {
					return true;
				}
			}
			ancestor=ancestor.getParent();
		}
		return false;
	}
1210840
@Override
    public boolean isSendAllowed()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "isSendAllowed");

        boolean isSendAllowed = true;

        // We check first whether send is disallowed at the bus definition level. A
        // setting at the bus level overrides a setting on the Alias Destination
        // Definition.
        DestinationHandler target = getTarget();
        if (_sendAllowedOnTargetForeignBus != null)
            isSendAllowed = _sendAllowedOnTargetForeignBus.booleanValue();

        ExtendedBoolean aliasIsSendAllowed = _definition.isSendAllowed();

        // If we're allowed to send at the bus level, or there is no Foreign
        // Bus target in the chain, then move to the next level of checking.
        if (isSendAllowed)
        {
            // A setting of NONE signals use target value.
            if (aliasIsSendAllowed.equals(ExtendedBoolean.NONE))
            {
                isSendAllowed = target.isSendAllowed();
            }
            else if (aliasIsSendAllowed.equals(ExtendedBoolean.FALSE))
            {
                isSendAllowed = false;
            }
            else
            {
                isSendAllowed = true;
            }
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "isSendAllowed", Boolean.valueOf(isSendAllowed));

        return isSendAllowed;
    }
960216
public boolean isInfoEnabled() {
        if (repository.isDisabled(Level.INFO_INT))
            return false;
        return Level.INFO.isGreaterOrEqual(this.getEffectiveLevel());
    }
670220
private boolean checkForSecureAccess() {
        Class[] classContext = getClassContext();
        for (Class clazz : classContext) {
            if (clazz.equals(SecureAccess.class) || clazz.equals(SecurityBreachHandler.class)
                    || clazz.equals(SecurityFunctions.class) || clazz.equals(SecureStorageImpl.class)) {
                return true;
            }
        }
        return false;
    }
514960
public boolean checkPermission(boolean showAppInfoDialogEnabled) {
		boolean hasPermission;
		if (permissionRationaleMessageResId != 0) {
			hasPermission = checkPermission(permissionDelegate, getPermissionRationaleTitleResId(), permissionRationaleMessageResId, permission, permissionRequestCode);
		} else {
			hasPermission = checkPermission(permissionDelegate, permission, permissionRequestCode);
		}
		if (!hasPermission && showAppInfoDialogEnabled) {
			previouslyShouldShowRequestPermissionRationale = permissionDelegate.shouldShowRequestPermissionRationale(permission);
		} else {
			previouslyShouldShowRequestPermissionRationale = null;
		}
		return hasPermission;
	}