Deletes a setting from this object's storage.
        
        The write to the database is performed immediately and the cache in the cache backend is flushed.
        The cache within this object will be updated correctly.
357606
def delete(self, key: str) -> None:
        
        if key in self._write_cache():
            self._write_cache()[key].delete()
            del self._write_cache()[key]

        if key in self._cache():
            del self._cache()[key]

        self._flush_external_cache()
1254306
def clear(self):
        
        self.database.delete(self.key)
        self.database.delete(self.event)
801437
public void setDeleted()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "setDeleted");
      SibTr.exit(tc, "setDeleted");
    }
    
    isDeleted = true;
  }
1087377
def delete(self):
        
        resp = self.r_session.delete(self.database_url)
        resp.raise_for_status()
152487
@Override
	public void clear() {
		lock.writeLock().lock();
		try {
			properties.clear();
		} finally {
			lock.writeLock().unlock();
		}
	}
62505
void flush() {
		internalLock.writeLock().lock();
		flushLock.lock();
		try {
			if (isNew || modifiedBy.size() > 0) {
				VanillaDb.logMgr().flush(lastLsn);
				contents.write(blk);
				modifiedBy.clear();
				isNew = false;
			}
		} finally {
			flushLock.unlock();
			internalLock.writeLock().unlock();
		}
	}
936617
def flush(self):
        

        self.clear()
        self.delete(self.session_key)
        self.create()
808623
public synchronized void close(boolean write) {

        if (dataFile == null) {
            return;
        }

        try {
            cache.saveAll();

            boolean empty = (dataFile.length() <= NL.length());

            dataFile.close();

            dataFile = null;

            if (empty && !cacheReadonly) {
                FileUtil.getDefaultInstance().delete(fileName);
            }
        } catch (Exception e) {
            throw Error.error(ErrorCode.FILE_IO_ERROR,
                              ErrorCode.M_TextCache_closing_file_error,
                              new Object[] {
                fileName, e
            });
        }
    }
1247510
def delete(self, name):
        
        if name in self._cache:
            del self._cache[name]
            self.writeCache()
            # TODO clean files
            return True
        return False
806687
def clear(self):
        
        self._lock.acquire()
        try:
            self._cache = []
            self._updated = False
        finally:
            self._lock.release()
1214834
def remove_setting(self, section, name, save=False):
    '''
    '''
    configfile = get_configfile()
    return _remove_setting(section, name, configfile, save)
969796
public function resetDefault()
    {
        if ($record = $this->getSettingsRecord()) {
            $record->delete();
            unset(self::$instances[$this->recordCode]);
            Cache::forget($this->getCacheKey());
        }
    }
1199346
def _sync_writes(self):
        '''
        
        '''
        for key in self._wqueue:
            val = self._cache[key]
            self._database[key] = val
        del self._wqueue
        self._wqueue = set()
        self._database.sync()
163757
def delete(key)
      deleted = @store.delete(key)
      @on_write_failure.call(key) if !deleted && @on_write_failure
      RecordCache::Base.logger.debug{ "Version Store: deleted #{key}" }
      deleted
    end
102561
def _do_write(self):
        
        with self.lock:
            self._commit_counter += 1
            if self._commit_counter >= self._commit_every:
                self._db.commit()
                self._commit_counter = 0
1264027
public function clear()
    {
        if (is_array($this->temp_properties)) {
            foreach ($this->temp_properties as $key => $value) {
                if (property_exists($this, $key)) {
                    $this->$key = $value;
                }
            }
            unset($key, $value);

            $this->temp_properties = null;
        }
    }
1047049
public static synchronized void clear() {
        for (final Map.Entry<String, Cache> entry : CACHES.entrySet()) {
            final Cache cache = entry.getValue();
            cache.clear();
            LOGGER.log(Level.TRACE, "Cleared cache [name={0}]", entry.getKey());
        }
    }