namespace Drupal\Core\State;
-use Drupal\Core\Cache\CacheBackendInterface;
-use Drupal\Core\Cache\CacheCollector;
use Drupal\Core\KeyValueStore\KeyValueFactoryInterface;
-use Drupal\Core\Lock\LockBackendInterface;
/**
* Provides the state system using a key value store.
*/
-class State extends CacheCollector implements StateInterface {
+class State implements StateInterface {
/**
* The key value store to use.
*/
protected $keyValueStore;
+ /**
+ * Static state cache.
+ *
+ * @var array
+ */
+ protected $cache = [];
+
/**
* Constructs a State object.
*
* @param \Drupal\Core\KeyValueStore\KeyValueFactoryInterface $key_value_factory
* The key value store to use.
- * @param \Drupal\Core\Cache\CacheBackendInterface $cache
- * The cache backend.
- * @param \Drupal\Core\Lock\LockBackendInterface $lock
- * The lock backend.
*/
- public function __construct(KeyValueFactoryInterface $key_value_factory, CacheBackendInterface $cache, LockBackendInterface $lock) {
- parent::__construct('state', $cache, $lock);
+ public function __construct(KeyValueFactoryInterface $key_value_factory) {
$this->keyValueStore = $key_value_factory->get('state');
}
* {@inheritdoc}
*/
public function get($key, $default = NULL) {
- $value = parent::get($key);
- return $value !== NULL ? $value : $default;
- }
-
- /**
- * {@inheritdoc}
- */
- protected function resolveCacheMiss($key) {
- $value = $this->keyValueStore->get($key);
- $this->storage[$key] = $value;
- $this->persist($key);
- return $value;
+ $values = $this->getMultiple([$key]);
+ return isset($values[$key]) ? $values[$key] : $default;
}
/**
*/
public function getMultiple(array $keys) {
$values = [];
+ $load = [];
foreach ($keys as $key) {
- $values[$key] = $this->get($key);
+ // Check if we have a value in the cache.
+ if (isset($this->cache[$key])) {
+ $values[$key] = $this->cache[$key];
+ }
+ // Load the value if we don't have an explicit NULL value.
+ elseif (!array_key_exists($key, $this->cache)) {
+ $load[] = $key;
+ }
}
+
+ if ($load) {
+ $loaded_values = $this->keyValueStore->getMultiple($load);
+ foreach ($load as $key) {
+ // If we find a value, even one that is NULL, add it to the cache and
+ // return it.
+ if (isset($loaded_values[$key]) || array_key_exists($key, $loaded_values)) {
+ $values[$key] = $loaded_values[$key];
+ $this->cache[$key] = $loaded_values[$key];
+ }
+ else {
+ $this->cache[$key] = NULL;
+ }
+ }
+ }
+
return $values;
}
* {@inheritdoc}
*/
public function set($key, $value) {
- parent::set($key, $value);
+ $this->cache[$key] = $value;
$this->keyValueStore->set($key, $value);
}
*/
public function setMultiple(array $data) {
foreach ($data as $key => $value) {
- parent::set($key, $value);
+ $this->cache[$key] = $value;
}
$this->keyValueStore->setMultiple($data);
}
* {@inheritdoc}
*/
public function delete($key) {
- parent::delete($key);
- $this->keyValueStore->delete($key);
+ $this->deleteMultiple([$key]);
}
/**
*/
public function deleteMultiple(array $keys) {
foreach ($keys as $key) {
- parent::delete($key);
+ unset($this->cache[$key]);
}
$this->keyValueStore->deleteMultiple($keys);
}
* {@inheritdoc}
*/
public function resetCache() {
- $this->clear();
+ $this->cache = [];
}
}