vendor/pimcore/pimcore/lib/Cache/Runtime.php line 152

Open in your IDE?
  1. <?php
  3. /**
  4. * Pimcore
  5. *
  6. * This source file is available under two different licenses:
  7. * - GNU General Public License version 3 (GPLv3)
  8. * - Pimcore Commercial License (PCL)
  9. * Full copyright and license information is available in
  10. * LICENSE.md which is distributed with this source code.
  11. *
  12. * @copyright Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13. * @license http://www.pimcore.org/license GPLv3 and PCL
  14. */
  16. namespace Pimcore\Cache;
  18. final class Runtime extends \ArrayObject
  19. {
  20. private const SERVICE_ID = __CLASS__;
  22. /**
  23. * @var self|null
  24. */
  25. protected static $tempInstance;
  27. /**
  28. * @var self|null
  29. */
  30. protected static $instance;
  32. /**
  33. * Retrieves the default registry instance.
  34. *
  35. * @return self
  36. */
  37. public static function getInstance(): self
  38. {
  39. if (self::$instance) {
  40. return self::$instance;
  41. }
  43. if (\Pimcore::hasContainer()) {
  44. $container = \Pimcore::getContainer();
  46. /** @var self $instance */
  47. $instance = null;
  48. if ($container->initialized(self::SERVICE_ID)) {
  49. $instance = $container->get(self::SERVICE_ID);
  50. } else {
  51. $instance = new self;
  52. $container->set(self::SERVICE_ID, $instance);
  53. }
  55. self::$instance = $instance;
  57. if (self::$tempInstance) {
  58. // copy values from static temp. instance to the service instance
  59. foreach (self::$tempInstance as $key => $value) {
  60. $instance->offsetSet($key, $value);
  61. }
  63. self::$tempInstance = null;
  64. }
  66. return $instance;
  67. }
  69. // create a temp. instance
  70. // this is necessary because the runtime cache is sometimes in use before the actual service container
  71. // is initialized
  72. if (!self::$tempInstance) {
  73. self::$tempInstance = new self;
  74. }
  76. return self::$tempInstance;
  77. }
  79. /**
  80. * getter method, basically same as offsetGet().
  81. *
  82. * This method can be called from an object of type \Pimcore\Cache\Runtime, or it
  83. * can be called statically. In the latter case, it uses the default
  84. * static instance stored in the class.
  85. *
  86. * @param string $index - get the value associated with $index
  87. *
  88. * @return mixed
  89. *
  90. * @throws \Exception if no entry is registered for $index.
  91. */
  92. public static function get($index)
  93. {
  94. $instance = self::getInstance();
  96. if (!$instance->offsetExists($index)) {
  97. throw new \Exception("No entry is registered for key '$index'");
  98. }
  100. return $instance->offsetGet($index);
  101. }
  103. /**
  104. * setter method, basically same as offsetSet().
  105. *
  106. * This method can be called from an object of type \Pimcore\Cache\Runtime, or it
  107. * can be called statically. In the latter case, it uses the default
  108. * static instance stored in the class.
  109. *
  110. * @param string $index The location in the ArrayObject in which to store
  111. * the value.
  112. * @param mixed $value The object to store in the ArrayObject.
  113. *
  114. * @return void
  115. */
  116. public static function set($index, $value)
  117. {
  118. $instance = self::getInstance();
  119. $instance->offsetSet($index, $value);
  120. }
  122. /**
  123. * Returns TRUE if the $index is a named value in the registry,
  124. * or FALSE if $index was not found in the registry.
  125. *
  126. * @param string $index
  127. *
  128. * @return bool
  129. */
  130. public static function isRegistered($index)
  131. {
  132. $instance = self::getInstance();
  134. return $instance->offsetExists($index);
  135. }
  137. /**
  138. * Constructs a parent ArrayObject with default
  139. * ARRAY_AS_PROPS to allow access as an object
  140. *
  141. * @param array $array data array
  142. * @param int $flags ArrayObject flags
  143. */
  144. public function __construct($array = [], $flags = parent::ARRAY_AS_PROPS)
  145. {
  146. parent::__construct($array, $flags);
  147. }
  149. /**
  150. * {@inheritdoc}
  151. */
  152. public function offsetSet($index, $value)
  153. {
  154. parent::offsetSet($index, $value);
  155. }
  157. /**
  158. * Alias of self::set() to be compatible with Pimcore\Cache
  159. *
  160. * @param mixed $data
  161. * @param string $id
  162. */
  163. public static function save($data, $id)
  164. {
  165. self::set($id, $data);
  166. }
  168. /**
  169. * Alias of self::get() to be compatible with Pimcore\Cache
  170. *
  171. * @param string $id
  172. *
  173. * @return mixed
  174. */
  175. public static function load($id)
  176. {
  177. return self::get($id);
  178. }
  180. /**
  181. * @param array $keepItems
  182. */
  183. public static function clear($keepItems = [])
  184. {
  185. self::$instance = null;
  186. $newInstance = new self();
  187. $oldInstance = self::getInstance();
  189. foreach ($keepItems as $key) {
  190. if ($oldInstance->offsetExists($key)) {
  191. $newInstance->offsetSet($key, $oldInstance->offsetGet($key));
  192. }
  193. }
  195. \Pimcore::getContainer()->set(self::SERVICE_ID, $newInstance);
  196. self::$instance = $newInstance;
  197. }
  198. }