/*
Remove entry to registry
516795
function(key) {
  var registry = getFile(cache.registry);
  delete registry[key];
  setFile(cache.registry, registry);
}
998964
function remove(keyId, callback) {
    commons.del(format('/%s/keys/%s', deis.version, keyId), callback);
  }
362168
public void removeEntry(Data key, Object value, Index.OperationSource operationSource) {
        InternalIndex[] indexes = getIndexes();
        for (InternalIndex index : indexes) {
            index.removeEntry(key, value, operationSource);
        }
    }
46555
void unlinkEntry(FatLfnDirectoryEntry entry) {
        final ShortName sn = entry.realEntry.getShortName();
        
        if (sn.equals(ShortName.DOT) || sn.equals(ShortName.DOT_DOT)) throw
                new IllegalArgumentException(
                    "the dot entries can not be removed");

        final String lowerName = entry.getName().toLowerCase(Locale.ROOT);

        assert (this.longNameIndex.containsKey(lowerName));
        this.longNameIndex.remove(lowerName);
        
        assert (this.shortNameIndex.containsKey(sn));
        this.shortNameIndex.remove(sn);
        this.usedNames.remove(sn.asSimpleString().toLowerCase(Locale.ROOT));
        
        assert (this.usedNames.contains(lowerName));
        this.usedNames.remove(lowerName);
        
        if (entry.isFile()) {
            this.entryToFile.remove(entry.realEntry);
        } else {
            this.entryToDirectory.remove(entry.realEntry);
        }
    }
359723
function clear (entry) {
    var type = entry.entryType
    if (type === 'measure') window.performance.clearMeasures(entry.name)
    else if (type === 'resource') window.performance.clearResourceTimings()
  }
77068
def remove(self, task_cls):
		
		registry_tag = task_cls.__registry_tag__
		if registry_tag in self.__registry.keys():
			self.__registry[registry_tag] = \
				list(filter(lambda x: x != task_cls, self.__registry[registry_tag]))
			if len(self.__registry[registry_tag]) == 0:
				self.__registry.pop(registry_tag)
791483
public void removeEntry(String entryKey) {
        Iterator<JPAEntry> iter = entries.iterator();
        while (iter.hasNext()) {
            if (iter.next().getKey().equals(entryKey)) {
                iter.remove();
                return;
            }
        }
    }
723526
public static void deleteValue(String keyName, String valueName) throws RegistryException {
        try (Key key = Key.open(keyName, KEY_WRITE)) {
            checkError(invoke(Methods.REG_DELETE_VALUE.get(), key.id, toByteArray(valueName)));
        }
    }
538799
public static void deleteKey(String keyName) throws RegistryException {
        checkError(invoke(Methods.REG_DELETE_KEY.get(), keyParts(keyName)));
    }
467304
static void unregister(final Object value) {
        Set<IDKey> registry = getRegistry();
        if (registry != null) {
            registry.remove(new IDKey(value));
            synchronized (HashCodeBuilder.class) {
                //read again
                registry = getRegistry();
                if (registry != null && registry.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
648333
private void removeStaleEntries() {
        FileLockReference ref;
        while ((ref = (FileLockReference)queue.poll()) != null) {
            FileKey fk = ref.fileKey();
            List<FileLockReference> list = lockMap.get(fk);
            if (list != null) {
                synchronized (list) {
                    list.remove(ref);
                    removeKeyIfEmpty(fk, list);
                }
            }
        }
    }
508406
def remove_entry_listener(self, registration_id):
        
        return self._stop_listening(registration_id,
                                    lambda i: map_remove_entry_listener_codec.encode_request(self.name, i))
701931
final public function destroy()
    {
        foreach ($this->registry as $offset => $object) {
            if (method_exists($object, '__destruct')) {
                $object->__destruct();
            }
            unset($this->registry[ $offset ]);
        }
    }
3715
function () {
	    eventPluginOrder = null;
	    for (var pluginName in namesToPlugins) {
	      if (namesToPlugins.hasOwnProperty(pluginName)) {
	        delete namesToPlugins[pluginName];
	      }
	    }
	    EventPluginRegistry.plugins.length = 0;
	
	    var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
	    for (var eventName in eventNameDispatchConfigs) {
	      if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
	        delete eventNameDispatchConfigs[eventName];
	      }
	    }
	
	    var registrationNameModules = EventPluginRegistry.registrationNameModules;
	    for (var registrationName in registrationNameModules) {
	      if (registrationNameModules.hasOwnProperty(registrationName)) {
	        delete registrationNameModules[registrationName];
	      }
	    }
	
	    if (false) {
	      var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
	      for (var lowerCasedName in possibleRegistrationNames) {
	        if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
	          delete possibleRegistrationNames[lowerCasedName];
	        }
	      }
	    }
	  }
1017909
def _RemoveRegistryKeys(self, metadata_value_pairs):
    """"""
    filtered_pairs = []
    for metadata, stat_entry in metadata_value_pairs:
      # Ignore registry keys.
      if stat_entry.pathspec.pathtype != rdf_paths.PathSpec.PathType.REGISTRY:
        filtered_pairs.append((metadata, stat_entry))

    return filtered_pairs
753927
def delete_entry(self, key):
        """"""
        pipe = self.client.pipeline()
        pipe.srem(self.keys_container, key)
        pipe.delete(key)
        pipe.execute()
1075137
private void removeLast(HeapEntry<E> entry) {
    indexToEntry.remove(entry.index);
    objectToEntry.remove(entry.object);
  }