Remove a message object from the list
@param message
333290
protected void removeMessage(LMEMessage message)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeMessage", new Object[] {new Integer(hashCode()), message, this });

    // If this was the message we entered the callback with we need
    // to move the start point back a bit
    if(message == callbackEntryMsg)
      callbackEntryMsg = message.previous;

    // If this is our current message we need to move the cursor
    // back a bit
    if(message == currentMsg)
      currentMsg = message.previous;

    // If this message was the next to expire we move the expiry cursor on to
    // the next eligible message. We leave any alarm registered so that it pops,
    // when this happens it realises the alarm is not valid for the next expiring
    // message and re-registers itself for the correct time. This gives us the
    // best performance when no locks are expiring as we're not continually
    // registering and de-registering alarms for every message
    if(message == nextMsgToExpire)
    {
      do
      {
        nextMsgToExpire = nextMsgToExpire.next;
      }
      while((nextMsgToExpire != null) && (nextMsgToExpire.expiryTime == 0));
    }

    if(message == nextMsgReferenceToExpire)
    {
      do
      {
        nextMsgReferenceToExpire = nextMsgReferenceToExpire.next;
      }
      while((nextMsgReferenceToExpire != null) && (nextMsgReferenceToExpire.expiryTime == 0));
    }

    // Unlink this message from the list
    if(message.previous != null)
      message.previous.next = message.next;
    else
      firstMsg = message.next;

    if(message.next != null)
      message.next.previous = message.previous;
    else
      lastMsg = message.previous;

    // Pool the element if there's space
    if(pooledCount < poolSize)
    {
      message.message = null;
      message.next = pooledMsg;
      message.previous = null;
      message.owner = null;
      message.jsMessage = null;
      message.expiryTime = 0;
      message.expiryMsgReferenceTime = 0;
      pooledMsg = message;
      pooledCount++;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeMessage", this);
  }
408024
async def deleteMessage(self, msg_identifier):
        
        p = _strip(locals(), more=['msg_identifier'])
        p.update(_dismantle_message_identifier(msg_identifier))
        return await self._api_request('deleteMessage', _rectify(p))
268085
public static void warn(Object... message) {
        StringBuilder builder = new StringBuilder(APP_WARN);
        for (Object object : message) {
            builder.append(object.toString());
        }
        warnStream.println(builder.toString());
    }
911976
def remove_message(self, message):
        '''
        
        '''
        if message in self.__messages:
            self.__messages.remove(message)
722998
function removeBinding(oBindingInfo) {
			// Also tell the Control that the messages have been removed (if any)
			if (that.refreshDataState) {
				that.refreshDataState(sName, oBindingInfo.binding.getDataState());
			}

			oBindingInfo.binding.detachChange(oBindingInfo.modelChangeHandler);
			if (oBindingInfo.modelRefreshHandler) { // only list bindings currently have a refresh handler attached
				oBindingInfo.binding.detachRefresh(oBindingInfo.modelRefreshHandler);
			}
			oBindingInfo.binding.detachEvents(oBindingInfo.events);
			oBindingInfo.binding.destroy();
			// remove all binding related data from the binding info
			delete oBindingInfo.binding;
			delete oBindingInfo.modelChangeHandler;
			delete oBindingInfo.dataStateChangeHandler;
			delete oBindingInfo.modelRefreshHandler;
		}
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()
466709
public void remove()
	{
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "remove");
    } 
    
		if (msgIterator.hasNext())
		{
			msgIterator.remove();
		}
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.exit(tc, "remove");
    } 
	}
1174387
public void removeFromQueue(T t) {
        synchronized (messages) {
            for (Map.Entry<Long, Message> messageEntry : messages.entrySet()) {
                if (messageEntry.getValue().equals(t)) {
                    Message message = messages.remove(messageEntry.getKey());
                    recycle(message);
                    notifyQueueChanged();
                    return;
                }
            }
        }
    }
589238
def inplace_delete_message(
        message_queue: List[SendMessageEvent],
        state_change: Union[ReceiveDelivered, ReceiveProcessed],
) -> None:
    
    for message in list(message_queue):
        message_found = (
            message.message_identifier == state_change.message_identifier and
            message.recipient == state_change.sender
        )
        if message_found:
            message_queue.remove(message)
61834
public void deleteMessage(final String id) throws UnauthorizedException, GeneralException, NotFoundException {
        if (id == null) {
            throw new IllegalArgumentException("Message ID must be specified.");
        }
        messageBirdService.deleteByID(MESSAGESPATH, id);
    }
39983
def remove(self, elem):
    """"""
    self._values.remove(elem)
    self._message_listener.Modified()
141224
protected final void deleteMessage(SIBusMessage message,
            SITransaction transaction) throws ResourceException {

        final String methodName = "deleteMessage";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, new Object[] { message,
                    transaction });
        }

        deleteMessages (new SIMessageHandle [] { message.getMessageHandle () }, transaction);

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
15541
public void removeListener(MessageKey key, VehicleMessage.Listener listener) {
        removeListener(ExactKeyMatcher.buildExactMatcher(key), listener);
    }
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)
353912
function(message) {
      if (message.namespace === data.namespace &&
          message.data.requestId === data.data.requestId) {
        if (timer) {
          clearTimeout(timer);
        }
        self.removeListener('message', answer);
        self.removeListener('disconnect', cancel);
        cb(null, message);
      }
    }
777224
public void removeValidationMessage() {

        if (m_hasError) {
            m_messageText.setInnerText("");
            removeStyleName(formCss().hasError());
            removeStyleName(formCss().hasWarning());
            m_hasError = false;
        }

    }
658744
public void removeMessages(final int index) {
		MessageModel model = getOrCreateComponentModel();

		if (model.messages != null) {
			model.messages.remove(index);
		}
	}