Deletes a queue.

@link http://msdn.microsoft.com/en-us/library/windowsazure/hh780747

@param string $queuePath The path of the queue
357425
public function deleteQueue($queuePath)
    {
        Validate::isString($queuePath, 'queuePath');
        Validate::notNullOrEmpty($queuePath, 'queuePath');

        $httpCallContext = new HttpCallContext();
        $httpCallContext->setMethod(Resources::HTTP_DELETE);
        $httpCallContext->addStatusCode(Resources::STATUS_OK);
        $httpCallContext->setPath($queuePath);

        $this->sendHttpContext($httpCallContext);
    }
37389
protected function queueDeclare($queue)
    {
        $this->channel->queue_declare($queue, false, true, false, false);
    }
261738
public function delete($name)
    {
        try {
            $id = $this->getQueueId($name);
        } catch (RuntimeException $e) {
            return false;
        }

        try {
            $this->db->delete('Queues', ['queue_id' => $id]);
        } catch (Exception $e) {
            throw new RuntimeException($e->getMessage(), $e->getCode(), $e);
        }

        return true;
    }
126796
public function purgeQueue($queueName = '')
    {
        if (! in_array($queueName, $this->config['queues'])) {
            throw new ModuleException(__CLASS__, "'$queueName' doesn't exist in queues config list");
        }

        $this->getChannel()->queue_purge($queueName, true);
    }
286680
protected function queueSomeForDeletion($styles)
    {
        $filePaths = array_map(function ($style) {
            return $this->path($style);
        }, $styles);

        $this->setQueue('deletion', $filePaths);
    }
1369716
public function deleteFile($filePath)
    {
        $filePath = realpath($filePath);

        // Check if it is an actual file and if it is writable.
        if (is_file($filePath) === true) {
            set_error_handler(
                function () {
                /* do nothing */
                }
            );
            // Make sure it is unlinkable.
            chmod($filePath, 0777);
            if (unlink($filePath) === true) {
                restore_error_handler();
                return;
            }

            // We have a permission problem here!
            $this->pool->messages->addMessage('fileserviceDelete', array($this->filterFilePath($filePath)));
            restore_error_handler();
        }
    }
967949
protected function queueAllForDeletion()
    {
        // If no file is currently stored, don't delete anything.
        if ( ! $this->originalFilename()) {
            return;
        }

        $this->deleteTarget    = $this->makeTargetInstanceWithCurrentData();
        $this->queuedForDelete = array_unique(array_merge($this->queuedForDelete, $this->variants(true)));
    }
802241
public function removeEmptyDirectory($directoryPath)
    {
        if (is_dir($directoryPath) && $this->isDirEmpty($directoryPath)) {
            if (!$this->removeDirectory($directoryPath)) {
                // @codeCoverageIgnoreStart
                throw new \RuntimeException('Unable to remove the directory : ' . $directoryPath);
                // @codeCoverageIgnoreEnd
            }

            return true;
        }

        return false;
    }
479086
public function deleteReserved($queue, $id)
    {
        $this->database->trans_begin();

        if ($this->getQueryBuilder()->from($this->table)->lockForUpdate()->find($id)) {
            $this->getQueryBuilder()->from($this->table)->where('id', $id)->delete();
        }

        $this->database->trans_commit();
    }
966880
function delete_file($filepath)
	{
		if ( ! $this->_is_conn())
		{
			return false;
		}

		$result = @ftp_delete($this->_conn_id, $filepath);

		if ($result === false)
		{
			if ($this->_debug == true)
			{
				throw new \FtpFileAccessException('Unable to delete');
			}
			return false;
		}

		return true;
	}
188628
protected function deleteInSolrAndRemoveFromIndexQueue($table, $uid)
    {
        $this->deleteIndexDocuments($table, $uid);
        $this->queue->deleteItem($table, $uid);
    }
1270079
@Override
	public final void deleteTemporaryQueue(String queueName) throws JMSException
    {
        engine.deleteQueue(queueName);
        unregisterTemporaryQueue(queueName);
    }
282522
public static function purge($path)
    {
        if (is_dir($path)) {
            foreach (scandir($path) as $item) {
                if (('.' === $item) || ('..' === $item)) {
                    continue;
                }

                self::purge($path . DIRECTORY_SEPARATOR . $item);
            }

            if (!rmdir($path)) {
                throw new RuntimeException(
                    sprintf(
                        'The directory "%s" could not be deleted.',
                        $path
                    )
                );
            }
        } else {
            if (!unlink($path)) {
                throw new RuntimeException(
                    sprintf(
                        'The file "%s" could not be deleted.',
                        $path
                    )
                );
            }
        }
    }
65348
public function deleteMessage($queue, $id)
    {
        $this->pheanstalk->useTube($this->getQueue($queue))->delete($id);
    }
813242
public static function delete(string $path)
    {
        if (trim($path) === '') {
            throw new \InvalidArgumentException('$path is not a string or is whitespace');
        }

        if (!file_exists($path)) {
            return;
        }

        try {
            self::throwIfFalse(unlink($path), "unlink returned false for '{$path}'");
        } catch (\Exception $e) {
            if (file_exists($path)) {
                throw $e;
            }
        }
    }
866113
public function remove($queueName)
    {
        $queue = null;
        if (isset($this->queues[$queueName])) {
            $queue = $this->queues[$queueName];
        }
        unset($this->queues[$queueName]);

        return $queue;
    }
259817
public function removePath($path)
	{
		$path = rtrim($path, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
		$this->finder->removePath($path);

		if ($this->environment)
		{
			$this->finder->removePath($path.$this->environment);
		}
	}