Delete messages from errors, warnings, and notices whose tier is
        greater than the ending tier.
343004
def discard_unused_messages(self, ending_tier):
        

        stacks = [self.errors, self.warnings, self.notices]
        for stack in stacks:
            for message in stack:
                if message['tier'] > ending_tier:
                    stack.remove(message)
625990
def _filter_messages(messages, products=None, levels=None):
    """"""
    if products is None:
        products = []
    if levels is None:
        levels = []
    segments = []
    bounds = len(messages)
    for i, message in enumerate(messages):
        if (message[3] in products or len(products) == 0) and \
                (message[4] in levels or len(levels) == 0):
            start = int(message[1])
            if i == (bounds - 1):
                end = None
            else:
                end = int(messages[i+1][1])
            segments.append((start, end))
    return _join(segments)
205508
function resetValidationMessage(e) {
    if (Swal.isVisible() && oldInputVal !== e.target.value) {
      Swal.resetValidationMessage();
    }

    oldInputVal = e.target.value;
  }
278269
public void clear(){
		this.errors.clearErrorMessages();;

		this.warnings.clear();
		this.infos.clear();

		this.scDir = 0;
		this.scDirUnreadable = 0;
		this.scFiles = 0;
		this.scFilesUnreadable = 0;
	}
1008474
def delete_bigger(self):
        
        logger.info(
            "Deleting all mails strictly bigger than {} bytes...".format(
                self.smallest_size))
        # Select candidates for deletion.
        candidates = [
            mail for mail in self.pool
            if mail.size > self.smallest_size]
        if len(candidates) == self.size:
            logger.warning(
                "Skip deletion: all {} mails share the same size."
                "".format(self.size))
        logger.info(
            "{} candidates found for deletion.".format(len(candidates)))
        for mail in candidates:
            self.delete(mail)
627304
def clean_errors(self):
        """"""
        self._vim.eval('clearmatches()')
        self._errors = []
        self._matches = []
        # Reset Syntastic notes - TODO: bufdo?
        self._vim.current.buffer.vars['ensime_notes'] = []
583038
public function clearMessages()
    {
        if (isset($this->storage[$this->storageKey])) {
            $this->storage[$this->storageKey] = [];
        }

        $this->fromPrevious = [];
        $this->forNow = [];
    }
230632
def delete_error_message(sender, instance, name, source, target, **kwargs):
    
    if source != StateMixin.States.ERRED:
        return
    instance.error_message = ''
    instance.save(update_fields=['error_message'])
429534
def remove(self, msg, callback):
        
        if callback is None:
            self._dict.pop(msg, None)
        else:
            cb = self._dict.get(msg, [])
            try:
                cb.remove(callback)
            except ValueError:
                pass
            if cb:
                _LOGGER.debug('%d callbacks for message: %s', len(cb), msg)
                self.add(msg, cb, True)
            else:
                self._dict.pop(msg, None)
                _LOGGER.debug('Removed all callbacks for message: %s', msg)
1101091
def clear(self, page_size=10, vtimeout=10):
        """"""
        n = 0
        l = self.get_messages(page_size, vtimeout)
        while l:
            for m in l:
                self.delete_message(m)
                n += 1
            l = self.get_messages(page_size, vtimeout)
        return n
1155820
public void cleanup() {
        List<String> keys = new ArrayList<>(created.keySet());
        keys.sort(String::compareTo);
        for (String key : keys) {
            created.remove(key)
                .stream()
                .sorted(Comparator.comparing(HasMetadata::getKind))
                .forEach(metadata -> {
                    log.info(String.format("Deleting %s : %s", key, metadata.getKind()));
                    deleteWithRetries(metadata);
                });
        }
    }
482623
def done(self, msg_handle):
        """"""
        self.sqs_client.delete_message(
            QueueUrl=self.queue_url,
            ReceiptHandle=msg_handle.handle,
        )
1121231
public void clearNew() {

        m_newAliasPath.setFormValueAsString(""); //$NON-NLS-1$
        m_newAliasPath.setErrorMessage(null);
        m_newResourcePath.setFormValueAsString(""); //$NON-NLS-1$
        m_newResourcePath.setErrorMessage(null);
    }
422960
function () {
            var arrayUtils = ariaUtilsArray;
            for (var i = 0, item; item = arguments[i]; i++) {
                arrayUtils.remove(this.validators, item);
            }
        }
745663
def message_callback_remove(self, sub):
        """"""
        if sub is None:
            raise ValueError("sub must defined.")

        self._callback_mutex.acquire()
        for i in range(0, len(self.on_message_filtered)):
            if self.on_message_filtered[i][0] == sub:
                self.on_message_filtered.pop(i)
                self._callback_mutex.release()
                return
        self._callback_mutex.release()
473327
@ObjectiveCName("deleteMessagesWithPeer:withRids:")
    public void deleteMessages(Peer peer, long[] rids) {
        modules.getMessagesModule().deleteMessages(peer, rids);
    }
1341278
public void removeMessage(String messageId) {
        Collection<ValidationMessage<Origin>> toRemove = new ArrayList<ValidationMessage<Origin>>();

        for (ValidationMessage<Origin> message : messages) {
            if (messageId.equals(message.getMessageKey())) {
                toRemove.add(message);
            }
        }
        messages.removeAll(toRemove);
    }