Page Menu
Home
WickedGov Phorge
Search
Configure Global Search
Log In
Files
F7415712
CacheAdapter.php
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Flag For Later
Award Token
Size
8 KB
Referenced Files
None
Subscribers
None
CacheAdapter.php
View Options
<?php
namespace
Doctrine\Common\Cache\Psr6
;
use
Doctrine\Common\Cache\Cache
;
use
Doctrine\Common\Cache\ClearableCache
;
use
Doctrine\Common\Cache\MultiDeleteCache
;
use
Doctrine\Common\Cache\MultiGetCache
;
use
Doctrine\Common\Cache\MultiPutCache
;
use
Psr\Cache\CacheItemInterface
;
use
Psr\Cache\CacheItemPoolInterface
;
use
Symfony\Component\Cache\DoctrineProvider
as
SymfonyDoctrineProvider
;
use
function
array_key_exists
;
use
function
assert
;
use
function
count
;
use
function
current
;
use
function
get_class
;
use
function
gettype
;
use
function
is_object
;
use
function
is_string
;
use
function
microtime
;
use
function
sprintf
;
use
function
strpbrk
;
use
const
PHP_VERSION_ID
;
final
class
CacheAdapter
implements
CacheItemPoolInterface
{
private
const
RESERVED_CHARACTERS
=
'{}()/
\@
:'
;
/** @var Cache */
private
$cache
;
/** @var array<CacheItem|TypedCacheItem> */
private
$deferredItems
=
[];
public
static
function
wrap
(
Cache
$cache
):
CacheItemPoolInterface
{
if
(
$cache
instanceof
DoctrineProvider
&&
!
$cache
->
getNamespace
())
{
return
$cache
->
getPool
();
}
if
(
$cache
instanceof
SymfonyDoctrineProvider
&&
!
$cache
->
getNamespace
())
{
$getPool
=
function
()
{
// phpcs:ignore Squiz.Scope.StaticThisUsage.Found
return
$this
->
pool
;
};
return
$getPool
->
bindTo
(
$cache
,
SymfonyDoctrineProvider
::
class
)();
}
return
new
self
(
$cache
);
}
private
function
__construct
(
Cache
$cache
)
{
$this
->
cache
=
$cache
;
}
/** @internal */
public
function
getCache
():
Cache
{
return
$this
->
cache
;
}
/**
* {@inheritDoc}
*/
public
function
getItem
(
$key
):
CacheItemInterface
{
assert
(
self
::
validKey
(
$key
));
if
(
isset
(
$this
->
deferredItems
[
$key
]))
{
$this
->
commit
();
}
$value
=
$this
->
cache
->
fetch
(
$key
);
if
(
PHP_VERSION_ID
>=
80000
)
{
if
(
$value
!==
false
)
{
return
new
TypedCacheItem
(
$key
,
$value
,
true
);
}
return
new
TypedCacheItem
(
$key
,
null
,
false
);
}
if
(
$value
!==
false
)
{
return
new
CacheItem
(
$key
,
$value
,
true
);
}
return
new
CacheItem
(
$key
,
null
,
false
);
}
/**
* {@inheritDoc}
*/
public
function
getItems
(
array
$keys
=
[]):
array
{
if
(
$this
->
deferredItems
)
{
$this
->
commit
();
}
assert
(
self
::
validKeys
(
$keys
));
$values
=
$this
->
doFetchMultiple
(
$keys
);
$items
=
[];
if
(
PHP_VERSION_ID
>=
80000
)
{
foreach
(
$keys
as
$key
)
{
if
(
array_key_exists
(
$key
,
$values
))
{
$items
[
$key
]
=
new
TypedCacheItem
(
$key
,
$values
[
$key
],
true
);
}
else
{
$items
[
$key
]
=
new
TypedCacheItem
(
$key
,
null
,
false
);
}
}
return
$items
;
}
foreach
(
$keys
as
$key
)
{
if
(
array_key_exists
(
$key
,
$values
))
{
$items
[
$key
]
=
new
CacheItem
(
$key
,
$values
[
$key
],
true
);
}
else
{
$items
[
$key
]
=
new
CacheItem
(
$key
,
null
,
false
);
}
}
return
$items
;
}
/**
* {@inheritDoc}
*/
public
function
hasItem
(
$key
):
bool
{
assert
(
self
::
validKey
(
$key
));
if
(
isset
(
$this
->
deferredItems
[
$key
]))
{
$this
->
commit
();
}
return
$this
->
cache
->
contains
(
$key
);
}
public
function
clear
():
bool
{
$this
->
deferredItems
=
[];
if
(!
$this
->
cache
instanceof
ClearableCache
)
{
return
false
;
}
return
$this
->
cache
->
deleteAll
();
}
/**
* {@inheritDoc}
*/
public
function
deleteItem
(
$key
):
bool
{
assert
(
self
::
validKey
(
$key
));
unset
(
$this
->
deferredItems
[
$key
]);
return
$this
->
cache
->
delete
(
$key
);
}
/**
* {@inheritDoc}
*/
public
function
deleteItems
(
array
$keys
):
bool
{
foreach
(
$keys
as
$key
)
{
assert
(
self
::
validKey
(
$key
));
unset
(
$this
->
deferredItems
[
$key
]);
}
return
$this
->
doDeleteMultiple
(
$keys
);
}
public
function
save
(
CacheItemInterface
$item
):
bool
{
return
$this
->
saveDeferred
(
$item
)
&&
$this
->
commit
();
}
public
function
saveDeferred
(
CacheItemInterface
$item
):
bool
{
if
(!
$item
instanceof
CacheItem
&&
!
$item
instanceof
TypedCacheItem
)
{
return
false
;
}
$this
->
deferredItems
[
$item
->
getKey
()]
=
$item
;
return
true
;
}
public
function
commit
():
bool
{
if
(!
$this
->
deferredItems
)
{
return
true
;
}
$now
=
microtime
(
true
);
$itemsCount
=
0
;
$byLifetime
=
[];
$expiredKeys
=
[];
foreach
(
$this
->
deferredItems
as
$key
=>
$item
)
{
$lifetime
=
(
$item
->
getExpiry
()
??
$now
)
-
$now
;
if
(
$lifetime
<
0
)
{
$expiredKeys
[]
=
$key
;
continue
;
}
++
$itemsCount
;
$byLifetime
[(
int
)
$lifetime
][
$key
]
=
$item
->
get
();
}
$this
->
deferredItems
=
[];
switch
(
count
(
$expiredKeys
))
{
case
0
:
break
;
case
1
:
$this
->
cache
->
delete
(
current
(
$expiredKeys
));
break
;
default
:
$this
->
doDeleteMultiple
(
$expiredKeys
);
break
;
}
if
(
$itemsCount
===
1
)
{
return
$this
->
cache
->
save
(
$key
,
$item
->
get
(),
(
int
)
$lifetime
);
}
$success
=
true
;
foreach
(
$byLifetime
as
$lifetime
=>
$values
)
{
$success
=
$this
->
doSaveMultiple
(
$values
,
$lifetime
)
&&
$success
;
}
return
$success
;
}
public
function
__destruct
()
{
$this
->
commit
();
}
/**
* @param mixed $key
*/
private
static
function
validKey
(
$key
):
bool
{
if
(!
is_string
(
$key
))
{
throw
new
InvalidArgument
(
sprintf
(
'Cache key must be string, "%s" given.'
,
is_object
(
$key
)
?
get_class
(
$key
)
:
gettype
(
$key
)));
}
if
(
$key
===
''
)
{
throw
new
InvalidArgument
(
'Cache key length must be greater than zero.'
);
}
if
(
strpbrk
(
$key
,
self
::
RESERVED_CHARACTERS
)
!==
false
)
{
throw
new
InvalidArgument
(
sprintf
(
'Cache key "%s" contains reserved characters "%s".'
,
$key
,
self
::
RESERVED_CHARACTERS
));
}
return
true
;
}
/**
* @param mixed[] $keys
*/
private
static
function
validKeys
(
array
$keys
):
bool
{
foreach
(
$keys
as
$key
)
{
self
::
validKey
(
$key
);
}
return
true
;
}
/**
* @param mixed[] $keys
*/
private
function
doDeleteMultiple
(
array
$keys
):
bool
{
if
(
$this
->
cache
instanceof
MultiDeleteCache
)
{
return
$this
->
cache
->
deleteMultiple
(
$keys
);
}
$success
=
true
;
foreach
(
$keys
as
$key
)
{
$success
=
$this
->
cache
->
delete
(
$key
)
&&
$success
;
}
return
$success
;
}
/**
* @param mixed[] $keys
*
* @return mixed[]
*/
private
function
doFetchMultiple
(
array
$keys
):
array
{
if
(
$this
->
cache
instanceof
MultiGetCache
)
{
return
$this
->
cache
->
fetchMultiple
(
$keys
);
}
$values
=
[];
foreach
(
$keys
as
$key
)
{
$value
=
$this
->
cache
->
fetch
(
$key
);
if
(!
$value
)
{
continue
;
}
$values
[
$key
]
=
$value
;
}
return
$values
;
}
/**
* @param mixed[] $keysAndValues
*/
private
function
doSaveMultiple
(
array
$keysAndValues
,
int
$lifetime
=
0
):
bool
{
if
(
$this
->
cache
instanceof
MultiPutCache
)
{
return
$this
->
cache
->
saveMultiple
(
$keysAndValues
,
$lifetime
);
}
$success
=
true
;
foreach
(
$keysAndValues
as
$key
=>
$value
)
{
$success
=
$this
->
cache
->
save
(
$key
,
$value
,
$lifetime
)
&&
$success
;
}
return
$success
;
}
}
File Metadata
Details
Attached
Mime Type
text/x-php
Expires
Sun, Nov 22, 02:19 (1 d, 13 h)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
94/dd/5f6849a12e5eb9145769a7de43f9
Default Alt Text
CacheAdapter.php (8 KB)
Attached To
Mode
rMWPROD MediaWiki Production
Attached
Detach File
Event Timeline
Log In to Comment