End.
@param  string $key
@return void
@throws Oppa\Exception\InvalidKeyException
351308
public function end(string $key): void
    {
        if (!isset($this->profiles[$key])) {
            throw new InvalidKeyException("Could not find a profile with given '{$key}' key!");
        }

        $end = microtime(true);
        switch ($key) {
            case 'connection':
                $this->profiles['connection']['end'] = $end;
                $this->profiles['connection']['time'] = round($end - $this->profiles['connection']['start'], 10);
                break;
            case 'query':
                $i = $this->queryCount;
                if (isset($this->profiles['query'][$i])) {
                    $this->profiles['query'][$i]['end'] = $end;
                    $this->profiles['query'][$i]['time'] = round($end - $this->profiles['query'][$i]['start'], 10);
                }
                break;
            default:
                throw new InvalidKeyException("Unimplemented key '{$key}' given, available keys are"
                    ." 'connection,query' only!");
        }
    }
409336
public static function delete( $key ) {

		if ( isset( self::$config[ strtolower( $key ) ] ) ) {
			unset( self::$config[ strtolower( $key ) ] );
		}

	}
1149398
public function stop($key, $timetamp = null)
    {
        $event = new End($key, $timetamp);
        $this->dispatcher->dispatch(End::EVENT_NAME, $event);
    }
1141916
public function delete($key)
    {
		if (! $key || ! is_string($key)) {
			throw new InvalidArgumentException('Invalid cache key');
		}

		$transientKey = $this->generateTransientKey($key);
		delete_transient($transientKey);
	}
842332
public function remove($key)
    {
        $method = 'remove'.$key;

        if (method_exists($this, $method)) {
            $this->$method();
        } else {
            unset($this->metas[$key]);
        }
    }
1374252
public function remove($key)
    {
        $this->load();

        if ($this->exists($key)) {
            unset($this->config[$key]);
            return true;
        } else {
            throw new RuntimeException(sprintf('Attempted to read non-existing key "%s"', $key));
        }
    }
696660
public function offsetUnset($key)
    {
        if ($this->root) {
            $this->root = $this->root->remove($key, $this->comparator);
        }
    }
915049
public static function end($name, $key = null){

        if ($key) {
            $GLOBALS[ARX_HOOK][$name][$key] = ob_get_contents();
        } else {
            $GLOBALS[ARX_HOOK][$name] = ob_get_contents();
        }

        ob_end_clean();
    }
280139
public function forget($key)
    {
        parent::forget($key);

        // because the database store cannot store empty arrays, remove empty
        // arrays to keep data consistent before and after saving
        $segments = explode('.', $key);
        array_pop($segments);

        while ( ! empty($segments)) {
            $segment = implode('.', $segments);

            // non-empty array - exit out of the loop
            if ($this->get($segment)) break;

            // remove the empty array and move on to the next segment
            $this->forget($segment);
            array_pop($segments);
        }

        return $this;
    }
852985
public function end($name = self::DEFAULT_NAME)
    {
        $this->end_time[$name] = microtime(true);
        $this->memory_usage[$name] = memory_get_usage(true);
    }
820925
public function remove($key)
    {
        $keyGen = $this->generateKey($key);
        $this->cache->remove($keyGen);
        @unlink($this->getFilePath($keyGen));
    }
745143
public function delete($key)
    {
        if (strpos($key, '*') !== false) {
            $this->deleteGlob($key);
        } else {
            $this->client->del([$key]);
        }
    }
688149
public function forget($key)
    {
        if (strpos($key, '.') !== false) {
            $this->forgetSubKey($key);
        } else {
            $this->forgetByKey($key);
        }

        $this->resetLang();
    }
669096
public function destroy(string $key): void
    {
        $key = $this->getKey($key);

        cache()->forget($key);
    }
128170
public static function destroy($key = '')
    {
        if (self::$_sessionStarted == true) {

            if (empty($key)) {
                session_unset();
                session_destroy();
            } else {
                self::setPrefix();
                unset($_SESSION[self::$_sessionPrefix . $key]);
            }
        }
    }
1078004
protected function validateKey(/*# string */ &$key)
    {
        // validate key
        if (is_string($key)) {
            $key = trim($key);
            return;
        }

        // throw exception
        throw new InvalidArgumentException(
            Message::get(Message::CACHE_INVALID_KEY, $key),
            Message::CACHE_INVALID_KEY
        );
    }
840102
public function release($key)
    {
        if (isset($this->resources[$key])) {
            $fd = $this->resources[$key];
            unset($this->resources[$key]);
            @flock($fd, LOCK_UN);
            @fclose($fd);
            try {
                @unlink($this->getFilenameForMutexKey($key));
            } catch (Exception $x) {
            }
        }
    }