Removes the specified key from the storage object's metadata. If the
        key does not exist in the metadata, nothing is done.
15352
def remove_metadata_key(self, key, prefix=None):
        
        self.manager.remove_metadata_key(self, key, prefix=prefix)
717984
def remove_object_metadata_key(self, container, obj, key, prefix=None):
        
        self.set_object_metadata(container, obj, {key: ""}, prefix=prefix)
1167824
def delete(self, key):
    '''
    '''
    path = self.object_path(key)
    if os.path.exists(path):
      os.remove(path)
538434
def remove(self, key):
        

        data = self._load_file()
        del data[key]
        self._save_file(data)
17817
async def delete(self, key):
        
        response = await self._discard(key)
        return response.body is True
91045
function(key) {

            // remove the item itself and its expiration time
            var ret = this._storage.removeItem(key);
            this._storage.removeItem(this._expiration_key_prefix + key);

            // return optional return code
            return ret;
        }
1192354
def delete(self, key):
    '''
    '''
    super(DirectoryTreeDatastore, self).delete(key)

    str_key = str(key)

    # ignore root
    if str_key == '/':
      return

    # retrieve directory, to remove entry
    dir_key = key.parent.instance('directory')
    directory = self.directory(dir_key)

    # ensure key is not in directory
    if directory and str_key in directory:
      directory.remove(str_key)
      if len(directory) > 0:
        super(DirectoryTreeDatastore, self).put(dir_key, directory)
      else:
        super(DirectoryTreeDatastore, self).delete(dir_key)
71601
public void deleteKey(String key) throws IOException {
        File keyDir = getKeyDir(key);
        LocalFsBlobStoreFile pf = new LocalFsBlobStoreFile(keyDir, BlobStoreFile.BLOBSTORE_DATA_FILE);
        pf.delete();
        delete(keyDir);
    }
198761
public void delete(int key) {
        int i = ContainerHelpers.binarySearch(mKeys, mSize, key);

        if (i >= 0) {
            if (mValues[i] != DELETED) {
                mValues[i] = DELETED;
                mGarbage = true;
            }
        }
    }
937992
def remove_object(self, key):
        ''''''
        state = self.state
        for layer in state.layers:
            state.layers[layer].pop(key, None)
        state.need_redraw = True
1257699
def delete(key)
      file = filename key
      File.delete file if File.exist? file
    end
47797
def del_key(cls, k):
        
        k = cls.__name__ + "__" + k
        session.pop(k)
532548
def delete(self, key):
        
        data = None
        if key is not None:
            data = self.db.delete(key.strip())
        else:
            self.tcex.log.warning(u'The key field was None.')
        return data
609821
def delete(self, key, sort_key):
        primary_key = key
        key = self.prefixed('{}:{}'.format(key, sort_key))
        
        self.logger.debug('Storage - delete {}'.format(key))
        if sort_key is not None:
            self.cache[self.prefixed(primary_key)].remove(sort_key)
        for index in self._secondary_indexes:
            obj = json.loads(self.cache[key])
            if index in obj.keys():
                self.cache['secondary_indexes'][index][obj[index]].remove(
                    key)
        del(self.cache[key])
        return True
1214948
def delete(self, key):
    '''
    '''
    self.cache_datastore.delete(key)
    self.child_datastore.delete(key)
1268455
def delete(self, key):
        
        if key in self.cache:
            self.cache.pop(key, None)
882391
public boolean removeKey(long key) {
	int i = indexOfKey(key);
	if (i<0) return false; // key not contained

	this.state[i]=REMOVED;
	this.values[i]=0; // delta
	this.distinct--;

	if (this.distinct < this.lowWaterMark) {
		int newCapacity = chooseShrinkCapacity(this.distinct,this.minLoadFactor, this.maxLoadFactor);
		rehash(newCapacity);
	}
	
	return true;	
}