Remove the reference to the keyRing monitor.
197919
protected void unsetKeyringMonitorRegistration() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(this, tc, "unsetKeyringMonitorRegistration");
        }
        if (keyringMonitorRegistration != null) {
            keyringMonitorRegistration.unregister();
            keyringMonitorRegistration = null;
        }
    }
940104
def trim(self):
        """"""
        for key, value in list(iteritems(self.counters)):
            if value.empty():
                del self.counters[key]
956802
public boolean removeReference(K key, ServiceReference<V> reference) {
        if (key == null)
            return false;

        ConcurrentServiceReferenceSet<V> csrs = elementMap.get(key);
        if (csrs == null) {
            return false;
        }
        return csrs.removeReference(reference);
    }
150409
public void removeKeyListener(KeyListener listener) {
		keyListeners.remove(listener);
		keyListenersToAdd.remove(listener);
		
		if (!mouseListeners.contains(listener) && !controllerListeners.contains(listener)) {
			allListeners.remove(listener);
		}
	}
373418
def _remove_keycache(self, entity_branch, turn, tick):
        """"""
        keycache = self.keycache
        if entity_branch in keycache:
            kc = keycache[entity_branch]
            if turn in kc:
                kcturn = kc[turn]
                if tick in kcturn:
                    del kcturn[tick]
                kcturn.truncate(tick)
                if not kcturn:
                    del kc[turn]
            kc.truncate(turn)
            if not kc:
                del keycache[entity_branch]
709324
def remove_service_listener(self, listener):
        """"""
        for browser in self.browsers:
            if browser.listener == listener:
                browser.cancel()
                del(browser)
1210949
public synchronized void stop() {

        _coreMonitor.unregister();

        for (ServiceReg<FileMonitor> reg : _monitors.values()) {
            reg.unregister();
        }

        _monitors.clear();

        // Tidy up old location if we built it
        tidyUpMonitoredDirectory(createdMonitoredDir.get(), monitoredDirectory.get());
    }
399060
def remove(self, key, value, element):
        """"""
        self.neoindex.delete(key, value, element.neoelement)
329396
def remove_override(self, key):
        """"""
        keys = key.split('.')
        if len(keys) > 1:
            raise NotImplementedError
        elif key in self.overrides:
            del self.overrides[key]
            self._uncache(key)
753414
def del_key(self, k):
        """"""
        if k not in self.mirror:
            raise KeyError
        del self.proxy[k]
        if '_config' in self.proxy and k in self.proxy['_config']:
            del self.proxy['_config'][k]
315827
def RemoveClientKeyword(self, client_id, keyword):
    """"""
    if keyword in self.keywords and client_id in self.keywords[keyword]:
      del self.keywords[keyword][client_id]
518239
def remove(self, key):
        """"""
        item = self.item_finder.pop(key)
        item[-1] = None
        self.removed_count += 1
724026
def removeItem(self, index):
        """"""
        self._stim.removeComponent(index.row(), index.column())
550093
def _remove(self, rtracker):
        
        with self._lock:
            i = self._reference_queue.index(rtracker)
            self._reference_queue[i] = None
            self._size -= 1
1165734
public void removeListener(KeyMatcher matcher,
            VehicleMessage.Listener listener) {
        mNotifier.unregister(matcher, listener);
    }
1148492
def _removeBackrefs( senderkey):
    """"""
    try:
        signals = connections[senderkey]
    except KeyError:
        signals = None
    else:
        items = signals.items()
        def allReceivers( ):
            for signal,set in items:
                for item in set:
                    yield item
        for receiver in allReceivers():
            _killBackref( receiver, senderkey )
148498
void cleanUpStaleEntries() {
        for (KeyedRef<K, V> ref = q.poll(); ref != null; ref = q.poll()) {
            map.remove(ref.getKey(), ref); // CONCURRENT remove() operation
        }
    }