Deletes the message whose ID matches the supplied msg_id from the
        specified queue. If the message has been claimed, the ID of that claim
        must be passed as the 'claim_id' parameter.
971819
def delete_message(self, queue, msg_id, claim_id=None):
        
        return queue.delete_message(msg_id, claim_id=claim_id)
911976
def remove_message(self, message):
        '''
        
        '''
        if message in self.__messages:
            self.__messages.remove(message)
312592
def deleteMessages(self, message_ids):
        
        message_ids = require_list(message_ids)
        data = dict()
        for i, message_id in enumerate(message_ids):
            data["message_ids[{}]".format(i)] = message_id
        r = self._post(self.req_url.DELETE_MESSAGES, data)
        return r.ok
469129
function (id, objId) {
    if (this.queue[id]) {
      _.remove(this.queue[id], function (o) {
        return o.id === objId;
      });
    }

    if (objId && this.retries[id] && this.retries[id][objId]) {
      this.retries[id][objId] = 0;
    }
  }
185036
def chat_delete(self, room_id, msg_id, **kwargs):
        """"""
        return self.__call_api_post('chat.delete', roomId=room_id, msgId=msg_id, kwargs=kwargs)
528111
def delete(self, msg, claim_id=None):
        
        msg_id = utils.get_id(msg)
        if claim_id:
            uri = "/%s/%s?claim_id=%s" % (self.uri_base, msg_id, claim_id)
        else:
            uri = "/%s/%s" % (self.uri_base, msg_id)
        return self._delete(uri)
420486
def delete_sdr(self, record_id):
        

        reservation_id = self.reserve_device_sdr_repository()
        rsp = self.send_message_with_name('DeleteSdr',
                                          reservation_id=reservation_id,
                                          record_id=record_id)
        return rsp.record_id
320164
def delete(message_id, reservation_id = nil)
      # API does not accept any options
      options = {}
      options['id'] = message_id
      unless reservation_id.nil?
        options['reservation_id'] = reservation_id
      end
      Message.new(self, options).delete
    end
223314
def delete_messages(self, only_processed=True):
        
        messages = self._processed_messages
        if not only_processed:
            messages += self._messages

        if messages:
            try:
                self.queue.delete_tasks(messages)
            except Exception:
                logging.exception("Error deleting messages")
                raise
444303
def NotificationsDelete(self, notification_id):
        
        if self.__SenseApiCall__('/notifications/{0}.json'.format(notification_id), 'DELETE'):
            return True
        else:
            self.__error__ = "api call unsuccessful"
            return False
812907
def DeleteMessageHandlerRequests(self, requests):
    """"""

    for r in requests:
      flow_dict = self.message_handler_requests.get(r.handler_name, {})
      if r.request_id in flow_dict:
        del flow_dict[r.request_id]
      flow_dict = self.message_handler_leases.get(r.handler_name, {})
      if r.request_id in flow_dict:
        del flow_dict[r.request_id]
760172
public void setDiscardMsgsAfterQueueDeletion() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled()) {
            SibTr.entry(tc, "setDiscardMsgsAfterQueueDeletion");
            SibTr.exit(tc, "setDiscardMsgsAfterQueueDeletion");
        }

        _discardMsgsAfterQueueDeletion = true;
    }
665342
def clear_reply_handlers_by_message_id(self, message_id):
        
        self.reply_handlers[message_id] = []

        if self.reply_saver is not None:
            self.reply_saver.start_save_timer()
1346768
private void doAck(long id) {
    // The other side of the connection has sent a message indicating which
    // messages it has seen. We can clear any messages before the indicated ID.
    if (log.isDebugEnabled()) {
      log.debug(String.format("%s - Received ack for messages up to %d, removing all previous messages from memory", this, id));
    }
    if (messages.containsKey(id+1)) {
      messages.tailMap(id+1);
    } else {
      messages.clear();
    }
    checkDrain();
  }
866099
def unregister_message_handler(self, target_or_handler):
        
        if isinstance(target_or_handler, str):
            del self._message_handlers[target_or_handler]
        else:
            for key, val in self._message_handlers.items():
                if val == target_or_handler:
                    del self._message_handlers[key]
34396
def delete_message(self, messageid="", folderid="", stackid=""):

        

        if self.standard_grant_type is not "authorization_code":
            raise DeviantartError("Authentication through Authorization Code (Grant Type) is required in order to connect to this endpoint.")

        response = self._req('/messages/delete', post_data={
            'folderid' : folderid,
            'messageid' : messageid,
            'stackid' : stackid
        })

        return response
1021747
def get_message(self, message_id):
        

        for message in self.messages:
            if message.id == message_id:
                return message

        raise ArgumentError("Message ID not found", message_id=message_id)