Method to reset the Subscription message object and
reinitialise it as a delete proxy subscription message.

This empty delete message that is created tells the Neighbouring
ME that this is the last message that it will receive from it.
434631
protected void resetDeleteSubscriptionMessage()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "resetDeleteSubscriptionMessage");

    // Reset the state
    reset();

    // Indicate that this is a create message    
    iSubscriptionMessage.setSubscriptionMessageType(
      SubscriptionMessageType.DELETE);

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "resetDeleteSubscriptionMessage");
  }
540166
def _reset(self):
        ''''''
        self._socket = None
        # The pending messages we have to send, and the current buffer we're
        # sending
        self._pending = deque()
        self._out_buffer = ''
        # Our read buffer
        self._buffer = ''
        # The identify response we last received from the server
        self._identify_response = {}
        # Our ready state
        self.last_ready_sent = 0
        self.ready = 0
922986
def delete_subscription(self):
        
        url = self._build_url('subscription', base_url=self._api)
        return self._boolean(self._delete(url), 204, 404)
1176347
def undelete(request, message_id, success_url=None):
    
    user = request.user
    message = get_object_or_404(Message, id=message_id)
    undeleted = False
    if success_url is None:
        success_url = reverse('messages_inbox')
    if 'next' in request.GET:
        success_url = request.GET['next']
    if message.sender == user:
        message.sender_deleted_at = None
        undeleted = True
    if message.recipient == user:
        message.recipient_deleted_at = None
        undeleted = True
    if undeleted:
        message.save()
        messages.info(request, _(u"Message successfully recovered."))
        if notification:
            notification.send([user], "messages_recovered", {'message': message,})
        return HttpResponseRedirect(success_url)
    raise Http404
539672
@Override
    public synchronized void reset() throws IOException {
        try {
            this.digest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            /*
             * Not much to do here. We know the algorithm existed when we created the initial MessageDigest in the
             * constructor, so we can be reasonably sure that it's still going to exist if the stream gets reset.
             */
        }

        this.in.reset();
    }
242289
def inplace_delete_message_queue(
        chain_state: ChainState,
        state_change: Union[ReceiveDelivered, ReceiveProcessed],
        queueid: QueueIdentifier,
) -> None:
    
    queue = chain_state.queueids_to_queues.get(queueid)
    if not queue:
        return

    inplace_delete_message(
        message_queue=queue,
        state_change=state_change,
    )

    if len(queue) == 0:
        del chain_state.queueids_to_queues[queueid]
    else:
        chain_state.queueids_to_queues[queueid] = queue
1126966
def delete_message(self, message, callback=None):
        
        return self.connection.delete_message(self, message, callback=callback)
1338298
protected SubscriptionMessage generateResetSubscriptionMessage()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "generateResetSubscriptionMessage");
    
    // Get the Message Handler for doing this operation.
    final SubscriptionMessageHandler messageHandler =
      iProxyHandler.getMessageHandler();

    // Reset the message.
    messageHandler.resetResetSubscriptionMessage();
     
    // Add the local subscriptions
    addToMessage(messageHandler, iLocalSubscriptions);
      
    // Add the remote Subscriptions
    addToMessage(messageHandler, iRemoteSubscriptions);
      
    SubscriptionMessage message = messageHandler.getSubscriptionMessage();
 
    // Add the message back into the pool
    iProxyHandler.addMessageHandler(messageHandler);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "generateResetSubscriptionMessage", message);
   
    return message;
  }
655141
def reset(self):
        
        self._monitor.notify_received()
        self._pinger.stop()
        self._mark_fresh()
307621
public void reset() {
		for (int i = 0; i < 4; i++) {
			ppCorner.get(i).set(0,0);
			ppDown.get(i).set(0,0);
			ppRight.get(i).set(0,0);
		}
		this.threshCorner = 0;
		this.threshDown = 0;
		this.threshRight = 0;
		version = -1;
		error = L;
		mask = QrCodeMaskPattern.M111;
		alignment.reset();
		mode = Mode.UNKNOWN;
		failureCause = Failure.NONE;
		rawbits = null;
		corrected = null;
		message = null;
	}
220049
public void clear() {
        if (!disposedInd) {
            Collection<Binding> unsubscribe1 = null;
            Collection<CompositeBinding> unsubscribe2 = null;
            if (bindings == null && compBindings == null) {
                return;
            }
            if (bindings != null) {
                unsubscribe1 = bindings;
                bindings = null;
                unsubscribeFromAll(unsubscribe1);
            }
            if (compBindings != null) {
                unsubscribe2 = compBindings;
                compBindings = null;
                unsubscribeFromAllComposite(unsubscribe2);
            }
        }
    }
40386
def reset(self):
        
        # Session IDs can be random on every connection
        self.id = struct.unpack('q', os.urandom(8))[0]
        self._sequence = 0
        self._last_msg_id = 0
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))
396749
private function reset(): void
    {
        $this->message = null;
        $this->heading = null;
        $this->heading_level = null;
    }
1064518
void sendResetProxySubscriptions() throws SIResourceException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "sendResetProxySubscriptions");

    // Generate the subscription message that will be sent to this neighbour.
    SubscriptionMessage message = iBusGroup.generateResetSubscriptionMessage();

    if (message !=null)
      // Send to the Neighbour.
      sendToNeighbour(message, null);
    else
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        SibTr.debug(
          tc,
          "No subscriptions to forward to ME " + iMEUuid.toString());

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "sendResetProxySubscriptions");
  }
101488
private void reset()
  {
    if (tc.isEntryEnabled())
      SibTr.entry(tc, "reset");

    if (iInitialised)
    {
      // Reset the ArrayLists associated with this message        
      iTopics.clear();
      iTopicSpaces.clear();
      iTopicSpaceMappings.clear();

      // Create a new message to send to this Neighbour.
      iSubscriptionMessage = createSubscriptionMessage();
    }
    else
    {
      iInitialised = true;
    }

    if (tc.isEntryEnabled())
      SibTr.exit(tc, "reset");
  }
911976
def remove_message(self, message):
        '''
        
        '''
        if message in self.__messages:
            self.__messages.remove(message)