Check if the entry for a given ID is marked.
 @param id [Integer] ID of the entry
 @param ignore_errors [Boolean] If set to true no errors will be raised
        for non-existing objects.
 @return [TrueClass or FalseClass] true if marked, false otherwise
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
163408
def wf_savedsearch_id?(id)
      return true if id.is_a?(String) && id =~ /^\w{8}$/
      raise Wavefront::Exception::InvalidSavedSearchId
    end
852744
def can_ignore_error(self, reqhnd=None):
        
        value = sys.exc_info()[1]
        try:
            if isinstance(value, BrokenPipeError) or \
                    isinstance(value, ConnectionResetError):
                return True
        except NameError:
            pass
        if not self.done:
            return False
        if not isinstance(value, socket.error):
            return False
        need_close = value.errno == 9
        if need_close and reqhnd is not None:
            reqhnd.close_connection = 1
        return need_close
1172704
function isNotFalse(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && value === false) {
        throw ValueException.expectedValue(assertionTypes.IS_NOT_FALSE, value, false, message, id);
    }
}
169707
def usable_id(cls, id):
        
        try:
            # id is maybe a sshkey name
            qry_id = cls.from_name(id)
            if not qry_id:
                qry_id = int(id)
        except DuplicateResults as exc:
            cls.error(exc.errors)
        except Exception:
            qry_id = None

        if not qry_id:
            msg = 'unknown identifier %s' % id
            cls.error(msg)

        return qry_id
1147820
def get_mark(self, mark_id):
        
        if mark_id in self.idx:
            return Cmarkable(self.idx[mark_id], self.type)
        else:
            return None
772657
private boolean contains(String ids[], String id) {
	for (int i = 0; i < ids.length; i++) {
	    if (Operator.compare(ids[i], id) == 0) return true;
	}
	return false;
    }
501526
def wf_message_id?(id)
      return true if id.is_a?(String) && id =~ /^\w+::\w+$/
      raise Wavefront::Exception::InvalidMessageId
    end
393409
def check(self, item_id):
        
        response = self._request("/submission/sample/{sample_id}".format(sample_id=item_id), headers=self.headers)

        if response.status_code == 404:
            # unknown id
            return False

        try:
            finished = False
            for submission in response.json()['data']:
                finished = finished or submission['submission_finished']
            if finished:
                return True

        except (ValueError, KeyError) as e:
            raise sandboxapi.SandboxError(e)

        return False
905402
def element_contains(self, element_id, value):
    

    elements = ElementSelector(
        world.browser,
        str('id("{id}")[contains(., "{value}")]'.format(
            id=element_id, value=value)),
        filter_displayed=True,
    )
    if not elements:
        raise AssertionError("Expected element not found.")
808024
def check(id, repair)
      begin
        return get_object(id) != nil
      rescue PEROBS::FatalError => e
        PEROBS.log.error "Cannot read object with ID #{id}: #{e.message}"
        if repair
          begin
            PEROBS.log.error "Discarding broken object with ID #{id}"
            @flat_file.delete_obj_by_id(id)
          rescue PEROBS::FatalError
          end
        end
      end

      return false
    end
1171000
def ignore_by_class?(ignored_class = nil)
      @ignore_by_class ||= Proc.new do |ignored_class|
        case error_class
        when (ignored_class.respond_to?(:name) ? ignored_class.name : ignored_class)
          true
        else
          exception && ignored_class.is_a?(Class) && exception.class < ignored_class
        end
      end

      ignored_class ? @ignore_by_class.call(ignored_class) : config.ignored_classes.any?(&@ignore_by_class)
    end
1074558
def should_see_id(self, element_id):
    

    elements = ElementSelector(
        world.browser,
        'id("%s")' % element_id,
        filter_displayed=True,
    )
    if not elements:
        raise AssertionError("Expected element with given id.")
50530
def check_is_declared(self, id_, lineno, classname='identifier',
                          scope=None, show_error=True):
        
        result = self.get_entry(id_, scope)
        if isinstance(result, symbols.TYPE):
            return True

        if result is None or not result.declared:
            if show_error:
                syntax_error(lineno, 'Undeclared %s "%s"' % (classname, id_))
            return False
        return True
1156279
def is_ignored(self, event):
        
        for each in self._ignored:
            if event.name == each:
                return True
        return False
737909
protected boolean check(String id, List<String> includes) {
		if (null != includes) {
			for (String check : includes) {
				if (check(id, check)) {
					return true;
				}
			}
		}
		return false;
	}
65778
def id_exists(api, search_id):
    
    response = utils.checked_api_call(api, 'get_specific', id=search_id)
    return response is not None