[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /**
   4   * PHPExcel_CachedObjectStorage_CacheBase
   5   *
   6   * Copyright (c) 2006 - 2015 PHPExcel
   7   *
   8   * This library is free software; you can redistribute it and/or
   9   * modify it under the terms of the GNU Lesser General Public
  10   * License as published by the Free Software Foundation; either
  11   * version 2.1 of the License, or (at your option) any later version.
  12   *
  13   * This library is distributed in the hope that it will be useful,
  14   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16   * Lesser General Public License for more details.
  17   *
  18   * You should have received a copy of the GNU Lesser General Public
  19   * License along with this library; if not, write to the Free Software
  20   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21   *
  22   * @category   PHPExcel
  23   * @package    PHPExcel_CachedObjectStorage
  24   * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
  25   * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  26   * @version    ##VERSION##, ##DATE##
  27   */
  28  abstract class PHPExcel_CachedObjectStorage_CacheBase
  29  {
  30      /**
  31       * Parent worksheet
  32       *
  33       * @var PHPExcel_Worksheet
  34       */
  35      protected $parent;
  36  
  37      /**
  38       * The currently active Cell
  39       *
  40       * @var PHPExcel_Cell
  41       */
  42      protected $currentObject = null;
  43  
  44      /**
  45       * Coordinate address of the currently active Cell
  46       *
  47       * @var string
  48       */
  49      protected $currentObjectID = null;
  50  
  51      /**
  52       * Flag indicating whether the currently active Cell requires saving
  53       *
  54       * @var boolean
  55       */
  56      protected $currentCellIsDirty = true;
  57  
  58      /**
  59       * An array of cells or cell pointers for the worksheet cells held in this cache,
  60       *        and indexed by their coordinate address within the worksheet
  61       *
  62       * @var array of mixed
  63       */
  64      protected $cellCache = array();
  65  
  66      /**
  67       * Initialise this new cell collection
  68       *
  69       * @param    PHPExcel_Worksheet    $parent        The worksheet for this cell collection
  70       */
  71      public function __construct(PHPExcel_Worksheet $parent)
  72      {
  73          //    Set our parent worksheet.
  74          //    This is maintained within the cache controller to facilitate re-attaching it to PHPExcel_Cell objects when
  75          //        they are woken from a serialized state
  76          $this->parent = $parent;
  77      }
  78  
  79      /**
  80       * Return the parent worksheet for this cell collection
  81       *
  82       * @return    PHPExcel_Worksheet
  83       */
  84      public function getParent()
  85      {
  86          return $this->parent;
  87      }
  88  
  89      /**
  90       * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
  91       *
  92       * @param    string        $pCoord        Coordinate address of the cell to check
  93       * @return    boolean
  94       */
  95      public function isDataSet($pCoord)
  96      {
  97          if ($pCoord === $this->currentObjectID) {
  98              return true;
  99          }
 100          //    Check if the requested entry exists in the cache
 101          return isset($this->cellCache[$pCoord]);
 102      }
 103  
 104      /**
 105       * Move a cell object from one address to another
 106       *
 107       * @param    string        $fromAddress    Current address of the cell to move
 108       * @param    string        $toAddress        Destination address of the cell to move
 109       * @return    boolean
 110       */
 111      public function moveCell($fromAddress, $toAddress)
 112      {
 113          if ($fromAddress === $this->currentObjectID) {
 114              $this->currentObjectID = $toAddress;
 115          }
 116          $this->currentCellIsDirty = true;
 117          if (isset($this->cellCache[$fromAddress])) {
 118              $this->cellCache[$toAddress] = &$this->cellCache[$fromAddress];
 119              unset($this->cellCache[$fromAddress]);
 120          }
 121  
 122          return true;
 123      }
 124  
 125      /**
 126       * Add or Update a cell in cache
 127       *
 128       * @param    PHPExcel_Cell    $cell        Cell to update
 129       * @return    PHPExcel_Cell
 130       * @throws    PHPExcel_Exception
 131       */
 132      public function updateCacheData(PHPExcel_Cell $cell)
 133      {
 134          return $this->addCacheData($cell->getCoordinate(), $cell);
 135      }
 136  
 137      /**
 138       * Delete a cell in cache identified by coordinate address
 139       *
 140       * @param    string            $pCoord        Coordinate address of the cell to delete
 141       * @throws    PHPExcel_Exception
 142       */
 143      public function deleteCacheData($pCoord)
 144      {
 145          if ($pCoord === $this->currentObjectID && !is_null($this->currentObject)) {
 146              $this->currentObject->detach();
 147              $this->currentObjectID = $this->currentObject = null;
 148          }
 149  
 150          if (is_object($this->cellCache[$pCoord])) {
 151              $this->cellCache[$pCoord]->detach();
 152              unset($this->cellCache[$pCoord]);
 153          }
 154          $this->currentCellIsDirty = false;
 155      }
 156  
 157      /**
 158       * Get a list of all cell addresses currently held in cache
 159       *
 160       * @return    string[]
 161       */
 162      public function getCellList()
 163      {
 164          return array_keys($this->cellCache);
 165      }
 166  
 167      /**
 168       * Sort the list of all cell addresses currently held in cache by row and column
 169       *
 170       * @return    string[]
 171       */
 172      public function getSortedCellList()
 173      {
 174          $sortKeys = array();
 175          foreach ($this->getCellList() as $coord) {
 176              sscanf($coord, '%[A-Z]%d', $column, $row);
 177              $sortKeys[sprintf('%09d%3s', $row, $column)] = $coord;
 178          }
 179          ksort($sortKeys);
 180  
 181          return array_values($sortKeys);
 182      }
 183  
 184      /**
 185       * Get highest worksheet column and highest row that have cell records
 186       *
 187       * @return array Highest column name and highest row number
 188       */
 189      public function getHighestRowAndColumn()
 190      {
 191          // Lookup highest column and highest row
 192          $col = array('A' => '1A');
 193          $row = array(1);
 194          foreach ($this->getCellList() as $coord) {
 195              sscanf($coord, '%[A-Z]%d', $c, $r);
 196              $row[$r] = $r;
 197              $col[$c] = strlen($c).$c;
 198          }
 199          if (!empty($row)) {
 200              // Determine highest column and row
 201              $highestRow = max($row);
 202              $highestColumn = substr(max($col), 1);
 203          }
 204  
 205          return array(
 206              'row'    => $highestRow,
 207              'column' => $highestColumn
 208          );
 209      }
 210  
 211      /**
 212       * Return the cell address of the currently active cell object
 213       *
 214       * @return    string
 215       */
 216      public function getCurrentAddress()
 217      {
 218          return $this->currentObjectID;
 219      }
 220  
 221      /**
 222       * Return the column address of the currently active cell object
 223       *
 224       * @return    string
 225       */
 226      public function getCurrentColumn()
 227      {
 228          sscanf($this->currentObjectID, '%[A-Z]%d', $column, $row);
 229          return $column;
 230      }
 231  
 232      /**
 233       * Return the row address of the currently active cell object
 234       *
 235       * @return    integer
 236       */
 237      public function getCurrentRow()
 238      {
 239          sscanf($this->currentObjectID, '%[A-Z]%d', $column, $row);
 240          return (integer) $row;
 241      }
 242  
 243      /**
 244       * Get highest worksheet column
 245       *
 246       * @param   string     $row        Return the highest column for the specified row,
 247       *                                     or the highest column of any row if no row number is passed
 248       * @return  string     Highest column name
 249       */
 250      public function getHighestColumn($row = null)
 251      {
 252          if ($row == null) {
 253              $colRow = $this->getHighestRowAndColumn();
 254              return $colRow['column'];
 255          }
 256  
 257          $columnList = array(1);
 258          foreach ($this->getCellList() as $coord) {
 259              sscanf($coord, '%[A-Z]%d', $c, $r);
 260              if ($r != $row) {
 261                  continue;
 262              }
 263              $columnList[] = PHPExcel_Cell::columnIndexFromString($c);
 264          }
 265          return PHPExcel_Cell::stringFromColumnIndex(max($columnList) - 1);
 266      }
 267  
 268      /**
 269       * Get highest worksheet row
 270       *
 271       * @param   string     $column     Return the highest row for the specified column,
 272       *                                     or the highest row of any column if no column letter is passed
 273       * @return  int        Highest row number
 274       */
 275      public function getHighestRow($column = null)
 276      {
 277          if ($column == null) {
 278              $colRow = $this->getHighestRowAndColumn();
 279              return $colRow['row'];
 280          }
 281  
 282          $rowList = array(0);
 283          foreach ($this->getCellList() as $coord) {
 284              sscanf($coord, '%[A-Z]%d', $c, $r);
 285              if ($c != $column) {
 286                  continue;
 287              }
 288              $rowList[] = $r;
 289          }
 290  
 291          return max($rowList);
 292      }
 293  
 294      /**
 295       * Generate a unique ID for cache referencing
 296       *
 297       * @return string Unique Reference
 298       */
 299      protected function getUniqueID()
 300      {
 301          if (function_exists('posix_getpid')) {
 302              $baseUnique = posix_getpid();
 303          } else {
 304              $baseUnique = mt_rand();
 305          }
 306          return uniqid($baseUnique, true);
 307      }
 308  
 309      /**
 310       * Clone the cell collection
 311       *
 312       * @param    PHPExcel_Worksheet    $parent        The new worksheet
 313       * @return    void
 314       */
 315      public function copyCellCollection(PHPExcel_Worksheet $parent)
 316      {
 317          $this->currentCellIsDirty;
 318          $this->storeData();
 319  
 320          $this->parent = $parent;
 321          if (($this->currentObject !== null) && (is_object($this->currentObject))) {
 322              $this->currentObject->attach($this);
 323          }
 324      }    //    function copyCellCollection()
 325  
 326      /**
 327       * Remove a row, deleting all cells in that row
 328       *
 329       * @param string    $row    Row number to remove
 330       * @return void
 331       */
 332      public function removeRow($row)
 333      {
 334          foreach ($this->getCellList() as $coord) {
 335              sscanf($coord, '%[A-Z]%d', $c, $r);
 336              if ($r == $row) {
 337                  $this->deleteCacheData($coord);
 338              }
 339          }
 340      }
 341  
 342      /**
 343       * Remove a column, deleting all cells in that column
 344       *
 345       * @param string    $column    Column ID to remove
 346       * @return void
 347       */
 348      public function removeColumn($column)
 349      {
 350          foreach ($this->getCellList() as $coord) {
 351              sscanf($coord, '%[A-Z]%d', $c, $r);
 352              if ($c == $column) {
 353                  $this->deleteCacheData($coord);
 354              }
 355          }
 356      }
 357  
 358      /**
 359       * Identify whether the caching method is currently available
 360       * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
 361       *
 362       * @return    boolean
 363       */
 364      public static function cacheMethodIsAvailable()
 365      {
 366          return true;
 367      }
 368  }