Key deletion.

@param string Key ID

@return mixed True on success or enigma_error
976450
public function delete_key($keyid)
    {
        // delete public key
        $result = $this->delete_pubkey($keyid);

        // error handling
        if ($result !== true) {
            $code = $result->getCode();

            // if not found, delete private key
            if ($code == enigma_error::KEYNOTFOUND) {
                $result = $this->delete_privkey($keyid);
            }
            // need to delete private key first
            else if ($code == enigma_error::DELKEY) {
                $result = $this->delete_privkey($keyid);

                if ($result === true) {
                    $result = $this->delete_pubkey($keyid);
                }
            }
        }

        return $result;
    }
800051
public function delete($key)
    {
        try {
            return (bool) $this->db->from($this->table)
                    ->where($this->columns['key'])->eq($this->prefix . $key)
                    ->delete();
        } catch (PDOException $e) {
            return false;
        }
    }
650810
public function deleteById($id)
    {
        $this->validateTableAndIdentityColumn();
        // If the soft delete is activated
        if ($this->deleteColumnName) {
            $query = <<<EOQ
UPDATE {$this->getTableName()}
SET {$this->deleteColumnName} = 1
WHERE {$this->escapeCharacter}{$this->identityColumn}{$this->escapeCharacter} = %s
EOQ;
        } else {
            $query = <<<EOQ
DELETE FROM {$this->getTableName()}
WHERE {$this->escapeCharacter}{$this->identityColumn}{$this->escapeCharacter} = %s
EOQ;
        }

        $params = array('identity' => $id);

        return (bool)$this->db->query($query, $params);
    }
76028
public function deleteValue($key)
    {
        $this->ssdbHandle->hdel($this->cache_keys_hash, $key);
        return $this->ssdbHandle->del($key);
    }
69886
public function delete($key) {
        if (!is_array($key)) {
            $key = array('key' => $key);
        }
        $key = $key['key'];
        $result = isset($this->store[$key]);
        unset($this->store[$key]);
        if ($this->maxsize !== false) {
            $this->storecount--;
        }
        return $result;
    }
1100077
public function remove($key) {
       if (!isset($this->hashmap[$key])) { return false; }
       $nodeToRemove = $this->hashmap[$key];
       $this->detach($nodeToRemove);
       unset($this->hashmap[$nodeToRemove->getKey()]);
       return true;
     }
1075771
protected function deleteValue($key)
    {
        $this->db->getCollection($this->cacheCollection)->remove(['id' => $key]);
        return true;
    }
663871
public function removeKey($key)
    {
        if ($this->hasKey($key)) {
            unset($this->container[$key]);
            return true;
        } else {
            return false;
        }
    }
185225
public function delete($key)
    {
        $filePath = $this->getFilePathFromKey($key);

        if (!file_exists($filePath)) {
            return false;
        }

        return unlink($filePath);
    }
820298
public function deleteEntryByKey($key)
    {
        $pattern = $this->indexDir . '*' . DIRECTORY_SEPARATOR . substr($key, 0, 2) . DIRECTORY_SEPARATOR . substr($key,
                2, 2) . DIRECTORY_SEPARATOR . substr($key, 4, 2) . DIRECTORY_SEPARATOR . 'index.db';

        $result = glob($pattern);

        if (!$result) {
            return false;
        }

        foreach ($result as $index) {
            // open the index for reading only
            $h = fopen($index, 'r');

            // try to find the key and remove it if found
            // we read 42 chars because the key is hashed using md5 (32 chars) + 10 chars for ttl
            $buffer = '';
            $indexFound = false;
            while (($i = fread($h, 42))) {
                if ($i != $key) {
                    $buffer .= $i;
                } else {
                    $indexFound = true;
                }
            }

            // close the handler
            fclose($h);

            // update the index
            if ($indexFound) {
                file_put_contents($index, $buffer);

                return true;
            }
        }

        return false;
    }
670638
public function delete($key){
        $url = $this->authenticationService->getServerEndPoint() . Endpoints::VERSION . Endpoints::BASE_META . Endpoints::META;

        $result = $this->authenticationService->getTransport()->fetch($url,array("key"=>$key),'DELETE',array(),0);

        return $result["code"] == APIResponse::RESPONSE_SUCCESS;
    }
259700
public function del($key)
    {
        if ($this->isMappedKey($key)) {
            return false;
        } else {
            $success = true;
            if ($this->hasMaxSize()) {
                $fields = $this->getDriver()->hGetAll($key);
                if (!empty($fields)) {
                    foreach ($fields as $subKey => $value) {
                        if ($this->isSplit($value)) {
                            $success = $success && $this->deleteMappedKey($subKey, $value);
                        }
                    }
                }
                $success = $success && $this->deleteMappedKey($key);
            }

            return $success && $this->getDriver()->del($key);
        }
    }
42175
public function delete($key = '')
    {
        $node = $this->mainNode->getByKey($key);
        if (empty($node)) return $this->mainNode;
        $this->mainNode->children->removeNode($node);
        unset($node);

        return $this->mainNode;
    }
638064
public function remove($id)
    {
        if (true === $result = @unlink($this->getCacheFile($id))) {
            $this->log('debug', sprintf('Cache data removed for id `%s`.', $id));
        }

        return $result;
    }
1232394
def delete_key(self, key_id):
        
        key = self.key(key_id)
        if key:
            return key.delete()
        return False
10116
public function delete($key)
    {
        if (!$this->enabled)
            return true;

        $this->Logger->debug("Delete key: {$key}");

        $ret = @$this->getConnection()->delete($this->key($key));

        $this->Logger->debug("". (($ret) ? "Successful" : "Failed to") . " delete '{$key}'\n");

        return $ret;
    }
330245
public function remove( $key )
	{
		if( !$this->has( $key ) )																	//  pair key is not existing
			return FALSE;																			//  indicate miss
		$key	= !$this->caseSensitive ? strtolower( $key ) : $key;								//  lowercase key if dictionary is not case sensitive
		$index	= array_search( $key, array_keys( $this->pairs ) );									//  index of pair to be removed
		if( $index >= $this->position )																//  iterator position is beyond pair
			$this->position--;																		//  decrease iterator position since pair is removed
		unset( $this->pairs[$key] );																//  remove pair by its key
		return TRUE;																				//  indicate hit
	}