Deletes the file from the filesystem.

@throws FileNotFound
@throws \RuntimeException when cannot delete file

@param array $metadata optional metadata which should be send when write

@return bool TRUE on success
165228
public function delete($metadata = array())
    {
        $this->setMetadata($metadata);

        return $this->filesystem->delete($this->key);
    }
530495
public function removeFile($file) {
		if(!is_array($file)) {
			$file = func_get_args();
		}
		$this->begin();
		foreach($file as $item) {
			$this->run('git rm', $item, '-r');
		}
		return $this->end();
	}
1150121
public function forget($key)
    {
        $filename = $this->_hash(array($key));

        return (bool) $this->_delete($filename);
    }
7890
public function delete($path)
    {
        $path = trim($path, '/');

        if (!$this->isFile($path)) {
            $path = $this->bucket . "/" . $path;
            throw new ExceptionStorage("File {$path} Not found or Not Is File", static::E_NOT_IS_FILE);
        }

        $response = $this->clientS3->deleteObject(array(
            'Bucket' => $this->bucket,
            'Key'    => $path,
        ));

        return (bool) $response;
    }
171829
public static function delete($file)
	{
		$files = (array) $file;

		foreach ($files as $file)
		{
			$file     = Path::clean($file);
			$filename = basename($file);

			if (!Path::canChmod($file))
			{
				throw new FilesystemException(__METHOD__ . ': Failed deleting inaccessible file ' . $filename);
			}

			// Try making the file writable first. If it's read-only, it can't be deleted
			// on Windows, even if the parent folder is writable
			@chmod($file, 0777);

			// In case of restricted permissions we zap it one way or the other
			// as long as the owner is either the webserver or the ftp
			if (!@ unlink($file))
			{
				throw new FilesystemException(__METHOD__ . ': Failed deleting ' . $filename);
			}
		}

		return true;
	}
75372
private function serialize(EntityMetadata $metadata)
    {
        switch ($this->serializer) {
            case self::SERIALIZER_PHP:
                return serialize($metadata);
            case self::SERIALIZER_IGBINARY:
                return igbinary_serialize($metadata);
            default:
                throw new RuntimeException('Unable to handle serialization of the metadata object');
        }
    }
1279213
public function delete(string $key) : bool
    {
        if (!$this->cacheStore->delete($key)) {
            // Unlikely, but safer.
            throw new RuntimeException(
                'Underlying cache store type[' . get_class($this->cacheStore)
                . '] failed to delete cache item, key[' . $key . '].'
            );
        }
        return true;
    }
508062
public function setMetadata(array $metadata)
    {
        $this->metadata = $this->validator->parseMetadata(array_filter($metadata, function ($field): bool {
            // 文字列型以外の (明らかに構文解析済みである) フィールドは構文解析器にかけない
            return is_string($field);
        })) + $metadata;
    }
1238108
private function sanitizeMetaDataId(array $metaData): string
    {
        $metaDataId = $metaData[static::METADATA_ID] ?? '';
        if ('' === $metaDataId) {
            $message = 'No metadata key "id" was not found in ' . $this->filePath;

            $event = new BadMetaDataFoundEvent($this->filePath, $message);
            $this->eventDispatcher->dispatch($event::NAME, $event);

            $metaDataId = trim(basename($this->getModuleDirectoryName()), DIRECTORY_SEPARATOR);
        }

        return $metaDataId;
    }
1240075
public function deleteFile($file)
    {
        if (!$this->filesystem->has($file)) {
            return;
        }

        $this->filesystem->delete($file);
        $this->cacheManager->remove($file);
    }
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));
        }
    }
179536
public final function remove()
    {
        if ($this->exists())
        {
            if (unlink($this->getPath()))
                return true;
            throw new \Exception($this->getName() . ': Deleting failed');
        }
    }
858738
public function delete($file = null)
	{
		$file = $file ?: $this->file;
		if ($this->fs->exists($file))
			$this->fs->delete($file);
		if ($this->f3->get('CACHE')) {
			$cache = \Cache::instance();
			if($cache->exists($cacheHash = $this->getCacheHash($file)))
				$cache->clear($cacheHash);
		}
		$this->metaHandle->delete($file);
	}
53941
public function delete($fileName)
    {
        $path = $this->getPathBase($fileName);

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

        return unlink($path);
    }
745385
public function deleteMetadata($name = false)
    {
        if ($name === false) {
            $this->metadata = array();
            return true;
        }
        if (!isset($this->metadata[$name])) {
            return false;
        }
        unset($this->metadata[$name]);
        return true;
    }
1183055
public function delete($name)
  {
    $path = $this->_getPath($name);
    
    if (file_exists($path)) {
      $result = @unlink($path);
    } else {
      $result = false;
    }
    
    return $result;
  }
915545
public function setMetadata(array $metadata)
    {
        $this->getMetadata()->setData(
            array_replace_recursive(
                $this->getDefaultMetadata(),
                $metadata
            )
        );

        return $this;
    }