Checks if the given ID is blacklisted in the given context.
495196
private boolean isUbique(String id, RelType context)
	{
		if (context == null) return this.context.containsKey(id);

		if (!isUbique(id)) return false;

		RelType ctx = this.context.get(id);
		return ctx == null || ctx.equals(context);
	}
1236948
@Override
	public String isValidID(String id) {
		Data data;
		try {
			data = identities.find(id, identities.reuse());
		} catch (IOException e) {
			return getName() + " could not lookup " + id + ": " + e.getLocalizedMessage();
		}
		return data==null?id + "is not an Identity in " + getName():null;
	}
527659
def containsID(self, idVal):
        
        for i in self:
            if i.id == idVal:
                return True
        return False
810434
public static function isDismissed( $id ) {
		$dismissed = false;
		$id = sanitize_key( $id );

		// Get all of the notices this user has dismissed.
		$dismissals = get_user_meta( get_current_user_id(), 'boldgrid_dismissed_admin_notices' );

		// Loop through all of the dismissed notices. If we find our $id, then mark bool and break.
		foreach ( $dismissals as $dismissal ) {
			if ( $id === $dismissal['id'] ) {
				$dismissed = true;
				break;
			}
		}

		return $dismissed;
	}
541315
def user_is_blacklisted(self, user):
        '''
        
        '''
        return not salt.utils.stringutils.check_whitelist_blacklist(user, blacklist=self.blacklist.get('users', []))
826085
public boolean isSecuredByPermission(final String permission,
            UserIdentityContext userIdentityContext) {
        try {
            checkPermission(permission,userIdentityContext);
            return true;
        } catch (AuthorizationException e) {
            return false;
        }
    }
660101
public function isBlacklisted(AddressInterface $ip = null)
    {
        if ($ip === null) {
            $ip = $this->getRequestIPAddress();
        }
        $rangeType = $this->getRangeType($ip);

        return $rangeType !== null && ($rangeType & static::IPRANGEFLAG_BLACKLIST) === static::IPRANGEFLAG_BLACKLIST;
    }
286446
public static void checkQuery(SpiQuery<?> query, Set<String> whitelist,
                                  Set<String> blacklist, boolean ignoreUnknown) {
        checkQuery(
                query,
                new ListExpressionValidation(
                        query.getBeanDescriptor(), whitelist, blacklist
                ),
                ignoreUnknown
        );
    }
210568
def _whitelist_blacklist(self, os_name):
        '''
        
        '''
        return napalm_logs.ext.check_whitelist_blacklist(os_name,
                                                         whitelist=self.device_whitelist,
                                                         blacklist=self.device_blacklist)
90617
private boolean isNewId(String id) {

        if (id.contains("#")) {
            id = id.substring(0, id.indexOf("#"));
        }
        return !CmsUUID.isValidUUID(id);
    }
483072
def is_marked?(id, ignore_errors = false)
      @entries.each do |entry|
        return entry[MARKED] != 0 if entry[ID] == id
      end

      return false if ignore_errors
      PEROBS.log.fatal "Cannot find an entry for ID #{'%016X' % id} to check"
    end
1374068
def check_id_has_no_blanks(self, ds):
        '''
        
        '''
        if not hasattr(ds, u'id'):
            return
        if ' ' in getattr(ds, u'id'):
            return Result(BaseCheck.MEDIUM, False, 'no_blanks_in_id',
                          msgs=[u'There should be no blanks in the id field'])
        else:
            return Result(BaseCheck.MEDIUM, True, 'no_blanks_in_id', msgs=[])
1132480
def blacklisted(options={})
      response = connection.get do |req|
        req.url "users/blacklisted", options
      end
      return_error_or_body(response)
    end
267959
@Override
    public boolean checkIfWorkspaceExists(@NonNull String id) {
        ensureThreadExistense();
        return backingMap.get().containsKey(id);
    }
1355426
public boolean isBlacklisted(String nodeName, ResourceType type) {
    List<ResourceType> blacklistedResourceTypes =
      blacklistedNodes.get(nodeName);
    if (blacklistedResourceTypes != null) {
      synchronized (blacklistedResourceTypes) {
        return blacklistedResourceTypes.contains(type);
      }
    } else {
      return false;
    }
  }
278940
public static boolean showRateDialogIfNeeded(final Context context, int themeId) {
        if (shouldShowRateDialog()) {
            showRateDialog(context, themeId);
            return true;
        } else {
            return false;
        }
    }
266634
function isBlacklisted(ip, callback) {
    var host_lookup = reverseIp(ip) + bl_zones[current_bl];

    dns.resolve4(host_lookup, function(err, domain) {
        if (err) {
            // Not blacklisted
            callback(false);
        } else {
            // It is blacklisted
            callback(true);
        }
    });
}