Remove the given messages from lease management.

        Args:
            items(Sequence[DropRequest]): The items to drop.
493030
def drop(self, items):
        
        self._manager.leaser.remove(items)
        self._manager.maybe_resume_consumer()
309798
def removeOldRequests
      now = Time.new
      @requestedPieces.length.times do |i|
        if @requestedPieces.set? i
          if now - @pieceRequestTime[i] > @requestTimeout
            @requestedPieces.clear i
            @pieceRequestTime[i] = nil
          end
        end
      end
    end
1118684
void clearAllMsg() {
        removeMessages(MESSAGE_DISPLAY);
        removeMessages(MESSAGE_ADD_VIEW);
        removeMessages(MESSAGE_REMOVE);
        clearShowing();
        msgQueue.clear();
        stickyQueue.clear();
    }
952193
def unregister(self, items):
        
        items = _listify(items)
        # get all members of Registry except private, special or class
        meta_names = (m for m in vars(self).iterkeys()
                      if (not m.startswith('_') and m not in dir(Registry)))
        # check that meta names matches
        # FIXME: this is so lame. replace this with something more robust
        for m in meta_names:
            if m not in self.meta_names:
                raise AttributeError('Meta name %s not listed.')
        # pop items from Registry and from meta
        for it in items:
            if it in self:
                self.pop(it)
            for m in (getattr(self, m_) for m_ in self.meta_names):
                if it in m:
                    m.pop(it)
1311859
def remove(self, *members):
        
        members = list(map(self._dumps, members))
        self._client.zrem(self.key_prefix, *members)
43299
public boolean remove( LocalSession localSession , TransactionItem[] items ) throws JMSException
    {
    	checkNotClosed();
    	checkTransactionLock();
    	
    	int volatileCommitted = 0;
    	int persistentCommitted = 0;
    	
        synchronized (storeLock)
        {
    		for (int n = 0 ; n < items.length ; n++)
            {
    			TransactionItem transactionItem = items[n];
            	if (transactionItem.getDestination() != this)
            		continue;
            	
            	if (traceEnabled)
                	log.trace(localSession+" COMMIT "+transactionItem.getMessageId());
            	
            	// Delete message from store
            	if (transactionItem.getDeliveryMode() == DeliveryMode.PERSISTENT)
            	{
            		persistentStore.delete(transactionItem.getHandle());
            		persistentCommitted++;
            	}
            	else
            	{
            		volatileStore.delete(transactionItem.getHandle());
            		volatileCommitted++;
            	}
            }
        }
        acknowledgedGetCount.addAndGet(volatileCommitted + persistentCommitted);
        
        if (persistentCommitted > 0 && requiresTransactionalUpdate())
        {
        	pendingChanges = true;
        	return true;
        }
        else
        	return false;
    }
211463
def remove(self, items):
        """"""
        items = coerce_to_list(items)
        new_options = {k: v for k, v in self.options.items() if v not in items}
        self.widget.options = new_options
        self.widget.param.trigger('options')
49611
def remove(self, item):
        """"""
        for entry in self:
            if item.lower() == entry.lower():
                list.remove(self, entry)
                return
        raise ValueError(': list.remove(x): x not in list')
881876
def remove_item(self, item):
        """"""
        index = self.items.index(item)
        self.beginRemoveRows(QtCore.QModelIndex(), index, index)
        self.items.remove(item)
        self.endRemoveRows()
371031
def delete_item(name)
      previous = items.size
      items.reject! { |item| item.name == name}
      previous != items.size
    end
1199554
def remove(self, item):
        
        if item not in self.__dict__[self.ATTRIBUTES].keys():
            raise AttributeError('%s does not exist' % item)
        delattr(self, item)
1344444
def remove_item(self, val):
        
        return cache.lrem(self.key, json.dumps(val))
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;
                }
            }
        }
    }
332091
def remove_all_labels(stdout=None):
    

    if not stdout:
        stdout = sys.stdout

    stdout.write("Droping constraints...\n")
    drop_constraints(quiet=False, stdout=stdout)

    stdout.write('Droping indexes...\n')
    drop_indexes(quiet=False, stdout=stdout)
815513
public void deleteAllItems() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        PubSub request = createPubsubPacket(Type.set, new NodeExtension(PubSubElementType.PURGE_OWNER, getId()));

        pubSubManager.getConnection().createStanzaCollectorAndSend(request).nextResultOrThrow();
    }
241144
public boolean removeItem(T item) {
        int index = mListItems.indexOf(item);
        if (index < 0) return false;
        mListItems.remove(index);
        notifyItemRemoved(index);
        return true;
    }
549925
def ack(self, items):
        
        # If we got timing information, add it to the histogram.
        for item in items:
            time_to_ack = item.time_to_ack
            if time_to_ack is not None:
                self._manager.ack_histogram.add(time_to_ack)

        ack_ids = [item.ack_id for item in items]
        request = types.StreamingPullRequest(ack_ids=ack_ids)
        self._manager.send(request)

        # Remove the message from lease management.
        self.drop(items)