[Summary view]

Differences Between: [Versions 310 and 403] [Versions 311 and 403] [Versions 39 and 403] [Versions 400 and 403] [Versions 401 and 403]

   1  <?php
   2  
   3  namespace PhpOffice\PhpSpreadsheet;
   4  
   5  /**
   6   * @template T of IComparable
   7   */
   8  class HashTable
   9  {
  10      /**
  11       * HashTable elements.
  12       *
  13       * @var array<string, T>
  14       */
  15      protected $items = [];
  16  
  17      /**
  18       * HashTable key map.
  19       *
  20       * @var array<int, string>
  21       */
  22      protected $keyMap = [];
  23  
  24      /**
  25       * Create a new HashTable.
  26       *
  27       * @param T[] $source Optional source array to create HashTable from
  28       */
  29      public function __construct($source = null)
  30      {
  31          if ($source !== null) {
  32              // Create HashTable
  33              $this->addFromSource($source);
  34          }
  35      }
  36  
  37      /**
  38       * Add HashTable items from source.
  39       *
  40       * @param T[] $source Source array to create HashTable from
  41       */
  42      public function addFromSource(?array $source = null): void
  43      {
  44          // Check if an array was passed
  45          if ($source === null) {
  46              return;
  47          }
  48  
  49          foreach ($source as $item) {
  50              $this->add($item);
  51          }
  52      }
  53  
  54      /**
  55       * Add HashTable item.
  56       *
  57       * @param T $source Item to add
  58       */
  59      public function add(IComparable $source): void
  60      {
  61          $hash = $source->getHashCode();
  62          if (!isset($this->items[$hash])) {
  63              $this->items[$hash] = $source;
  64              $this->keyMap[count($this->items) - 1] = $hash;
  65          }
  66      }
  67  
  68      /**
  69       * Remove HashTable item.
  70       *
  71       * @param T $source Item to remove
  72       */
  73      public function remove(IComparable $source): void
  74      {
  75          $hash = $source->getHashCode();
  76          if (isset($this->items[$hash])) {
  77              unset($this->items[$hash]);
  78  
  79              $deleteKey = -1;
  80              foreach ($this->keyMap as $key => $value) {
  81                  if ($deleteKey >= 0) {
  82                      $this->keyMap[$key - 1] = $value;
  83                  }
  84  
  85                  if ($value == $hash) {
  86                      $deleteKey = $key;
  87                  }
  88              }
  89              unset($this->keyMap[count($this->keyMap) - 1]);
  90          }
  91      }
  92  
  93      /**
  94       * Clear HashTable.
  95       */
  96      public function clear(): void
  97      {
  98          $this->items = [];
  99          $this->keyMap = [];
 100      }
 101  
 102      /**
 103       * Count.
 104       *
 105       * @return int
 106       */
 107      public function count()
 108      {
 109          return count($this->items);
 110      }
 111  
 112      /**
 113       * Get index for hash code.
 114       *
 115       * @return false|int Index
 116       */
 117      public function getIndexForHashCode(string $hashCode)
 118      {
 119          // Scrutinizer thinks the following could return string. It is wrong.
 120          return array_search($hashCode, $this->keyMap, true);
 121      }
 122  
 123      /**
 124       * Get by index.
 125       *
 126       * @return null|T
 127       */
 128      public function getByIndex(int $index)
 129      {
 130          if (isset($this->keyMap[$index])) {
 131              return $this->getByHashCode($this->keyMap[$index]);
 132          }
 133  
 134          return null;
 135      }
 136  
 137      /**
 138       * Get by hashcode.
 139       *
 140       * @return null|T
 141       */
 142      public function getByHashCode(string $hashCode)
 143      {
 144          if (isset($this->items[$hashCode])) {
 145              return $this->items[$hashCode];
 146          }
 147  
 148          return null;
 149      }
 150  
 151      /**
 152       * HashTable to array.
 153       *
 154       * @return T[]
 155       */
 156      public function toArray()
 157      {
 158          return $this->items;
 159      }
 160  
 161      /**
 162       * Implement PHP __clone to create a deep clone, not just a shallow copy.
 163       */
 164      public function __clone()
 165      {
 166          $vars = get_object_vars($this);
 167          foreach ($vars as $key => $value) {
 168              // each member of this class is an array
 169              if (is_array($value)) {
 170                  $array1 = $value;
 171                  foreach ($array1 as $key1 => $value1) {
 172                      if (is_object($value1)) {
 173                          $array1[$key1] = clone $value1;
 174                      }
 175                  }
 176                  $this->$key = $array1;
 177              }
 178          }
 179      }
 180  }