vendor/symfony/form/Util/OrderedHashMap.php line 170

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\Form\Util;
  14. /**
  15.  * A hash map which keeps track of deletions and additions.
  16.  *
  17.  * Like in associative arrays, elements can be mapped to integer or string keys.
  18.  * Unlike associative arrays, the map keeps track of the order in which keys
  19.  * were added and removed. This order is reflected during iteration.
  20.  *
  21.  * The map supports concurrent modification during iteration. That means that
  22.  * you can insert and remove elements from within a foreach loop and the
  23.  * iterator will reflect those changes accordingly.
  24.  *
  25.  * While elements that are added during the loop are recognized by the iterator,
  26.  * changed elements are not. Otherwise the loop could be infinite if each loop
  27.  * changes the current element:
  28.  *
  29.  *     $map = new OrderedHashMap();
  30.  *     $map[1] = 1;
  31.  *     $map[2] = 2;
  32.  *     $map[3] = 3;
  33.  *
  34.  *     foreach ($map as $index => $value) {
  35.  *         echo "$index: $value\n"
  36.  *         if (1 === $index) {
  37.  *             $map[1] = 4;
  38.  *             $map[] = 5;
  39.  *         }
  40.  *     }
  41.  *
  42.  *     print_r(iterator_to_array($map));
  43.  *
  44.  *     // => 1: 1
  45.  *     //    2: 2
  46.  *     //    3: 3
  47.  *     //    4: 5
  48.  *     //    Array
  49.  *     //    (
  50.  *     //        [1] => 4
  51.  *     //        [2] => 2
  52.  *     //        [3] => 3
  53.  *     //        [4] => 5
  54.  *     //    )
  55.  *
  56.  * The map also supports multiple parallel iterators. That means that you can
  57.  * nest foreach loops without affecting each other's iteration:
  58.  *
  59.  *     foreach ($map as $index => $value) {
  60.  *         foreach ($map as $index2 => $value2) {
  61.  *             // ...
  62.  *         }
  63.  *     }
  64.  *
  65.  * @author Bernhard Schussek <bschussek@gmail.com>
  66.  */
  67. class OrderedHashMap implements \ArrayAccess, \IteratorAggregate, \Countable
  68. {
  69.     /**
  70.      * The elements of the map, indexed by their keys.
  71.      *
  72.      * @var array
  73.      */
  74.     private $elements = [];
  76.     /**
  77.      * The keys of the map in the order in which they were inserted or changed.
  78.      *
  79.      * @var array
  80.      */
  81.     private $orderedKeys = [];
  83.     /**
  84.      * References to the cursors of all open iterators.
  85.      *
  86.      * @var array
  87.      */
  88.     private $managedCursors = [];
  90.     /**
  91.      * Creates a new map.
  92.      *
  93.      * @param array $elements The elements to insert initially
  94.      */
  95.     public function __construct(array $elements = [])
  96.     {
  97.         $this->elements = $elements;
  98.         $this->orderedKeys = array_keys($elements);
  99.     }
  101.     /**
  102.      * @return bool
  103.      */
  104.     public function offsetExists($key)
  105.     {
  106.         return isset($this->elements[$key]);
  107.     }
  109.     /**
  110.      * {@inheritdoc}
  111.      */
  112.     public function offsetGet($key)
  113.     {
  114.         if (!isset($this->elements[$key])) {
  115.             throw new \OutOfBoundsException(sprintf('The offset "%s" does not exist.', $key));
  116.         }
  118.         return $this->elements[$key];
  119.     }
  121.     /**
  122.      * {@inheritdoc}
  123.      */
  124.     public function offsetSet($key, $value)
  125.     {
  126.         if (null === $key || !isset($this->elements[$key])) {
  127.             if (null === $key) {
  128.                 $key = [] === $this->orderedKeys
  129.                     // If the array is empty, use 0 as key
  130.                     ? 0
  131.                     // Imitate PHP behavior of generating a key that equals
  132.                     // the highest existing integer key + 1
  133.                     : 1 + (int) max($this->orderedKeys);
  134.             }
  136.             $this->orderedKeys[] = (string) $key;
  137.         }
  139.         $this->elements[$key] = $value;
  140.     }
  142.     /**
  143.      * {@inheritdoc}
  144.      */
  145.     public function offsetUnset($key)
  146.     {
  147.         if (false !== ($position = array_search((string) $key, $this->orderedKeys))) {
  148.             array_splice($this->orderedKeys, $position, 1);
  149.             unset($this->elements[$key]);
  151.             foreach ($this->managedCursors as $i => $cursor) {
  152.                 if ($cursor >= $position) {
  153.                     --$this->managedCursors[$i];
  154.                 }
  155.             }
  156.         }
  157.     }
  159.     /**
  160.      * @return \Traversable
  161.      */
  162.     public function getIterator()
  163.     {
  164.         return new OrderedHashMapIterator($this->elements, $this->orderedKeys, $this->managedCursors);
  165.     }
  167.     /**
  168.      * @return int
  169.      */
  170.     public function count()
  171.     {
  172.         return \count($this->elements);
  173.     }
  174. }