2018-04-17 02:11:51 +00:00
< ? php
/*
* This file is part of the Symfony package .
*
* ( c ) Fabien Potencier < fabien @ symfony . com >
*
* For the full copyright and license information , please view the LICENSE
* file that was distributed with this source code .
*/
namespace Symfony\Component\Cache\Simple ;
use Psr\Cache\CacheException as Psr6CacheException ;
2024-01-12 05:08:24 +00:00
use Psr\Cache\CacheItemPoolInterface ;
2018-04-17 02:11:51 +00:00
use Psr\SimpleCache\CacheException as SimpleCacheException ;
2024-01-12 05:08:24 +00:00
use Psr\SimpleCache\CacheInterface ;
use Symfony\Component\Cache\Adapter\AdapterInterface ;
2018-04-17 02:11:51 +00:00
use Symfony\Component\Cache\CacheItem ;
use Symfony\Component\Cache\Exception\InvalidArgumentException ;
use Symfony\Component\Cache\PruneableInterface ;
use Symfony\Component\Cache\ResettableInterface ;
use Symfony\Component\Cache\Traits\ProxyTrait ;
/**
* @ author Nicolas Grekas < p @ tchwork . com >
*/
class Psr6Cache implements CacheInterface , PruneableInterface , ResettableInterface
{
use ProxyTrait ;
private $createCacheItem ;
2024-01-12 05:08:24 +00:00
private $cacheItemPrototype ;
2018-04-17 02:11:51 +00:00
public function __construct ( CacheItemPoolInterface $pool )
{
$this -> pool = $pool ;
2024-01-12 05:08:24 +00:00
if ( ! $pool instanceof AdapterInterface ) {
return ;
2018-04-17 02:11:51 +00:00
}
2024-01-12 05:08:24 +00:00
$cacheItemPrototype = & $this -> cacheItemPrototype ;
$createCacheItem = \Closure :: bind (
static function ( $key , $value , $allowInt = false ) use ( & $cacheItemPrototype ) {
$item = clone $cacheItemPrototype ;
$item -> key = $allowInt && \is_int ( $key ) ? ( string ) $key : CacheItem :: validateKey ( $key );
$item -> value = $value ;
$item -> isHit = false ;
return $item ;
},
null ,
CacheItem :: class
);
$this -> createCacheItem = function ( $key , $value , $allowInt = false ) use ( $createCacheItem ) {
if ( null === $this -> cacheItemPrototype ) {
$this -> get ( $allowInt && \is_int ( $key ) ? ( string ) $key : $key );
}
$this -> createCacheItem = $createCacheItem ;
return $createCacheItem ( $key , $value , $allowInt );
};
2018-04-17 02:11:51 +00:00
}
/**
* { @ inheritdoc }
*/
public function get ( $key , $default = null )
{
try {
$item = $this -> pool -> getItem ( $key );
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
2024-01-12 05:08:24 +00:00
if ( null === $this -> cacheItemPrototype ) {
$this -> cacheItemPrototype = clone $item ;
$this -> cacheItemPrototype -> set ( null );
}
2018-04-17 02:11:51 +00:00
return $item -> isHit () ? $item -> get () : $default ;
}
/**
* { @ inheritdoc }
*/
public function set ( $key , $value , $ttl = null )
{
try {
if ( null !== $f = $this -> createCacheItem ) {
$item = $f ( $key , $value );
} else {
$item = $this -> pool -> getItem ( $key ) -> set ( $value );
}
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
if ( null !== $ttl ) {
$item -> expiresAfter ( $ttl );
}
return $this -> pool -> save ( $item );
}
/**
* { @ inheritdoc }
*/
public function delete ( $key )
{
try {
return $this -> pool -> deleteItem ( $key );
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
}
/**
* { @ inheritdoc }
*/
public function clear ()
{
return $this -> pool -> clear ();
}
/**
* { @ inheritdoc }
*/
public function getMultiple ( $keys , $default = null )
{
if ( $keys instanceof \Traversable ) {
$keys = iterator_to_array ( $keys , false );
2024-01-12 05:08:24 +00:00
} elseif ( ! \is_array ( $keys )) {
throw new InvalidArgumentException ( sprintf ( 'Cache keys must be array or Traversable, "%s" given.' , \is_object ( $keys ) ? \get_class ( $keys ) : \gettype ( $keys )));
2018-04-17 02:11:51 +00:00
}
try {
$items = $this -> pool -> getItems ( $keys );
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
2024-01-12 05:08:24 +00:00
$values = [];
2018-04-17 02:11:51 +00:00
foreach ( $items as $key => $item ) {
$values [ $key ] = $item -> isHit () ? $item -> get () : $default ;
}
return $values ;
}
/**
* { @ inheritdoc }
*/
public function setMultiple ( $values , $ttl = null )
{
2024-01-12 05:08:24 +00:00
$valuesIsArray = \is_array ( $values );
2018-04-17 02:11:51 +00:00
if ( ! $valuesIsArray && ! $values instanceof \Traversable ) {
2024-01-12 05:08:24 +00:00
throw new InvalidArgumentException ( sprintf ( 'Cache values must be array or Traversable, "%s" given.' , \is_object ( $values ) ? \get_class ( $values ) : \gettype ( $values )));
2018-04-17 02:11:51 +00:00
}
2024-01-12 05:08:24 +00:00
$items = [];
2018-04-17 02:11:51 +00:00
try {
if ( null !== $f = $this -> createCacheItem ) {
$valuesIsArray = false ;
foreach ( $values as $key => $value ) {
$items [ $key ] = $f ( $key , $value , true );
}
} elseif ( $valuesIsArray ) {
2024-01-12 05:08:24 +00:00
$items = [];
2018-04-17 02:11:51 +00:00
foreach ( $values as $key => $value ) {
$items [] = ( string ) $key ;
}
$items = $this -> pool -> getItems ( $items );
} else {
foreach ( $values as $key => $value ) {
2024-01-12 05:08:24 +00:00
if ( \is_int ( $key )) {
2018-04-17 02:11:51 +00:00
$key = ( string ) $key ;
}
$items [ $key ] = $this -> pool -> getItem ( $key ) -> set ( $value );
}
}
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
$ok = true ;
foreach ( $items as $key => $item ) {
if ( $valuesIsArray ) {
$item -> set ( $values [ $key ]);
}
if ( null !== $ttl ) {
$item -> expiresAfter ( $ttl );
}
$ok = $this -> pool -> saveDeferred ( $item ) && $ok ;
}
return $this -> pool -> commit () && $ok ;
}
/**
* { @ inheritdoc }
*/
public function deleteMultiple ( $keys )
{
if ( $keys instanceof \Traversable ) {
$keys = iterator_to_array ( $keys , false );
2024-01-12 05:08:24 +00:00
} elseif ( ! \is_array ( $keys )) {
throw new InvalidArgumentException ( sprintf ( 'Cache keys must be array or Traversable, "%s" given.' , \is_object ( $keys ) ? \get_class ( $keys ) : \gettype ( $keys )));
2018-04-17 02:11:51 +00:00
}
try {
return $this -> pool -> deleteItems ( $keys );
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
}
/**
* { @ inheritdoc }
*/
public function has ( $key )
{
try {
return $this -> pool -> hasItem ( $key );
} catch ( SimpleCacheException $e ) {
throw $e ;
} catch ( Psr6CacheException $e ) {
throw new InvalidArgumentException ( $e -> getMessage (), $e -> getCode (), $e );
}
}
}