vendor/symfony/http-foundation/Session/Attribute/NamespacedAttributeBag.php line 14

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpFoundation\Session\Attribute;
  14. trigger_deprecation('symfony/http-foundation', '5.3', 'The "%s" class is deprecated.', NamespacedAttributeBag::class);
  16. /**
  17.  * This class provides structured storage of session attributes using
  18.  * a name spacing character in the key.
  19.  *
  20.  * @author Drak <drak@zikula.org>
  21.  *
  22.  * @deprecated since Symfony 5.3
  23.  */
  24. class NamespacedAttributeBag extends AttributeBag
  25. {
  26.     private $namespaceCharacter;
  28.     /**
  29.      * @param string $storageKey         Session storage key
  30.      * @param string $namespaceCharacter Namespace character to use in keys
  31.      */
  32.     public function __construct(string $storageKey = '_sf2_attributes', string $namespaceCharacter = '/')
  33.     {
  34.         $this->namespaceCharacter = $namespaceCharacter;
  35.         parent::__construct($storageKey);
  36.     }
  38.     /**
  39.      * {@inheritdoc}
  40.      */
  41.     public function has(string $name)
  42.     {
  43.         // reference mismatch: if fixed, re-introduced in array_key_exists; keep as it is
  44.         $attributes = $this->resolveAttributePath($name);
  45.         $name = $this->resolveKey($name);
  47.         if (null === $attributes) {
  48.             return false;
  49.         }
  51.         return \array_key_exists($name, $attributes);
  52.     }
  54.     /**
  55.      * {@inheritdoc}
  56.      */
  57.     public function get(string $name, $default = null)
  58.     {
  59.         // reference mismatch: if fixed, re-introduced in array_key_exists; keep as it is
  60.         $attributes = $this->resolveAttributePath($name);
  61.         $name = $this->resolveKey($name);
  63.         if (null === $attributes) {
  64.             return $default;
  65.         }
  67.         return \array_key_exists($name, $attributes) ? $attributes[$name] : $default;
  68.     }
  70.     /**
  71.      * {@inheritdoc}
  72.      */
  73.     public function set(string $name, $value)
  74.     {
  75.         $attributes = &$this->resolveAttributePath($name, true);
  76.         $name = $this->resolveKey($name);
  77.         $attributes[$name] = $value;
  78.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     public function remove(string $name)
  84.     {
  85.         $retval = null;
  86.         $attributes = &$this->resolveAttributePath($name);
  87.         $name = $this->resolveKey($name);
  88.         if (null !== $attributes && \array_key_exists($name, $attributes)) {
  89.             $retval = $attributes[$name];
  90.             unset($attributes[$name]);
  91.         }
  93.         return $retval;
  94.     }
  96.     /**
  97.      * Resolves a path in attributes property and returns it as a reference.
  98.      *
  99.      * This method allows structured namespacing of session attributes.
  100.      *
  101.      * @param string $name         Key name
  102.      * @param bool   $writeContext Write context, default false
  103.      *
  104.      * @return array|null
  105.      */
  106.     protected function &resolveAttributePath(string $name, bool $writeContext = false)
  107.     {
  108.         $array = &$this->attributes;
  109.         $name = (str_starts_with($name, $this->namespaceCharacter)) ? substr($name, 1) : $name;
  111.         // Check if there is anything to do, else return
  112.         if (!$name) {
  113.             return $array;
  114.         }
  116.         $parts = explode($this->namespaceCharacter, $name);
  117.         if (\count($parts) < 2) {
  118.             if (!$writeContext) {
  119.                 return $array;
  120.             }
  122.             $array[$parts[0]] = [];
  124.             return $array;
  125.         }
  127.         unset($parts[\count($parts) - 1]);
  129.         foreach ($parts as $part) {
  130.             if (null !== $array && !\array_key_exists($part, $array)) {
  131.                 if (!$writeContext) {
  132.                     $null = null;
  134.                     return $null;
  135.                 }
  137.                 $array[$part] = [];
  138.             }
  140.             $array = &$array[$part];
  141.         }
  143.         return $array;
  144.     }
  146.     /**
  147.      * Resolves the key from the name.
  148.      *
  149.      * This is the last part in a dot separated string.
  150.      *
  151.      * @return string
  152.      */
  153.     protected function resolveKey(string $name)
  154.     {
  155.         if (false !== $pos = strrpos($name, $this->namespaceCharacter)) {
  156.             $name = substr($name, $pos + 1);
  157.         }
  159.         return $name;
  160.     }
  161. }