PHP Util::contentSize方法代码示例

 /**
  * @inheritdoc
  */
 public function getSize($path)
 {
     if (!($decrypted = $this->read($path))) {
         return false;
     }
     $size = Util::contentSize($decrypted['contents']);
     return compact('path', 'size');
 }

 /**
  * Write a file
  *
  * @param   string  $path
  * @param   string  $contents
  * @param   mixed   $config
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)), $config);
     $result = $this->client->putObject($options);
     if ($result === false) {
         return false;
     }
     return $this->normalizeObject($options);
 }

 /**
  * Write a file
  *
  * @param   string  $path
  * @param   string  $contents
  * @param   mixed   $config
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::contentMimetype($contents), 'ContentLength' => Util::contentSize($contents)));
     if ($visibility = $config->get('visibility')) {
         $options['ACL'] = $visibility === AdapterInterface::VISIBILITY_PUBLIC ? 'public-read' : 'private';
     }
     $this->client->putObject($options);
     if ($visibility) {
         $options['visibility'] = $visibility;
     }
     return $this->normalizeObject($options);
 }

 /**
  * Upload an object.
  *
  * @param        $path
  * @param        $body
  * @param Config $config
  *
  * @return array
  */
 protected function upload($path, $body, Config $config)
 {
     $key = $this->applyPathPrefix($path);
     $options = $this->getOptionsFromConfig($config);
     $acl = isset($options['ACL']) ? $options['ACL'] : 'private';
     if (!isset($options['ContentType']) && is_string($body)) {
         $options['ContentType'] = Util::guessMimeType($path, $body);
     }
     if (!isset($options['ContentLength'])) {
         $options['ContentLength'] = is_string($body) ? Util::contentSize($body) : Util::getStreamSize($body);
     }
     $this->s3Client->upload($this->bucket, $key, $body, $acl, ['params' => $options]);
     return $this->normalizeResponse($options, $key);
 }

 /**
  * {@inheritdoc}
  */
 public function write($path, $contents, Config $config)
 {
     $options = $this->getOptions($path, ['Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)], $config);
     return $this->writeObject($options);
 }

 /**
  * Write a new file.
  *
  * @param string $path
  * @param string $contents
  * @param Config $config Config object
  * @return array|false false on failure file meta data on success
  */
 public function write($path, $contents, Config $config)
 {
     $object = $this->applyPathPrefix($path);
     $options = $this->getOptionsFromConfig($config);
     if (!isset($options[OssClient::OSS_LENGTH])) {
         $options[OssClient::OSS_LENGTH] = Util::contentSize($contents);
     }
     if (!isset($options[OssClient::OSS_CONTENT_TYPE])) {
         $options[OssClient::OSS_CONTENT_TYPE] = Util::guessMimeType($path, $contents);
     }
     try {
         $this->client->putObject($this->bucket, $object, $contents, $options);
     } catch (OssException $e) {
         return false;
     }
     $type = 'file';
     $result = compact('type', 'path', 'contents');
     $result['mimetype'] = $options[OssClient::OSS_CONTENT_TYPE];
     $result['size'] = $options[OssClient::OSS_LENGTH];
     return $result;
 }

 /**
  * {@inheritdoc}
  */
 public function getMetadata($path)
 {
     $info = $this->getPathInfo($path);
     if (!$this->has($path)) {
         throw new \League\Flysystem\FileNotFoundException("File not found at path: {$info['path']}");
     }
     $metadata = json_decode($this->redis->hget($this->applyPathPrefix($info['dirname']), $info['basename']), TRUE);
     if ($metadata['type'] === 'file') {
         $metadata['contents'] = base64_decode($metadata['contents']);
         $metadata += ['size' => Util::contentSize($metadata['contents']), 'mimetype' => Util::guessMimeType($metadata['path'], $metadata['contents'])];
         unset($metadata['contents']);
     }
     return $metadata;
 }

 /**
  * {@inheritdoc}
  */
 public function write($path, $contents, Config $config)
 {
     $options = $this->getOptions($path, ['Content' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)], $config);
     if ($this->client->putObject($options) === false) {
         var_dump(11);
         exit;
         return false;
     }
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function write($path, $contents, Config $config)
 {
     $options = $this->getOptions($path, ['Content' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)], $config);
     try {
         if ($this->client->putObject($options) === false) {
             return false;
         }
         return true;
     } catch (OSSException $e) {
         return false;
     } catch (ClientException $e) {
         return false;
     }
 }

 /**
  * Write a file
  *
  * @param   string  $path
  * @param   string  $contents
  * @param   mixed   $config
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $mimeType = Util::guessMimeType($path, $contents);
     if (isset($config)) {
         if (isset($config["mimeType"])) {
             $mimeType = $config["mimeType"];
         }
     }
     $config = Util::ensureConfig($config);
     $options = $this->getOptions($path, array('ContentType' => $mimeType, 'ContentLength' => Util::contentSize($contents)), $config);
     $dirname = dirname($path);
     $filename = basename($path);
     if ($this->has($path)) {
         $isUpdate = true;
         $file = $this->service->files->get($path);
     } else {
         $file = new Google_Service_Drive_DriveFile();
         $file->setTitle($filename);
         $file->setMimeType($mimeType);
         if ($dirname != ".") {
             $parent = new Google_Service_Drive_ParentReference();
             $parent->setId($dirname);
             $file->setParents(array($parent));
         }
     }
     if (isset($isUpdate)) {
         $result = $this->service->files->update($file['id'], $file, array('data' => $contents, 'mimeType' => $mimeType, 'uploadType' => "multipart"));
     } else {
         $result = $this->service->files->insert($file, array('data' => $contents, 'mimeType' => $mimeType, 'uploadType' => "multipart"));
     }
     if ($result === false) {
         return false;
     }
     $result['mimeType'] = $mimeType;
     $result['title'] = $filename;
     $result['id'] = $result->getId();
     return $this->normalizeObject($result);
 }

 /**
  * Write a file
  *
  * @param   string $path
  * @param   string $contents
  * @param   mixed  $config
  *
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)), $config = Util::ensureConfig($config));
     return $this->writeObject($options);
 }

 protected function kvPut($path, $contents, Config $config, $file = null)
 {
     $addOrSet = is_null($file) ? 'set' : 'add';
     $file['contents'] = $contents;
     $file['timestamp'] = time();
     $file['size'] = Util::contentSize($contents);
     if ($visibility = $config->get('visibility')) {
         $file['visibility'] = $visibility;
     }
     if ($this->client->{$addOrSet}($path, $file)) {
         return $file + compact('path');
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function update($path, $contents, Config $config)
 {
     if (!$this->hasFile($path)) {
         return false;
     }
     $this->storage[$path]['contents'] = $contents;
     $this->storage[$path]['timestamp'] = time();
     $this->storage[$path]['size'] = Util::contentSize($contents);
     $this->storage[$path]['mimetype'] = Util::guessMimeType($path, $contents);
     if ($visibility = $config->get('visibility')) {
         $this->setVisibility($path, $visibility);
     }
     return $this->getMetadata($path);
 }

 /**
  * Write a file
  *
  * @param   string $path
  * @param   string $contents
  * @param   mixed  $config
  *
  * @return  array   file metadata
  */
 public function write($path, $contents, $config = null)
 {
     $options = $this->getOptions($path, array('Body' => $contents, 'ContentType' => Util::guessMimeType($path, $contents), 'ContentLength' => Util::contentSize($contents)), Util::ensureConfig($config));
     $multipartLimit = $this->mbToBytes($options['Multipart']);
     if ($options['ContentLength'] > $multipartLimit) {
         $result = $this->putObjectMultipart($options);
     } else {
         $result = $this->client->putObject($options);
     }
     if ($result === false) {
         return false;
     }
     return $this->normalizeObject($options);
 }

 /**
  * {@inheritdoc}
  */
 public function update($path, $contents, Config $config)
 {
     if (!$this->hasFile($path)) {
         return false;
     }
     $this->storage[$path]['contents'] = $contents;
     $this->storage[$path]['timestamp'] = time();
     $this->storage[$path]['size'] = Util::contentSize($contents);
     if ($visibility = $config->get('visibility')) {
         $this->storage[$path]['visibility'] = $visibility;
     }
     return $this->storage[$path] + compact('path');
 }