vendor/laminas/laminas-stdlib/src/SplPriorityQueue.php line 27

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  3. namespace Laminas\Stdlib;
  4. use Serializable;
  5. use UnexpectedValueException;
  6. use function array_key_exists;
  7. use function get_class;
  8. use function gettype;
  9. use function is_array;
  10. use function is_object;
  11. use function serialize;
  12. use function sprintf;
  13. use function unserialize;
  14. use const PHP_INT_MAX;
  15. /**
  16.  * Serializable version of SplPriorityQueue
  17.  *
  18.  * Also, provides predictable heap order for datums added with the same priority
  19.  * (i.e., they will be emitted in the same order they are enqueued).
  20.  */
  21. class SplPriorityQueue extends \SplPriorityQueue implements Serializable
  22. {
  23.     /** @var int Seed used to ensure queue order for items of the same priority */
  24.     protected $serial PHP_INT_MAX;
  25.     /**
  26.      * Insert a value with a given priority
  27.      *
  28.      * Utilizes {@var $serial} to ensure that values of equal priority are
  29.      * emitted in the same order in which they are inserted.
  30.      *
  31.      * @param  mixed $datum
  32.      * @param  mixed $priority
  33.      * @return void
  34.      */
  35.     public function insert($datum$priority)
  36.     {
  37.         if (! is_array($priority)) {
  38.             $priority = [$priority$this->serial--];
  39.         }
  40.         parent::insert($datum$priority);
  41.     }
  42.     /**
  43.      * Serialize to an array
  44.      *
  45.      * Array will be priority => data pairs
  46.      *
  47.      * @return array
  48.      */
  49.     public function toArray()
  50.     {
  51.         $array = [];
  52.         foreach (clone $this as $item) {
  53.             $array[] = $item;
  54.         }
  55.         return $array;
  56.     }
  57.     /**
  58.      * Serialize
  59.      *
  60.      * @return string
  61.      */
  62.     public function serialize()
  63.     {
  64.         return serialize($this->__serialize());
  65.     }
  66.     /**
  67.      * Magic method used for serializing of an instance.
  68.      *
  69.      * @return array
  70.      */
  71.     public function __serialize()
  72.     {
  73.         $clone = clone $this;
  74.         $clone->setExtractFlags(self::EXTR_BOTH);
  75.         $data = [];
  76.         foreach ($clone as $item) {
  77.             $data[] = $item;
  78.         }
  79.         return $data;
  80.     }
  81.     /**
  82.      * Deserialize
  83.      *
  84.      * @param  string $data
  85.      * @return void
  86.      */
  87.     public function unserialize($data)
  88.     {
  89.         $toUnserialize unserialize($data);
  90.         if (! is_array($toUnserialize)) {
  91.             throw new UnexpectedValueException(sprintf(
  92.                 'Cannot deserialize %s instance; corrupt serialization data',
  93.                 self::class
  94.             ));
  95.         }
  96.         $this->__unserialize($toUnserialize);
  97.     }
  98.     /**
  99.      * Magic method used to rebuild an instance.
  100.      *
  101.      * @param array $data Data array.
  102.      * @return void
  103.      */
  104.     public function __unserialize($data)
  105.     {
  106.         $this->serial PHP_INT_MAX;
  107.         foreach ($data as $item) {
  108.             if (! is_array($item)) {
  109.                 throw new UnexpectedValueException(sprintf(
  110.                     'Cannot deserialize %s instance: corrupt item; expected array, received %s',
  111.                     self::class,
  112.                     is_object($item) ? get_class($item) : gettype($item)
  113.                 ));
  114.             }
  115.             if (! array_key_exists('data'$item)) {
  116.                 throw new UnexpectedValueException(sprintf(
  117.                     'Cannot deserialize %s instance: corrupt item; missing "data" element',
  118.                     self::class
  119.                 ));
  120.             }
  121.             $priority 1;
  122.             if (array_key_exists('priority'$item)) {
  123.                 $priority = (int) $item['priority'];
  124.             }
  125.             $this->insert($item['data'], $priority);
  126.         }
  127.     }
  128. }