[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  if (class_exists('SplFixedArray')) {
   4      return;
   5  }
   6  
   7  /**
   8   * The SplFixedArray class provides the main functionalities of array. The
   9   * main differences between a SplFixedArray and a normal PHP array is that
  10   * the SplFixedArray is of fixed length and allows only integers within
  11   * the range as indexes. The advantage is that it allows a faster array
  12   * implementation.
  13   */
  14  class SplFixedArray implements Iterator, ArrayAccess, Countable
  15  {
  16      /** @var array<int, mixed> */
  17      private $internalArray = array();
  18  
  19      /** @var int $size */
  20      private $size = 0;
  21  
  22      /**
  23       * SplFixedArray constructor.
  24       * @param int $size
  25       */
  26      public function __construct($size = 0)
  27      {
  28          $this->size = $size;
  29          $this->internalArray = array();
  30      }
  31  
  32      /**
  33       * @return int
  34       */
  35      #[\ReturnTypeWillChange]
  36      public function count()
  37      {
  38          return count($this->internalArray);
  39      }
  40  
  41      /**
  42       * @return array
  43       */
  44      public function toArray()
  45      {
  46          ksort($this->internalArray);
  47          return (array) $this->internalArray;
  48      }
  49  
  50      /**
  51       * @param array $array
  52       * @param bool $save_indexes
  53       * @return SplFixedArray
  54       * @psalm-suppress MixedAssignment
  55       */
  56      public static function fromArray(array $array, $save_indexes = true)
  57      {
  58          $self = new SplFixedArray(count($array));
  59          if($save_indexes) {
  60              foreach($array as $key => $value) {
  61                  $self[(int) $key] = $value;
  62              }
  63          } else {
  64              $i = 0;
  65              foreach (array_values($array) as $value) {
  66                  $self[$i] = $value;
  67                  $i++;
  68              }
  69          }
  70          return $self;
  71      }
  72  
  73      /**
  74       * @return int
  75       */
  76      #[\ReturnTypeWillChange]
  77      public function getSize()
  78      {
  79          return $this->size;
  80      }
  81  
  82      /**
  83       * @param int $size
  84       * @return bool
  85       */
  86      #[\ReturnTypeWillChange]
  87      public function setSize($size)
  88      {
  89          $this->size = $size;
  90          return true;
  91      }
  92  
  93      /**
  94       * @param string|int $index
  95       * @return bool
  96       */
  97      #[\ReturnTypeWillChange]
  98      public function offsetExists($index)
  99      {
 100          return array_key_exists((int) $index, $this->internalArray);
 101      }
 102  
 103      /**
 104       * @param string|int $index
 105       * @return mixed
 106       */
 107      #[\ReturnTypeWillChange]
 108      public function offsetGet($index)
 109      {
 110          /** @psalm-suppress MixedReturnStatement */
 111          return $this->internalArray[(int) $index];
 112      }
 113  
 114      /**
 115       * @param string|int $index
 116       * @param mixed $newval
 117       * @psalm-suppress MixedAssignment
 118       */
 119      #[\ReturnTypeWillChange]
 120      public function offsetSet($index, $newval)
 121      {
 122          $this->internalArray[(int) $index] = $newval;
 123      }
 124  
 125      /**
 126       * @param string|int $index
 127       */
 128      #[\ReturnTypeWillChange]
 129      public function offsetUnset($index)
 130      {
 131          unset($this->internalArray[(int) $index]);
 132      }
 133  
 134      /**
 135       * Rewind iterator back to the start
 136       * @link https://php.net/manual/en/splfixedarray.rewind.php
 137       * @return void
 138       * @since 5.3.0
 139       */
 140      #[\ReturnTypeWillChange]
 141      public function rewind()
 142      {
 143          reset($this->internalArray);
 144      }
 145  
 146      /**
 147       * Return current array entry
 148       * @link https://php.net/manual/en/splfixedarray.current.php
 149       * @return mixed The current element value.
 150       * @since 5.3.0
 151       */
 152      #[\ReturnTypeWillChange]
 153      public function current()
 154      {
 155          /** @psalm-suppress MixedReturnStatement */
 156          return current($this->internalArray);
 157      }
 158  
 159      /**
 160       * Return current array index
 161       * @return int The current array index.
 162       */
 163      #[\ReturnTypeWillChange]
 164      public function key()
 165      {
 166          return key($this->internalArray);
 167      }
 168  
 169      /**
 170       * @return void
 171       */
 172      #[\ReturnTypeWillChange]
 173      public function next()
 174      {
 175          next($this->internalArray);
 176      }
 177  
 178      /**
 179       * Check whether the array contains more elements
 180       * @link https://php.net/manual/en/splfixedarray.valid.php
 181       * @return bool true if the array contains any more elements, false otherwise.
 182       */
 183      #[\ReturnTypeWillChange]
 184      public function valid()
 185      {
 186          if (empty($this->internalArray)) {
 187              return false;
 188          }
 189          $result = next($this->internalArray) !== false;
 190          prev($this->internalArray);
 191          return $result;
 192      }
 193  
 194      public function __sleep()
 195      {
 196          return $this->internalArray;
 197      }
 198  
 199      /**
 200       * Do nothing.
 201       */
 202      public function __wakeup()
 203      {
 204          // NOP
 205      }
 206  
 207      public function __serialize()
 208      {
 209          return array_values($this->internalArray);
 210      }
 211  
 212      public function __unserialize(array $data)
 213      {
 214          $length = count($data);
 215          $values = array_values($data);
 216          for ($i = 0; $i < $length; ++$i) {
 217              $this->internalArray[$i] = $values[$i];
 218          }
 219          $this->size = $length;
 220      }
 221  }