init

data/sql/functions.sql

+-- CREATE DEFINER=`root`@`localhost` FUNCTION `geodist`(`src_lat` DECIMAL(18,14), `src_lon` DECIMAL(18,14), `dst_lat` DECIMAL(18,14), `dst_lon` DECIMAL(18,14)) RETURNS decimal(18,14)
+-- BEGIN
+--  SET @dist := 6371 * 2 * ASIN(SQRT(
+--       POWER(SIN((src_lat - ABS(dst_lat)) * PI()/180 / 2), 2) +
+--       COS(src_lat * PI()/180) *
+--       COS(ABS(dst_lat) * PI()/180) *
+--       POWER(SIN((src_lon - dst_lon) * PI()/180 / 2), 2)
+--     ));
+--  RETURN @dist;
+CREATE TABLE seo2 (id BIGINT AUTO_INCREMENT, url TEXT NOT NULL, h1 TEXT, title TEXT, description TEXT, body text, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, PRIMARY KEY(id)) ENGINE = INNODB;
\ No newline at end of file

data/sql/schema.sql

+CREATE TABLE cat (id BIGINT AUTO_INCREMENT, title TEXT NOT NULL, min_weight FLOAT(10, 3), price FLOAT(10, 2), order_id BIGINT DEFAULT 0 NOT NULL, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE page (id BIGINT AUTO_INCREMENT, title VARCHAR(255) NOT NULL, alias VARCHAR(255) UNIQUE, body TEXT, images text, is_activated TINYINT(1) DEFAULT '1' NOT NULL, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE permission (id BIGINT AUTO_INCREMENT, credential VARCHAR(255) NOT NULL UNIQUE, description VARCHAR(255), PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE session (id VARCHAR(128), session_data text, session_time BIGINT, user_id BIGINT, token VARCHAR(255), device_id VARCHAR(255), INDEX user_id_idx (user_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user (id BIGINT AUTO_INCREMENT, username VARCHAR(255) NOT NULL UNIQUE, name VARCHAR(255) NOT NULL, email VARCHAR(128), email_check VARCHAR(255), email_change VARCHAR(128) NOT NULL, email_change_check VARCHAR(255), social VARCHAR(255), phone VARCHAR(11), phone_check VARCHAR(255), phone_change VARCHAR(11) NOT NULL, salt VARCHAR(128), password VARCHAR(128), password_recovery VARCHAR(255), is_active TINYINT(1) DEFAULT '0' NOT NULL, is_super_admin TINYINT(1) DEFAULT '0', last_login DATETIME, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, deleted_at DATETIME, INDEX name_idx_idx (username), PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user_group (id BIGINT AUTO_INCREMENT, title VARCHAR(128) NOT NULL UNIQUE, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user_group_permissions (user_group_id BIGINT, permission_id BIGINT, PRIMARY KEY(user_group_id, permission_id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user_group_users (user_id BIGINT, user_group_id BIGINT, PRIMARY KEY(user_id, user_group_id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user_log (id BIGINT AUTO_INCREMENT, user_id BIGINT NOT NULL, log_type VARCHAR(50) NOT NULL, model VARCHAR(50) NOT NULL, model_id BIGINT NOT NULL, log TEXT, created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL, INDEX model_idx_idx (model), INDEX model_id_idx_idx (model_id), INDEX user_id_idx (user_id), PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE user_permissions (user_id BIGINT, permission_id BIGINT, PRIMARY KEY(user_id, permission_id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+CREATE TABLE cs_setting (id INT AUTO_INCREMENT, name VARCHAR(255) NOT NULL UNIQUE, type VARCHAR(255) DEFAULT 'input' NOT NULL, widget_options LONGTEXT, value LONGTEXT, setting_group VARCHAR(255) DEFAULT NULL, setting_default LONGTEXT DEFAULT NULL, variables LONGTEXT DEFAULT NULL, slug VARCHAR(255), UNIQUE INDEX cs_setting_sluggable_idx (slug), PRIMARY KEY(id)) DEFAULT CHARACTER SET UTF8 ENGINE = INNODB;
+ALTER TABLE session ADD CONSTRAINT session_user_id_user_id FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE;
+ALTER TABLE user_group_permissions ADD CONSTRAINT user_group_permissions_permission_id_permission_id FOREIGN KEY (permission_id) REFERENCES permission(id);
+ALTER TABLE user_group_users ADD CONSTRAINT user_group_users_user_id_user_id FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE;
+ALTER TABLE user_group_users ADD CONSTRAINT user_group_users_user_group_id_user_group_id FOREIGN KEY (user_group_id) REFERENCES user_group(id) ON DELETE CASCADE;
+ALTER TABLE user_log ADD CONSTRAINT user_log_user_id_user_id FOREIGN KEY (user_id) REFERENCES user(id) ON DELETE CASCADE;
+ALTER TABLE user_permissions ADD CONSTRAINT user_permissions_permission_id_permission_id FOREIGN KEY (permission_id) REFERENCES permission(id);

data/version.txt

+1.0.0
\ No newline at end of file

lib/Classes/Dadata/CleanClient.php

+<?php
+
+namespace Dadata;
+
+class CleanClient extends ClientBase
+{
+    const BASE_URL = "https://cleaner.dadata.ru/api/v1/";
+
+    public function __construct($token, $secret)
+    {
+        parent::__construct(self::BASE_URL, $token, $secret);
+    }
+
+    public function clean($name, $value)
+    {
+        $url = "clean/$name";
+        $fields = array($value);
+        $response = $this->post($url, $fields);
+        return $response[0];
+    }
+
+    public function cleanRecord($structure, $record)
+    {
+        $url = "clean";
+        $data = [
+            "structure" => $structure,
+            "data" => [$record]
+        ];
+        $response = $this->post($url, $data);
+        return $response["data"][0];
+    }
+}

lib/Classes/Dadata/ClientBase.php

+<?php
+
+namespace Dadata;
+
+abstract class ClientBase
+{
+    public $client;
+
+    public function __construct($baseUrl, $token, $secret = null)
+    {
+        $headers = [
+            "Content-Type" => "application/json",
+            "Accept" => "application/json",
+            "Authorization" => "Token " . $token,
+        ];
+        if ($secret) {
+            $headers["X-Secret"] = $secret;
+        }
+        $this->client = new \GuzzleHttp\Client([
+            "base_uri" => $baseUrl,
+            "headers" => $headers,
+            "timeout" => Settings::TIMEOUT_SEC
+        ]);
+    }
+
+    protected function get($url, $query = [])
+    {
+        $response = $this->client->get($url, ["query" => $query]);
+        return json_decode($response->getBody(), true);
+    }
+
+    protected function post($url, $data)
+    {
+        $response = $this->client->post($url, [
+            "json" => $data
+        ]);
+        return json_decode($response->getBody(), true);
+    }
+}

lib/Classes/Dadata/DadataClient.php

+<?php
+
+namespace Dadata;
+
+class DadataClient
+{
+    private $cleaner;
+    private $profile;
+    private $suggestions;
+
+    public function __construct($token, $secret)
+    {
+        $this->cleaner = new CleanClient($token, $secret);
+        $this->profile = new ProfileClient($token, $secret);
+        $this->suggestions = new SuggestClient($token);
+    }
+
+    public function clean($name, $value)
+    {
+        return $this->cleaner->clean($name, $value);
+    }
+
+    public function cleanRecord($structure, $record)
+    {
+        return $this->cleaner->cleanRecord($structure, $record);
+    }
+
+    public function findAffiliated($query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        return $this->suggestions->findAffiliated($query, $count, $kwargs);
+    }
+
+    public function findById($name, $query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        return $this->suggestions->findById($name, $query, $count, $kwargs);
+    }
+
+    public function geolocate($name, $lat, $lon, $radiusMeters = 100, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        return $this->suggestions->geolocate($name, $lat, $lon, $radiusMeters, $count, $kwargs);
+    }
+
+    public function getBalance()
+    {
+        return $this->profile->getBalance();
+    }
+
+    public function getDailyStats($date = null)
+    {
+        return $this->profile->getDailyStats($date);
+    }
+
+    public function getVersions()
+    {
+        return $this->profile->getVersions();
+    }
+
+    public function iplocate($ip, $kwargs = [])
+    {
+        return $this->suggestions->iplocate($ip, $kwargs);
+    }
+
+    public function suggest($name, $query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        return $this->suggestions->suggest($name, $query, $count, $kwargs);
+    }
+}

lib/Classes/Dadata/ProfileClient.php

+<?php
+
+namespace Dadata;
+
+use DateTime;
+
+class ProfileClient extends ClientBase
+{
+    const BASE_URL = "https://dadata.ru/api/v2/";
+
+    public function __construct($token, $secret)
+    {
+        parent::__construct(self::BASE_URL, $token, $secret);
+    }
+
+    public function getBalance()
+    {
+        $url = "profile/balance";
+        $response = $this->get($url);
+        return $response["balance"];
+    }
+
+    public function getDailyStats($date = null)
+    {
+        $url = "stat/daily";
+        if (!$date) {
+            $date = new DateTime();
+        }
+        $query = ["date" => $date->format("Y-m-d")];
+        $response = $this->get($url, $query);
+        return $response;
+    }
+
+    public function getVersions()
+    {
+        $url = "version";
+        $response = $this->get($url);
+        return $response;
+    }
+}

lib/Classes/Dadata/Settings.php

+<?php
+
+namespace Dadata;
+
+class Settings
+{
+    const SUGGESTION_COUNT = 5;
+    const TIMEOUT_SEC = 3;
+}

lib/Classes/Dadata/SuggestClient.php

+<?php
+
+namespace Dadata;
+
+class SuggestClient extends ClientBase
+{
+    const BASE_URL = "https://suggestions.dadata.ru/suggestions/api/4_1/rs/";
+
+    public function __construct($token)
+    {
+        parent::__construct(self::BASE_URL, $token, null);
+    }
+
+    public function findAffiliated($query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        $url = "findAffiliated/party";
+        $data = ["query" => $query, "count" => $count];
+        $data = $data + $kwargs;
+        $response = $this->post($url, $data);
+        return $response["suggestions"];
+    }
+
+    public function findById($name, $query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        $url = "findById/$name";
+        $data = ["query" => $query, "count" => $count];
+        $data = $data + $kwargs;
+        $response = $this->post($url, $data);
+        return $response["suggestions"];
+    }
+
+    public function geolocate($name, $lat, $lon, $radiusMeters = 100, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        $url = "geolocate/$name";
+        $data = array(
+            "lat" => $lat,
+            "lon" => $lon,
+            "radius_meters" => $radiusMeters,
+            "count" => $count,
+        );
+        $data = $data + $kwargs;
+        $response = $this->post($url, $data);
+        return $response["suggestions"];
+    }
+
+    public function iplocate($ip, $kwargs = [])
+    {
+        $url = "iplocate/address";
+        $query = ["ip" => $ip];
+        $query = $query + $kwargs;
+        $response = $this->get($url, $query);
+        return $response["location"];
+    }
+
+    public function suggest($name, $query, $count = Settings::SUGGESTION_COUNT, $kwargs = [])
+    {
+        $url = "suggest/$name";
+        $data = ["query" => $query, "count" => $count];
+        $data = $data + $kwargs;
+        $response = $this->post($url, $data);
+        return $response["suggestions"];
+    }
+}

lib/Classes/Dadata/autoload.php

+<?php
+spl_autoload_register(function ($class_name) {
+    global $includes;
+    foreach (glob(__DIR__ . "/*.php") as $filename) {
+        if((str_replace('Dadata\\', '', $class_name) . '.php') === basename($filename) && !class_exists($class_name) && __FILE__ !== $filename && file_exists($filename)){
+
+
+            file_put_contents(sfConfig::get('sf_log_dir') . '/auto', $class_name . "\n\n", FILE_APPEND);
+
+
+            require_once $filename;
+        }
+    }
+});
+foreach (glob(__DIR__ . "/*.php") as $filename) {
+    if(__FILE__ !== $filename && file_exists($filename) && basename($filename) !== 'ClientBase.php'){
+        require_once $filename;
+    }
+}
\ No newline at end of file

lib/Classes/PHPExcel.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+
+/**
+ * PHPExcel
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel
+{
+    /**
+     * Unique ID
+     *
+     * @var string
+     */
+    private $_uniqueID;
+
+    /**
+     * Document properties
+     *
+     * @var PHPExcel_DocumentProperties
+     */
+    private $_properties;
+
+    /**
+     * Document security
+     *
+     * @var PHPExcel_DocumentSecurity
+     */
+    private $_security;
+
+    /**
+     * Collection of Worksheet objects
+     *
+     * @var PHPExcel_Worksheet[]
+     */
+    private $_workSheetCollection = array();
+
+    /**
+	 * Calculation Engine
+	 *
+	 * @var PHPExcel_Calculation
+	 */
+	private $_calculationEngine = NULL;
+
+    /**
+     * Active sheet index
+     *
+     * @var int
+     */
+    private $_activeSheetIndex = 0;
+
+    /**
+     * Named ranges
+     *
+     * @var PHPExcel_NamedRange[]
+     */
+    private $_namedRanges = array();
+
+    /**
+     * CellXf supervisor
+     *
+     * @var PHPExcel_Style
+     */
+    private $_cellXfSupervisor;
+
+    /**
+     * CellXf collection
+     *
+     * @var PHPExcel_Style[]
+     */
+    private $_cellXfCollection = array();
+
+    /**
+     * CellStyleXf collection
+     *
+     * @var PHPExcel_Style[]
+     */
+    private $_cellStyleXfCollection = array();
+
+	/**
+	* _hasMacros : this workbook have macros ?
+	*
+	* @var bool
+	*/
+	private $_hasMacros = FALSE;
+
+	/**
+	* _macrosCode : all macros code (the vbaProject.bin file, this include form, code,  etc.), NULL if no macro
+	*
+	* @var binary
+	*/
+	private $_macrosCode=NULL;
+	/**
+	* _macrosCertificate : if macros are signed, contains vbaProjectSignature.bin file, NULL if not signed
+	*
+	* @var binary
+	*/
+	private $_macrosCertificate=NULL;
+
+	/**
+	* _ribbonXMLData : NULL if workbook is'nt Excel 2007 or not contain a customized UI
+	*
+	* @var NULL|string
+	*/
+	private $_ribbonXMLData=NULL;
+
+	/**
+	* _ribbonBinObjects : NULL if workbook is'nt Excel 2007 or not contain embedded objects (picture(s)) for Ribbon Elements
+	* ignored if $_ribbonXMLData is null
+	*
+	* @var NULL|array
+	*/
+	private $_ribbonBinObjects=NULL;
+
+	/**
+	* The workbook has macros ?
+	*
+	* @return true if workbook has macros, false if not
+	*/
+	public function hasMacros(){
+		return $this->_hasMacros;
+	}
+
+	/**
+	* Define if a workbook has macros
+	*
+	* @param true|false
+	*/
+	public function setHasMacros($hasMacros=false){
+		$this->_hasMacros=(bool)$hasMacros;
+	}
+
+	/**
+	* Set the macros code
+	*
+	* @param binary string|null
+	*/
+	public function setMacrosCode($MacrosCode){
+		$this->_macrosCode=$MacrosCode;
+		$this->setHasMacros(!is_null($MacrosCode));
+	}
+
+	/**
+	* Return the macros code
+	*
+	* @return binary|null
+	*/
+	public function getMacrosCode(){
+		return $this->_macrosCode;
+	}
+
+	/**
+	* Set the macros certificate
+	*
+	* @param binary|null
+	*/
+	public function setMacrosCertificate($Certificate=NULL){
+		$this->_macrosCertificate=$Certificate;
+	}
+
+	/**
+	* Is the project signed ?
+	*
+	* @return true|false
+	*/
+	public function hasMacrosCertificate(){
+		return !is_null($this->_macrosCertificate);
+	}
+
+	/**
+	* Return the macros certificate
+	*
+	* @return binary|null
+	*/
+	public function getMacrosCertificate(){
+		return $this->_macrosCertificate;
+	}
+
+	/**
+	* Remove all macros, certificate from spreadsheet
+	*
+	* @param none
+	* @return void
+	*/
+	public function discardMacros(){
+		$this->_hasMacros=false;
+		$this->_macrosCode=NULL;
+		$this->_macrosCertificate=NULL;
+	}
+
+	/**
+	* set ribbon XML data
+	*
+	*/
+	public function setRibbonXMLData($Target=NULL, $XMLData=NULL){
+		if(!is_null($Target) && !is_null($XMLData)){
+			$this->_ribbonXMLData=array('target'=>$Target, 'data'=>$XMLData);
+		}else{
+			$this->_ribbonXMLData=NULL;
+		}
+	}
+
+	/**
+	* retrieve ribbon XML Data
+	*
+	* return string|null|array
+	*/
+	public function getRibbonXMLData($What='all'){//we need some constants here...
+		$ReturnData=NULL;
+		$What=strtolower($What);
+		switch($What){
+		case 'all':
+			$ReturnData=$this->_ribbonXMLData;
+			break;
+		case 'target':
+		case 'data':
+			if(is_array($this->_ribbonXMLData) && array_key_exists($What,$this->_ribbonXMLData)){
+				$ReturnData=$this->_ribbonXMLData[$What];
+			}//else $ReturnData stay at null
+			break;
+		}//default: $ReturnData at null
+		return $ReturnData;
+	}
+
+	/**
+	* store binaries ribbon objects (pictures)
+	*
+	*/
+	public function setRibbonBinObjects($BinObjectsNames=NULL, $BinObjectsData=NULL){
+		if(!is_null($BinObjectsNames) && !is_null($BinObjectsData)){
+			$this->_ribbonBinObjects=array('names'=>$BinObjectsNames, 'data'=>$BinObjectsData);
+		}else{
+			$this->_ribbonBinObjects=NULL;
+		}
+	}
+	/**
+	* return the extension of a filename. Internal use for a array_map callback (php<5.3 don't like lambda function)
+	*
+	*/
+	private function _getExtensionOnly($ThePath){
+		return pathinfo($ThePath, PATHINFO_EXTENSION);
+	}
+
+	/**
+	* retrieve Binaries Ribbon Objects
+	*
+	*/
+	public function getRibbonBinObjects($What='all'){
+		$ReturnData=NULL;
+		$What=strtolower($What);
+		switch($What){
+		case 'all':
+			return $this->_ribbonBinObjects;
+			break;
+		case 'names':
+		case 'data':
+			if(is_array($this->_ribbonBinObjects) && array_key_exists($What, $this->_ribbonBinObjects)){
+				$ReturnData=$this->_ribbonBinObjects[$What];
+			}
+			break;
+		case 'types':
+			if(is_array($this->_ribbonBinObjects) && array_key_exists('data', $this->_ribbonBinObjects) && is_array($this->_ribbonBinObjects['data'])){
+				$tmpTypes=array_keys($this->_ribbonBinObjects['data']);
+				$ReturnData=array_unique(array_map(array($this,'_getExtensionOnly'), $tmpTypes));
+			}else
+				$ReturnData=array();//the caller want an array... not null if empty
+			break;
+		}
+		return $ReturnData;
+	}
+
+	/**
+	* This workbook have a custom UI ?
+	*
+	* @return true|false
+	*/
+	public function hasRibbon(){
+		return !is_null($this->_ribbonXMLData);
+	}
+
+	/**
+	* This workbook have additionnal object for the ribbon ?
+	*
+	* @return true|false
+	*/
+	public function hasRibbonBinObjects(){
+		return !is_null($this->_ribbonBinObjects);
+	}
+
+	/**
+     * Check if a sheet with a specified code name already exists
+     *
+     * @param string $pSheetCodeName  Name of the worksheet to check
+     * @return boolean
+     */
+    public function sheetCodeNameExists($pSheetCodeName)
+    {
+		return ($this->getSheetByCodeName($pSheetCodeName) !== NULL);
+    }
+
+	/**
+	 * Get sheet by code name. Warning : sheet don't have always a code name !
+	 *
+	 * @param string $pName Sheet name
+	 * @return PHPExcel_Worksheet
+	 */
+	public function getSheetByCodeName($pName = '')
+	{
+		$worksheetCount = count($this->_workSheetCollection);
+		for ($i = 0; $i < $worksheetCount; ++$i) {
+			if ($this->_workSheetCollection[$i]->getCodeName() == $pName) {
+				return $this->_workSheetCollection[$i];
+			}
+		}
+
+		return null;
+	}
+
+	 /**
+	 * Create a new PHPExcel with one Worksheet
+	 */
+	public function __construct()
+	{
+		$this->_uniqueID = uniqid();
+		$this->_calculationEngine	= PHPExcel_Calculation::getInstance($this);
+
+		// Initialise worksheet collection and add one worksheet
+		$this->_workSheetCollection = array();
+		$this->_workSheetCollection[] = new PHPExcel_Worksheet($this);
+		$this->_activeSheetIndex = 0;
+
+        // Create document properties
+        $this->_properties = new PHPExcel_DocumentProperties();
+
+        // Create document security
+        $this->_security = new PHPExcel_DocumentSecurity();
+
+        // Set named ranges
+        $this->_namedRanges = array();
+
+        // Create the cellXf supervisor
+        $this->_cellXfSupervisor = new PHPExcel_Style(true);
+        $this->_cellXfSupervisor->bindParent($this);
+
+        // Create the default style
+        $this->addCellXf(new PHPExcel_Style);
+        $this->addCellStyleXf(new PHPExcel_Style);
+    }
+
+    /**
+     * Code to execute when this worksheet is unset()
+     *
+     */
+    public function __destruct() {
+        PHPExcel_Calculation::unsetInstance($this);
+        $this->disconnectWorksheets();
+    }    //    function __destruct()
+
+    /**
+     * Disconnect all worksheets from this PHPExcel workbook object,
+     *    typically so that the PHPExcel object can be unset
+     *
+     */
+    public function disconnectWorksheets()
+    {
+    	$worksheet = NULL;
+        foreach($this->_workSheetCollection as $k => &$worksheet) {
+            $worksheet->disconnectCells();
+            $this->_workSheetCollection[$k] = null;
+        }
+        unset($worksheet);
+        $this->_workSheetCollection = array();
+    }
+
+	/**
+	 * Return the calculation engine for this worksheet
+	 *
+	 * @return PHPExcel_Calculation
+	 */
+	public function getCalculationEngine()
+	{
+		return $this->_calculationEngine;
+	}	//	function getCellCacheController()
+
+    /**
+     * Get properties
+     *
+     * @return PHPExcel_DocumentProperties
+     */
+    public function getProperties()
+    {
+        return $this->_properties;
+    }
+
+    /**
+     * Set properties
+     *
+     * @param PHPExcel_DocumentProperties    $pValue
+     */
+    public function setProperties(PHPExcel_DocumentProperties $pValue)
+    {
+        $this->_properties = $pValue;
+    }
+
+    /**
+     * Get security
+     *
+     * @return PHPExcel_DocumentSecurity
+     */
+    public function getSecurity()
+    {
+        return $this->_security;
+    }
+
+    /**
+     * Set security
+     *
+     * @param PHPExcel_DocumentSecurity    $pValue
+     */
+    public function setSecurity(PHPExcel_DocumentSecurity $pValue)
+    {
+        $this->_security = $pValue;
+    }
+
+    /**
+     * Get active sheet
+     *
+     * @return PHPExcel_Worksheet
+     */
+    public function getActiveSheet()
+    {
+        return $this->_workSheetCollection[$this->_activeSheetIndex];
+    }
+
+    /**
+     * Create sheet and add it to this workbook
+     *
+     * @param  int|null $iSheetIndex Index where sheet should go (0,1,..., or null for last)
+     * @return PHPExcel_Worksheet
+     * @throws PHPExcel_Exception
+     */
+    public function createSheet($iSheetIndex = NULL)
+    {
+        $newSheet = new PHPExcel_Worksheet($this);
+        $this->addSheet($newSheet, $iSheetIndex);
+        return $newSheet;
+    }
+
+    /**
+     * Check if a sheet with a specified name already exists
+     *
+     * @param  string $pSheetName  Name of the worksheet to check
+     * @return boolean
+     */
+    public function sheetNameExists($pSheetName)
+    {
+        return ($this->getSheetByName($pSheetName) !== NULL);
+    }
+
+    /**
+     * Add sheet
+     *
+     * @param  PHPExcel_Worksheet $pSheet
+     * @param  int|null $iSheetIndex Index where sheet should go (0,1,..., or null for last)
+     * @return PHPExcel_Worksheet
+     * @throws PHPExcel_Exception
+     */
+    public function addSheet(PHPExcel_Worksheet $pSheet, $iSheetIndex = NULL)
+    {
+        if ($this->sheetNameExists($pSheet->getTitle())) {
+            throw new PHPExcel_Exception(
+            	"Workbook already contains a worksheet named '{$pSheet->getTitle()}'. Rename this worksheet first."
+            );
+        }
+
+        if($iSheetIndex === NULL) {
+            if ($this->_activeSheetIndex < 0) {
+                $this->_activeSheetIndex = 0;
+            }
+            $this->_workSheetCollection[] = $pSheet;
+        } else {
+            // Insert the sheet at the requested index
+            array_splice(
+                $this->_workSheetCollection,
+                $iSheetIndex,
+                0,
+                array($pSheet)
+                );
+
+            // Adjust active sheet index if necessary
+            if ($this->_activeSheetIndex >= $iSheetIndex) {
+                ++$this->_activeSheetIndex;
+            }
+        }
+
+        if ($pSheet->getParent() === null) {
+            $pSheet->rebindParent($this);
+        }
+
+        return $pSheet;
+    }
+
+    /**
+     * Remove sheet by index
+     *
+     * @param  int $pIndex Active sheet index
+     * @throws PHPExcel_Exception
+     */
+    public function removeSheetByIndex($pIndex = 0)
+    {
+
+        $numSheets = count($this->_workSheetCollection);
+
+        if ($pIndex > $numSheets - 1) {
+            throw new PHPExcel_Exception(
+            	"You tried to remove a sheet by the out of bounds index: {$pIndex}. The actual number of sheets is {$numSheets}."
+            );
+        } else {
+            array_splice($this->_workSheetCollection, $pIndex, 1);
+        }
+        // Adjust active sheet index if necessary
+        if (($this->_activeSheetIndex >= $pIndex) &&
+            ($pIndex > count($this->_workSheetCollection) - 1)) {
+            --$this->_activeSheetIndex;
+        }
+
+    }
+
+    /**
+     * Get sheet by index
+     *
+     * @param  int $pIndex Sheet index
+     * @return PHPExcel_Worksheet
+     * @throws PHPExcel_Exception
+     */
+    public function getSheet($pIndex = 0)
+    {
+
+        $numSheets = count($this->_workSheetCollection);
+
+        if ($pIndex > $numSheets - 1) {
+            throw new PHPExcel_Exception(
+            	"Your requested sheet index: {$pIndex} is out of bounds. The actual number of sheets is {$numSheets}."
+           	);
+        } else {
+            return $this->_workSheetCollection[$pIndex];
+        }
+    }
+
+    /**
+     * Get all sheets
+     *
+     * @return PHPExcel_Worksheet[]
+     */
+    public function getAllSheets()
+    {
+        return $this->_workSheetCollection;
+    }
+
+    /**
+     * Get sheet by name
+     *
+     * @param  string $pName Sheet name
+     * @return PHPExcel_Worksheet
+     */
+    public function getSheetByName($pName = '')
+    {
+        $worksheetCount = count($this->_workSheetCollection);
+        for ($i = 0; $i < $worksheetCount; ++$i) {
+            if ($this->_workSheetCollection[$i]->getTitle() === $pName) {
+                return $this->_workSheetCollection[$i];
+            }
+        }
+
+        return NULL;
+    }
+
+    /**
+     * Get index for sheet
+     *
+     * @param  PHPExcel_Worksheet $pSheet
+     * @return Sheet index
+     * @throws PHPExcel_Exception
+     */
+    public function getIndex(PHPExcel_Worksheet $pSheet)
+    {
+        foreach ($this->_workSheetCollection as $key => $value) {
+            if ($value->getHashCode() == $pSheet->getHashCode()) {
+                return $key;
+            }
+        }
+
+        throw new PHPExcel_Exception("Sheet does not exist.");
+    }
+
+    /**
+     * Set index for sheet by sheet name.
+     *
+     * @param  string $sheetName Sheet name to modify index for
+     * @param  int $newIndex New index for the sheet
+     * @return New sheet index
+     * @throws PHPExcel_Exception
+     */
+    public function setIndexByName($sheetName, $newIndex)
+    {
+        $oldIndex = $this->getIndex($this->getSheetByName($sheetName));
+        $pSheet = array_splice(
+            $this->_workSheetCollection,
+            $oldIndex,
+            1
+        );
+        array_splice(
+            $this->_workSheetCollection,
+            $newIndex,
+            0,
+            $pSheet
+        );
+        return $newIndex;
+    }
+
+    /**
+     * Get sheet count
+     *
+     * @return int
+     */
+    public function getSheetCount()
+    {
+        return count($this->_workSheetCollection);
+    }
+
+    /**
+     * Get active sheet index
+     *
+     * @return int Active sheet index
+     */
+    public function getActiveSheetIndex()
+    {
+        return $this->_activeSheetIndex;
+    }
+
+    /**
+     * Set active sheet index
+     *
+     * @param  int $pIndex Active sheet index
+     * @throws PHPExcel_Exception
+     * @return PHPExcel_Worksheet
+     */
+    public function setActiveSheetIndex($pIndex = 0)
+    {
+    		$numSheets = count($this->_workSheetCollection);
+
+        if ($pIndex > $numSheets - 1) {
+            throw new PHPExcel_Exception(
+            	"You tried to set a sheet active by the out of bounds index: {$pIndex}. The actual number of sheets is {$numSheets}."
+            );
+        } else {
+            $this->_activeSheetIndex = $pIndex;
+        }
+        return $this->getActiveSheet();
+    }
+
+    /**
+     * Set active sheet index by name
+     *
+     * @param  string $pValue Sheet title
+     * @return PHPExcel_Worksheet
+     * @throws PHPExcel_Exception
+     */
+    public function setActiveSheetIndexByName($pValue = '')
+    {
+        if (($worksheet = $this->getSheetByName($pValue)) instanceof PHPExcel_Worksheet) {
+            $this->setActiveSheetIndex($this->getIndex($worksheet));
+            return $worksheet;
+        }
+
+        throw new PHPExcel_Exception('Workbook does not contain sheet:' . $pValue);
+    }
+
+    /**
+     * Get sheet names
+     *
+     * @return string[]
+     */
+    public function getSheetNames()
+    {
+        $returnValue = array();
+        $worksheetCount = $this->getSheetCount();
+        for ($i = 0; $i < $worksheetCount; ++$i) {
+            $returnValue[] = $this->getSheet($i)->getTitle();
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * Add external sheet
+     *
+     * @param  PHPExcel_Worksheet $pSheet External sheet to add
+     * @param  int|null $iSheetIndex Index where sheet should go (0,1,..., or null for last)
+     * @throws PHPExcel_Exception
+     * @return PHPExcel_Worksheet
+     */
+    public function addExternalSheet(PHPExcel_Worksheet $pSheet, $iSheetIndex = null) {
+        if ($this->sheetNameExists($pSheet->getTitle())) {
+            throw new PHPExcel_Exception("Workbook already contains a worksheet named '{$pSheet->getTitle()}'. Rename the external sheet first.");
+        }
+
+        // count how many cellXfs there are in this workbook currently, we will need this below
+        $countCellXfs = count($this->_cellXfCollection);
+
+        // copy all the shared cellXfs from the external workbook and append them to the current
+        foreach ($pSheet->getParent()->getCellXfCollection() as $cellXf) {
+            $this->addCellXf(clone $cellXf);
+        }
+
+        // move sheet to this workbook
+        $pSheet->rebindParent($this);
+
+        // update the cellXfs
+        foreach ($pSheet->getCellCollection(false) as $cellID) {
+            $cell = $pSheet->getCell($cellID);
+            $cell->setXfIndex( $cell->getXfIndex() + $countCellXfs );
+        }
+
+        return $this->addSheet($pSheet, $iSheetIndex);
+    }
+
+    /**
+     * Get named ranges
+     *
+     * @return PHPExcel_NamedRange[]
+     */
+    public function getNamedRanges() {
+        return $this->_namedRanges;
+    }
+
+    /**
+     * Add named range
+     *
+     * @param  PHPExcel_NamedRange $namedRange
+     * @return PHPExcel
+     */
+    public function addNamedRange(PHPExcel_NamedRange $namedRange) {
+        if ($namedRange->getScope() == null) {
+            // global scope
+            $this->_namedRanges[$namedRange->getName()] = $namedRange;
+        } else {
+            // local scope
+            $this->_namedRanges[$namedRange->getScope()->getTitle().'!'.$namedRange->getName()] = $namedRange;
+        }
+        return true;
+    }
+
+    /**
+     * Get named range
+     *
+     * @param  string $namedRange
+     * @param  PHPExcel_Worksheet|null $pSheet Scope. Use null for global scope
+     * @return PHPExcel_NamedRange|null
+     */
+    public function getNamedRange($namedRange, PHPExcel_Worksheet $pSheet = null) {
+        $returnValue = null;
+
+        if ($namedRange != '' && ($namedRange !== NULL)) {
+            // first look for global defined name
+            if (isset($this->_namedRanges[$namedRange])) {
+                $returnValue = $this->_namedRanges[$namedRange];
+            }
+
+            // then look for local defined name (has priority over global defined name if both names exist)
+            if (($pSheet !== NULL) && isset($this->_namedRanges[$pSheet->getTitle() . '!' . $namedRange])) {
+                $returnValue = $this->_namedRanges[$pSheet->getTitle() . '!' . $namedRange];
+            }
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * Remove named range
+     *
+     * @param  string  $namedRange
+     * @param  PHPExcel_Worksheet|null  $pSheet  Scope: use null for global scope.
+     * @return PHPExcel
+     */
+    public function removeNamedRange($namedRange, PHPExcel_Worksheet $pSheet = null) {
+        if ($pSheet === NULL) {
+            if (isset($this->_namedRanges[$namedRange])) {
+                unset($this->_namedRanges[$namedRange]);
+            }
+        } else {
+            if (isset($this->_namedRanges[$pSheet->getTitle() . '!' . $namedRange])) {
+                unset($this->_namedRanges[$pSheet->getTitle() . '!' . $namedRange]);
+            }
+        }
+        return $this;
+    }
+
+    /**
+     * Get worksheet iterator
+     *
+     * @return PHPExcel_WorksheetIterator
+     */
+    public function getWorksheetIterator() {
+        return new PHPExcel_WorksheetIterator($this);
+    }
+
+    /**
+     * Copy workbook (!= clone!)
+     *
+     * @return PHPExcel
+     */
+    public function copy() {
+        $copied = clone $this;
+
+        $worksheetCount = count($this->_workSheetCollection);
+        for ($i = 0; $i < $worksheetCount; ++$i) {
+            $this->_workSheetCollection[$i] = $this->_workSheetCollection[$i]->copy();
+            $this->_workSheetCollection[$i]->rebindParent($this);
+        }
+
+        return $copied;
+    }
+
+    /**
+     * Implement PHP __clone to create a deep clone, not just a shallow copy.
+     */
+    public function __clone() {
+        foreach($this as $key => $val) {
+            if (is_object($val) || (is_array($val))) {
+                $this->{$key} = unserialize(serialize($val));
+            }
+        }
+    }
+
+    /**
+     * Get the workbook collection of cellXfs
+     *
+     * @return PHPExcel_Style[]
+     */
+    public function getCellXfCollection()
+    {
+        return $this->_cellXfCollection;
+    }
+
+    /**
+     * Get cellXf by index
+     *
+     * @param  int $pIndex
+     * @return PHPExcel_Style
+     */
+    public function getCellXfByIndex($pIndex = 0)
+    {
+        return $this->_cellXfCollection[$pIndex];
+    }
+
+    /**
+     * Get cellXf by hash code
+     *
+     * @param  string $pValue
+     * @return PHPExcel_Style|false
+     */
+    public function getCellXfByHashCode($pValue = '')
+    {
+        foreach ($this->_cellXfCollection as $cellXf) {
+            if ($cellXf->getHashCode() == $pValue) {
+                return $cellXf;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Check if style exists in style collection
+     *
+     * @param  PHPExcel_Style $pCellStyle
+     * @return boolean
+     */
+    public function cellXfExists($pCellStyle = null)
+    {
+        return in_array($pCellStyle, $this->_cellXfCollection, true);
+    }
+
+    /**
+     * Get default style
+     *
+     * @return PHPExcel_Style
+     * @throws PHPExcel_Exception
+     */
+    public function getDefaultStyle()
+    {
+        if (isset($this->_cellXfCollection[0])) {
+            return $this->_cellXfCollection[0];
+        }
+        throw new PHPExcel_Exception('No default style found for this workbook');
+    }
+
+    /**
+     * Add a cellXf to the workbook
+     *
+     * @param PHPExcel_Style $style
+     */
+    public function addCellXf(PHPExcel_Style $style)
+    {
+        $this->_cellXfCollection[] = $style;
+        $style->setIndex(count($this->_cellXfCollection) - 1);
+    }
+
+    /**
+     * Remove cellXf by index. It is ensured that all cells get their xf index updated.
+     *
+     * @param  int $pIndex Index to cellXf
+     * @throws PHPExcel_Exception
+     */
+    public function removeCellXfByIndex($pIndex = 0)
+    {
+        if ($pIndex > count($this->_cellXfCollection) - 1) {
+            throw new PHPExcel_Exception("CellXf index is out of bounds.");
+        } else {
+            // first remove the cellXf
+            array_splice($this->_cellXfCollection, $pIndex, 1);
+
+            // then update cellXf indexes for cells
+            foreach ($this->_workSheetCollection as $worksheet) {
+                foreach ($worksheet->getCellCollection(false) as $cellID) {
+                    $cell = $worksheet->getCell($cellID);
+                    $xfIndex = $cell->getXfIndex();
+                    if ($xfIndex > $pIndex ) {
+                        // decrease xf index by 1
+                        $cell->setXfIndex($xfIndex - 1);
+                    } else if ($xfIndex == $pIndex) {
+                        // set to default xf index 0
+                        $cell->setXfIndex(0);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the cellXf supervisor
+     *
+     * @return PHPExcel_Style
+     */
+    public function getCellXfSupervisor()
+    {
+        return $this->_cellXfSupervisor;
+    }
+
+    /**
+     * Get the workbook collection of cellStyleXfs
+     *
+     * @return PHPExcel_Style[]
+     */
+    public function getCellStyleXfCollection()
+    {
+        return $this->_cellStyleXfCollection;
+    }
+
+    /**
+     * Get cellStyleXf by index
+     *
+     * @param  int $pIndex
+     * @return PHPExcel_Style
+     */
+    public function getCellStyleXfByIndex($pIndex = 0)
+    {
+        return $this->_cellStyleXfCollection[$pIndex];
+    }
+
+    /**
+     * Get cellStyleXf by hash code
+     *
+     * @param  string $pValue
+     * @return PHPExcel_Style|false
+     */
+    public function getCellStyleXfByHashCode($pValue = '')
+    {
+        foreach ($this->_cellXfStyleCollection as $cellStyleXf) {
+            if ($cellStyleXf->getHashCode() == $pValue) {
+                return $cellStyleXf;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Add a cellStyleXf to the workbook
+     *
+     * @param PHPExcel_Style $pStyle
+     */
+    public function addCellStyleXf(PHPExcel_Style $pStyle)
+    {
+        $this->_cellStyleXfCollection[] = $pStyle;
+        $pStyle->setIndex(count($this->_cellStyleXfCollection) - 1);
+    }
+
+    /**
+     * Remove cellStyleXf by index
+     *
+     * @param int $pIndex
+     * @throws PHPExcel_Exception
+     */
+    public function removeCellStyleXfByIndex($pIndex = 0)
+    {
+        if ($pIndex > count($this->_cellStyleXfCollection) - 1) {
+            throw new PHPExcel_Exception("CellStyleXf index is out of bounds.");
+        } else {
+            array_splice($this->_cellStyleXfCollection, $pIndex, 1);
+        }
+    }
+
+    /**
+     * Eliminate all unneeded cellXf and afterwards update the xfIndex for all cells
+     * and columns in the workbook
+     */
+    public function garbageCollect()
+    {
+        // how many references are there to each cellXf ?
+        $countReferencesCellXf = array();
+        foreach ($this->_cellXfCollection as $index => $cellXf) {
+            $countReferencesCellXf[$index] = 0;
+        }
+
+        foreach ($this->getWorksheetIterator() as $sheet) {
+
+            // from cells
+            foreach ($sheet->getCellCollection(false) as $cellID) {
+                $cell = $sheet->getCell($cellID);
+                ++$countReferencesCellXf[$cell->getXfIndex()];
+            }
+
+            // from row dimensions
+            foreach ($sheet->getRowDimensions() as $rowDimension) {
+                if ($rowDimension->getXfIndex() !== null) {
+                    ++$countReferencesCellXf[$rowDimension->getXfIndex()];
+                }
+            }
+
+            // from column dimensions
+            foreach ($sheet->getColumnDimensions() as $columnDimension) {
+                ++$countReferencesCellXf[$columnDimension->getXfIndex()];
+            }
+        }
+
+        // remove cellXfs without references and create mapping so we can update xfIndex
+        // for all cells and columns
+        $countNeededCellXfs = 0;
+        foreach ($this->_cellXfCollection as $index => $cellXf) {
+            if ($countReferencesCellXf[$index] > 0 || $index == 0) { // we must never remove the first cellXf
+                ++$countNeededCellXfs;
+            } else {
+                unset($this->_cellXfCollection[$index]);
+            }
+            $map[$index] = $countNeededCellXfs - 1;
+        }
+        $this->_cellXfCollection = array_values($this->_cellXfCollection);
+
+        // update the index for all cellXfs
+        foreach ($this->_cellXfCollection as $i => $cellXf) {
+            $cellXf->setIndex($i);
+        }
+
+        // make sure there is always at least one cellXf (there should be)
+        if (empty($this->_cellXfCollection)) {
+            $this->_cellXfCollection[] = new PHPExcel_Style();
+        }
+
+        // update the xfIndex for all cells, row dimensions, column dimensions
+        foreach ($this->getWorksheetIterator() as $sheet) {
+
+            // for all cells
+            foreach ($sheet->getCellCollection(false) as $cellID) {
+                $cell = $sheet->getCell($cellID);
+                $cell->setXfIndex( $map[$cell->getXfIndex()] );
+            }
+
+            // for all row dimensions
+            foreach ($sheet->getRowDimensions() as $rowDimension) {
+                if ($rowDimension->getXfIndex() !== null) {
+                    $rowDimension->setXfIndex( $map[$rowDimension->getXfIndex()] );
+                }
+            }
+
+            // for all column dimensions
+            foreach ($sheet->getColumnDimensions() as $columnDimension) {
+                $columnDimension->setXfIndex( $map[$columnDimension->getXfIndex()] );
+            }
+
+			// also do garbage collection for all the sheets
+            $sheet->garbageCollect();
+        }
+    }
+
+    /**
+     * Return the unique ID value assigned to this spreadsheet workbook
+     *
+     * @return string
+     */
+    public function getID() {
+        return $this->_uniqueID;
+    }
+
+}

lib/Classes/PHPExcel/Autoloader.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+PHPExcel_Autoloader::Register();
+//    As we always try to run the autoloader before anything else, we can use it to do a few
+//        simple checks and initialisations
+//PHPExcel_Shared_ZipStreamWrapper::register();
+// check mbstring.func_overload
+if (ini_get('mbstring.func_overload') & 2) {
+    throw new PHPExcel_Exception('Multibyte function overloading in PHP must be disabled for string functions (2).');
+}
+PHPExcel_Shared_String::buildCharacterSets();
+
+
+/**
+ * PHPExcel_Autoloader
+ *
+ * @category    PHPExcel
+ * @package     PHPExcel
+ * @copyright   Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Autoloader
+{
+    /**
+     * Register the Autoloader with SPL
+     *
+     */
+    public static function Register() {
+        if (function_exists('__autoload')) {
+            //    Register any existing autoloader function with SPL, so we don't get any clashes
+            spl_autoload_register('__autoload');
+        }
+        //    Register ourselves with SPL
+        return spl_autoload_register(array('PHPExcel_Autoloader', 'Load'));
+    }   //    function Register()
+
+
+    /**
+     * Autoload a class identified by name
+     *
+     * @param    string    $pClassName        Name of the object to load
+     */
+    public static function Load($pClassName){
+        if ((class_exists($pClassName,FALSE)) || (strpos($pClassName, 'PHPExcel') !== 0)) {
+            //    Either already loaded, or not a PHPExcel class request
+            return FALSE;
+        }
+
+        $pClassFilePath = PHPEXCEL_ROOT .
+                          str_replace('_',DIRECTORY_SEPARATOR,$pClassName) .
+                          '.php';
+
+        if ((file_exists($pClassFilePath) === FALSE) || (is_readable($pClassFilePath) === FALSE)) {
+            //    Can't load
+            return FALSE;
+        }
+
+        require($pClassFilePath);
+    }   //    function Load()
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/APC.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_APC
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_CachedObjectStorage_APC extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
+
+    /**
+     * Prefix used to uniquely identify cache data for this worksheet
+     *
+     * @access    private
+     * @var string
+     */
+    private $_cachePrefix = null;
+
+    /**
+     * Cache timeout
+     *
+     * @access    private
+     * @var integer
+     */
+    private $_cacheTime = 600;
+
+
+    /**
+     * Store cell data in cache for the current cell object if it's "dirty",
+     *     and the 'nullify' the current cell object
+     *
+     * @access  private
+     * @return  void
+     * @throws  PHPExcel_Exception
+     */
+    protected function _storeData() {
+        if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
+            $this->_currentObject->detach();
+
+            if (!apc_store($this->_cachePrefix.$this->_currentObjectID.'.cache',serialize($this->_currentObject),$this->_cacheTime)) {
+                $this->__destruct();
+                throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in APC');
+            }
+            $this->_currentCellIsDirty = false;
+        }
+        $this->_currentObjectID = $this->_currentObject = null;
+    }    //    function _storeData()
+
+
+    /**
+     * Add or Update a cell in cache identified by coordinate address
+     *
+     * @access  public
+     * @param   string         $pCoord  Coordinate address of the cell to update
+     * @param   PHPExcel_Cell  $cell    Cell to update
+     * @return  void
+     * @throws  PHPExcel_Exception
+     */
+    public function addCacheData($pCoord, PHPExcel_Cell $cell) {
+        if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
+            $this->_storeData();
+        }
+        $this->_cellCache[$pCoord] = true;
+
+        $this->_currentObjectID = $pCoord;
+        $this->_currentObject = $cell;
+        $this->_currentCellIsDirty = true;
+
+        return $cell;
+    }    //    function addCacheData()
+
+
+    /**
+     * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
+     *
+     * @access  public
+     * @param   string  $pCoord  Coordinate address of the cell to check
+     * @return  void
+     * @return  boolean
+     */
+    public function isDataSet($pCoord) {
+        //    Check if the requested entry is the current object, or exists in the cache
+        if (parent::isDataSet($pCoord)) {
+            if ($this->_currentObjectID == $pCoord) {
+                return true;
+            }
+            //    Check if the requested entry still exists in apc
+            $success = apc_fetch($this->_cachePrefix.$pCoord.'.cache');
+            if ($success === FALSE) {
+                //    Entry no longer exists in APC, so clear it from the cache array
+                parent::deleteCacheData($pCoord);
+                throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in APC cache');
+            }
+            return true;
+        }
+        return false;
+    }    //    function isDataSet()
+
+
+    /**
+     * Get cell at a specific coordinate
+     *
+     * @access  public
+     * @param   string         $pCoord  Coordinate of the cell
+     * @throws  PHPExcel_Exception
+     * @return  PHPExcel_Cell  Cell that was found, or null if not found
+     */
+    public function getCacheData($pCoord) {
+        if ($pCoord === $this->_currentObjectID) {
+            return $this->_currentObject;
+        }
+        $this->_storeData();
+
+        //    Check if the entry that has been requested actually exists
+        if (parent::isDataSet($pCoord)) {
+            $obj = apc_fetch($this->_cachePrefix.$pCoord.'.cache');
+            if ($obj === FALSE) {
+                //    Entry no longer exists in APC, so clear it from the cache array
+                parent::deleteCacheData($pCoord);
+                throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in APC cache');
+            }
+        } else {
+            //    Return null if requested entry doesn't exist in cache
+            return null;
+        }
+
+        //    Set current entry to the requested entry
+        $this->_currentObjectID = $pCoord;
+        $this->_currentObject = unserialize($obj);
+        //    Re-attach this as the cell's parent
+        $this->_currentObject->attach($this);
+
+        //    Return requested entry
+        return $this->_currentObject;
+    }    //    function getCacheData()
+
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return  array of string
+	 */
+	public function getCellList() {
+		if ($this->_currentObjectID !== null) {
+			$this->_storeData();
+		}
+
+		return parent::getCellList();
+	}
+
+
+    /**
+     * Delete a cell in cache identified by coordinate address
+     *
+     * @access  public
+     * @param   string  $pCoord  Coordinate address of the cell to delete
+     * @throws  PHPExcel_Exception
+     */
+    public function deleteCacheData($pCoord) {
+        //    Delete the entry from APC
+        apc_delete($this->_cachePrefix.$pCoord.'.cache');
+
+        //    Delete the entry from our cell address array
+        parent::deleteCacheData($pCoord);
+    }    //    function deleteCacheData()
+
+
+    /**
+     * Clone the cell collection
+     *
+     * @access  public
+     * @param   PHPExcel_Worksheet  $parent  The new worksheet
+     * @throws  PHPExcel_Exception
+     * @return  void
+     */
+    public function copyCellCollection(PHPExcel_Worksheet $parent) {
+        parent::copyCellCollection($parent);
+        //    Get a new id for the new file name
+        $baseUnique = $this->_getUniqueID();
+        $newCachePrefix = substr(md5($baseUnique),0,8).'.';
+        $cacheList = $this->getCellList();
+        foreach($cacheList as $cellID) {
+            if ($cellID != $this->_currentObjectID) {
+                $obj = apc_fetch($this->_cachePrefix.$cellID.'.cache');
+                if ($obj === FALSE) {
+                    //    Entry no longer exists in APC, so clear it from the cache array
+                    parent::deleteCacheData($cellID);
+                    throw new PHPExcel_Exception('Cell entry '.$cellID.' no longer exists in APC');
+                }
+                if (!apc_store($newCachePrefix.$cellID.'.cache',$obj,$this->_cacheTime)) {
+                    $this->__destruct();
+                    throw new PHPExcel_Exception('Failed to store cell '.$cellID.' in APC');
+                }
+            }
+        }
+        $this->_cachePrefix = $newCachePrefix;
+    }    //    function copyCellCollection()
+
+
+    /**
+     * Clear the cell collection and disconnect from our parent
+     *
+     * @return  void
+     */
+    public function unsetWorksheetCells() {
+        if ($this->_currentObject !== NULL) {
+            $this->_currentObject->detach();
+            $this->_currentObject = $this->_currentObjectID = null;
+        }
+
+        //    Flush the APC cache
+        $this->__destruct();
+
+        $this->_cellCache = array();
+
+        //    detach ourself from the worksheet, so that it can then delete this object successfully
+        $this->_parent = null;
+    }    //    function unsetWorksheetCells()
+
+
+    /**
+     * Initialise this new cell collection
+     *
+     * @param  PHPExcel_Worksheet  $parent     The worksheet for this cell collection
+     * @param  array of mixed      $arguments  Additional initialisation arguments
+     */
+    public function __construct(PHPExcel_Worksheet $parent, $arguments) {
+        $cacheTime = (isset($arguments['cacheTime'])) ? $arguments['cacheTime'] : 600;
+
+        if ($this->_cachePrefix === NULL) {
+            $baseUnique = $this->_getUniqueID();
+            $this->_cachePrefix = substr(md5($baseUnique),0,8).'.';
+            $this->_cacheTime = $cacheTime;
+
+            parent::__construct($parent);
+        }
+    }    //    function __construct()
+
+
+    /**
+     * Destroy this cell collection
+     */
+    public function __destruct() {
+        $cacheList = $this->getCellList();
+        foreach($cacheList as $cellID) {
+            apc_delete($this->_cachePrefix.$cellID.'.cache');
+        }
+    }    //    function __destruct()
+
+
+    /**
+     * Identify whether the caching method is currently available
+     * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
+     *
+     * @return  boolean
+     */
+    public static function cacheMethodIsAvailable() {
+        if (!function_exists('apc_store')) {
+            return FALSE;
+        }
+        if (apc_sma_info() === FALSE) {
+            return FALSE;
+        }
+
+        return TRUE;
+    }
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/CacheBase.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_CacheBase
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+abstract class PHPExcel_CachedObjectStorage_CacheBase {
+
+	/**
+	 * Parent worksheet
+	 *
+	 * @var PHPExcel_Worksheet
+	 */
+	protected $_parent;
+
+	/**
+	 * The currently active Cell
+	 *
+	 * @var PHPExcel_Cell
+	 */
+	protected $_currentObject = null;
+
+	/**
+	 * Coordinate address of the currently active Cell
+	 *
+	 * @var string
+	 */
+	protected $_currentObjectID = null;
+
+
+	/**
+	 * Flag indicating whether the currently active Cell requires saving
+	 *
+	 * @var boolean
+	 */
+	protected $_currentCellIsDirty = true;
+
+	/**
+	 * An array of cells or cell pointers for the worksheet cells held in this cache,
+	 *		and indexed by their coordinate address within the worksheet
+	 *
+	 * @var array of mixed
+	 */
+	protected $_cellCache = array();
+
+
+	/**
+	 * Initialise this new cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The worksheet for this cell collection
+	 */
+	public function __construct(PHPExcel_Worksheet $parent) {
+		//	Set our parent worksheet.
+		//	This is maintained within the cache controller to facilitate re-attaching it to PHPExcel_Cell objects when
+		//		they are woken from a serialized state
+		$this->_parent = $parent;
+	}	//	function __construct()
+
+
+	/**
+	 * Return the parent worksheet for this cell collection
+	 *
+	 * @return	PHPExcel_Worksheet
+	 */
+	public function getParent()
+	{
+		return $this->_parent;
+	}
+
+	/**
+	 * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
+	 *
+	 * @param	string		$pCoord		Coordinate address of the cell to check
+	 * @return	boolean
+	 */
+	public function isDataSet($pCoord) {
+		if ($pCoord === $this->_currentObjectID) {
+			return true;
+		}
+		//	Check if the requested entry exists in the cache
+		return isset($this->_cellCache[$pCoord]);
+	}	//	function isDataSet()
+
+
+	/**
+	 * Move a cell object from one address to another
+	 *
+	 * @param	string		$fromAddress	Current address of the cell to move
+	 * @param	string		$toAddress		Destination address of the cell to move
+	 * @return	boolean
+	 */
+	public function moveCell($fromAddress, $toAddress) {
+		if ($fromAddress === $this->_currentObjectID) {
+			$this->_currentObjectID = $toAddress;
+		}
+		$this->_currentCellIsDirty = true;
+		if (isset($this->_cellCache[$fromAddress])) {
+			$this->_cellCache[$toAddress] = &$this->_cellCache[$fromAddress];
+			unset($this->_cellCache[$fromAddress]);
+		}
+
+		return TRUE;
+	}	//	function moveCell()
+
+
+    /**
+     * Add or Update a cell in cache
+     *
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function updateCacheData(PHPExcel_Cell $cell) {
+		return $this->addCacheData($cell->getCoordinate(),$cell);
+	}	//	function updateCacheData()
+
+
+    /**
+     * Delete a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to delete
+     * @throws	PHPExcel_Exception
+     */
+	public function deleteCacheData($pCoord) {
+		if ($pCoord === $this->_currentObjectID) {
+			$this->_currentObject->detach();
+			$this->_currentObjectID = $this->_currentObject = null;
+		}
+
+		if (is_object($this->_cellCache[$pCoord])) {
+			$this->_cellCache[$pCoord]->detach();
+			unset($this->_cellCache[$pCoord]);
+		}
+		$this->_currentCellIsDirty = false;
+	}	//	function deleteCacheData()
+
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return	array of string
+	 */
+	public function getCellList() {
+		return array_keys($this->_cellCache);
+	}	//	function getCellList()
+
+
+	/**
+	 * Sort the list of all cell addresses currently held in cache by row and column
+	 *
+	 * @return	void
+	 */
+	public function getSortedCellList() {
+		$sortKeys = array();
+		foreach ($this->getCellList() as $coord) {
+			sscanf($coord,'%[A-Z]%d', $column, $row);
+			$sortKeys[sprintf('%09d%3s',$row,$column)] = $coord;
+		}
+		ksort($sortKeys);
+
+		return array_values($sortKeys);
+	}	//	function sortCellList()
+
+
+
+	/**
+	 * Get highest worksheet column and highest row that have cell records
+	 *
+	 * @return array Highest column name and highest row number
+	 */
+	public function getHighestRowAndColumn()
+	{
+		// Lookup highest column and highest row
+		$col = array('A' => '1A');
+		$row = array(1);
+		foreach ($this->getCellList() as $coord) {
+			sscanf($coord,'%[A-Z]%d', $c, $r);
+			$row[$r] = $r;
+			$col[$c] = strlen($c).$c;
+		}
+		if (!empty($row)) {
+			// Determine highest column and row
+			$highestRow = max($row);
+			$highestColumn = substr(max($col),1);
+		}
+
+		return array( 'row'	   => $highestRow,
+					  'column' => $highestColumn
+					);
+	}
+
+
+	/**
+	 * Return the cell address of the currently active cell object
+	 *
+	 * @return	string
+	 */
+	public function getCurrentAddress()
+	{
+		return $this->_currentObjectID;
+	}
+
+	/**
+	 * Return the column address of the currently active cell object
+	 *
+	 * @return	string
+	 */
+	public function getCurrentColumn()
+	{
+		sscanf($this->_currentObjectID, '%[A-Z]%d', $column, $row);
+		return $column;
+	}
+
+	/**
+	 * Return the row address of the currently active cell object
+	 *
+	 * @return	string
+	 */
+	public function getCurrentRow()
+	{
+		sscanf($this->_currentObjectID, '%[A-Z]%d', $column, $row);
+		return $row;
+	}
+
+	/**
+	 * Get highest worksheet column
+	 *
+     * @param   string     $row        Return the highest column for the specified row,
+     *                                     or the highest column of any row if no row number is passed
+	 * @return  string     Highest column name
+	 */
+	public function getHighestColumn($row = null)
+	{
+        if ($row == null) {
+    		$colRow = $this->getHighestRowAndColumn();
+	    	return $colRow['column'];
+        }
+
+        $columnList = array(1);
+        foreach ($this->getCellList() as $coord) {
+            sscanf($coord,'%[A-Z]%d', $c, $r);
+            if ($r != $row) {
+                continue;
+            }
+            $columnList[] = PHPExcel_Cell::columnIndexFromString($c);
+        }
+        return PHPExcel_Cell::stringFromColumnIndex(max($columnList) - 1);
+    }
+
+	/**
+	 * Get highest worksheet row
+	 *
+     * @param   string     $column     Return the highest row for the specified column,
+     *                                     or the highest row of any column if no column letter is passed
+	 * @return  int        Highest row number
+	 */
+	public function getHighestRow($column = null)
+	{
+        if ($column == null) {
+	    	$colRow = $this->getHighestRowAndColumn();
+    		return $colRow['row'];
+        }
+
+        $rowList = array(0);
+        foreach ($this->getCellList() as $coord) {
+            sscanf($coord,'%[A-Z]%d', $c, $r);
+            if ($c != $column) {
+                continue;
+            }
+            $rowList[] = $r;
+        }
+
+        return max($rowList);
+	}
+
+
+	/**
+	 * Generate a unique ID for cache referencing
+	 *
+	 * @return string Unique Reference
+	 */
+	protected function _getUniqueID() {
+		if (function_exists('posix_getpid')) {
+			$baseUnique = posix_getpid();
+		} else {
+			$baseUnique = mt_rand();
+		}
+		return uniqid($baseUnique,true);
+	}
+
+	/**
+	 * Clone the cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The new worksheet
+	 * @return	void
+	 */
+	public function copyCellCollection(PHPExcel_Worksheet $parent) {
+		$this->_currentCellIsDirty;
+        $this->_storeData();
+
+		$this->_parent = $parent;
+		if (($this->_currentObject !== NULL) && (is_object($this->_currentObject))) {
+			$this->_currentObject->attach($this);
+		}
+	}	//	function copyCellCollection()
+
+
+	/**
+	 * Identify whether the caching method is currently available
+	 * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
+	 *
+	 * @return	boolean
+	 */
+	public static function cacheMethodIsAvailable() {
+		return true;
+	}
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/DiscISAM.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_DiscISAM
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_CachedObjectStorage_DiscISAM extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
+
+	/**
+	 * Name of the file for this cache
+	 *
+	 * @var string
+	 */
+	private $_fileName = NULL;
+
+	/**
+	 * File handle for this cache file
+	 *
+	 * @var resource
+	 */
+	private $_fileHandle = NULL;
+
+	/**
+	 * Directory/Folder where the cache file is located
+	 *
+	 * @var string
+	 */
+	private $_cacheDirectory = NULL;
+
+
+    /**
+     * Store cell data in cache for the current cell object if it's "dirty",
+     *     and the 'nullify' the current cell object
+     *
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	protected function _storeData() {
+		if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
+			$this->_currentObject->detach();
+
+			fseek($this->_fileHandle,0,SEEK_END);
+			$offset = ftell($this->_fileHandle);
+			fwrite($this->_fileHandle, serialize($this->_currentObject));
+			$this->_cellCache[$this->_currentObjectID]	= array('ptr' => $offset,
+																'sz'  => ftell($this->_fileHandle) - $offset
+															   );
+			$this->_currentCellIsDirty = false;
+		}
+		$this->_currentObjectID = $this->_currentObject = null;
+	}	//	function _storeData()
+
+
+    /**
+     * Add or Update a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to update
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function addCacheData($pCoord, PHPExcel_Cell $cell) {
+		if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
+			$this->_storeData();
+		}
+
+		$this->_currentObjectID = $pCoord;
+		$this->_currentObject = $cell;
+		$this->_currentCellIsDirty = true;
+
+		return $cell;
+	}	//	function addCacheData()
+
+
+    /**
+     * Get cell at a specific coordinate
+     *
+     * @param 	string 			$pCoord		Coordinate of the cell
+     * @throws 	PHPExcel_Exception
+     * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
+     */
+	public function getCacheData($pCoord) {
+		if ($pCoord === $this->_currentObjectID) {
+			return $this->_currentObject;
+		}
+		$this->_storeData();
+
+		//	Check if the entry that has been requested actually exists
+		if (!isset($this->_cellCache[$pCoord])) {
+			//	Return null if requested entry doesn't exist in cache
+			return null;
+		}
+
+		//	Set current entry to the requested entry
+		$this->_currentObjectID = $pCoord;
+		fseek($this->_fileHandle,$this->_cellCache[$pCoord]['ptr']);
+		$this->_currentObject = unserialize(fread($this->_fileHandle,$this->_cellCache[$pCoord]['sz']));
+        //    Re-attach this as the cell's parent
+        $this->_currentObject->attach($this);
+
+		//	Return requested entry
+		return $this->_currentObject;
+	}	//	function getCacheData()
+
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return  array of string
+	 */
+	public function getCellList() {
+		if ($this->_currentObjectID !== null) {
+			$this->_storeData();
+		}
+
+		return parent::getCellList();
+	}
+
+
+	/**
+	 * Clone the cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The new worksheet
+	 * @return	void
+	 */
+	public function copyCellCollection(PHPExcel_Worksheet $parent) {
+		parent::copyCellCollection($parent);
+		//	Get a new id for the new file name
+		$baseUnique = $this->_getUniqueID();
+		$newFileName = $this->_cacheDirectory.'/PHPExcel.'.$baseUnique.'.cache';
+		//	Copy the existing cell cache file
+		copy ($this->_fileName,$newFileName);
+		$this->_fileName = $newFileName;
+		//	Open the copied cell cache file
+		$this->_fileHandle = fopen($this->_fileName,'a+');
+	}	//	function copyCellCollection()
+
+
+	/**
+	 * Clear the cell collection and disconnect from our parent
+	 *
+	 * @return	void
+	 */
+	public function unsetWorksheetCells() {
+		if(!is_null($this->_currentObject)) {
+			$this->_currentObject->detach();
+			$this->_currentObject = $this->_currentObjectID = null;
+		}
+		$this->_cellCache = array();
+
+		//	detach ourself from the worksheet, so that it can then delete this object successfully
+		$this->_parent = null;
+
+		//	Close down the temporary cache file
+		$this->__destruct();
+	}	//	function unsetWorksheetCells()
+
+
+	/**
+	 * Initialise this new cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The worksheet for this cell collection
+	 * @param	array of mixed		$arguments	Additional initialisation arguments
+	 */
+	public function __construct(PHPExcel_Worksheet $parent, $arguments) {
+		$this->_cacheDirectory	= ((isset($arguments['dir'])) && ($arguments['dir'] !== NULL))
+									? $arguments['dir']
+									: PHPExcel_Shared_File::sys_get_temp_dir();
+
+		parent::__construct($parent);
+		if (is_null($this->_fileHandle)) {
+			$baseUnique = $this->_getUniqueID();
+			$this->_fileName = $this->_cacheDirectory.'/PHPExcel.'.$baseUnique.'.cache';
+			$this->_fileHandle = fopen($this->_fileName,'a+');
+		}
+	}	//	function __construct()
+
+
+	/**
+	 * Destroy this cell collection
+	 */
+	public function __destruct() {
+		if (!is_null($this->_fileHandle)) {
+			fclose($this->_fileHandle);
+			unlink($this->_fileName);
+		}
+		$this->_fileHandle = null;
+	}	//	function __destruct()
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/ICache.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_ICache
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+interface PHPExcel_CachedObjectStorage_ICache
+{
+    /**
+     * Add or Update a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to update
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function addCacheData($pCoord, PHPExcel_Cell $cell);
+
+    /**
+     * Add or Update a cell in cache
+     *
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function updateCacheData(PHPExcel_Cell $cell);
+
+    /**
+     * Fetch a cell from cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to retrieve
+     * @return PHPExcel_Cell 	Cell that was found, or null if not found
+     * @throws	PHPExcel_Exception
+     */
+	public function getCacheData($pCoord);
+
+    /**
+     * Delete a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to delete
+     * @throws	PHPExcel_Exception
+     */
+	public function deleteCacheData($pCoord);
+
+	/**
+	 * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
+	 *
+	 * @param	string		$pCoord		Coordinate address of the cell to check
+	 * @return	boolean
+	 */
+	public function isDataSet($pCoord);
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return	array of string
+	 */
+	public function getCellList();
+
+	/**
+	 * Get the list of all cell addresses currently held in cache sorted by column and row
+	 *
+	 * @return	void
+	 */
+	public function getSortedCellList();
+
+	/**
+	 * Clone the cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The new worksheet
+	 * @return	void
+	 */
+	public function copyCellCollection(PHPExcel_Worksheet $parent);
+
+	/**
+	 * Identify whether the caching method is currently available
+	 * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
+	 *
+	 * @return	boolean
+	 */
+	public static function cacheMethodIsAvailable();
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/Igbinary.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_Igbinary
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_CachedObjectStorage_Igbinary extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
+
+    /**
+     * Store cell data in cache for the current cell object if it's "dirty",
+     *     and the 'nullify' the current cell object
+     *
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	protected function _storeData() {
+		if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
+			$this->_currentObject->detach();
+
+			$this->_cellCache[$this->_currentObjectID] = igbinary_serialize($this->_currentObject);
+			$this->_currentCellIsDirty = false;
+		}
+		$this->_currentObjectID = $this->_currentObject = null;
+	}	//	function _storeData()
+
+
+    /**
+     * Add or Update a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to update
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function addCacheData($pCoord, PHPExcel_Cell $cell) {
+		if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
+			$this->_storeData();
+		}
+
+		$this->_currentObjectID = $pCoord;
+		$this->_currentObject = $cell;
+		$this->_currentCellIsDirty = true;
+
+		return $cell;
+	}	//	function addCacheData()
+
+
+    /**
+     * Get cell at a specific coordinate
+     *
+     * @param 	string 			$pCoord		Coordinate of the cell
+     * @throws 	PHPExcel_Exception
+     * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
+     */
+	public function getCacheData($pCoord) {
+		if ($pCoord === $this->_currentObjectID) {
+			return $this->_currentObject;
+		}
+		$this->_storeData();
+
+		//	Check if the entry that has been requested actually exists
+		if (!isset($this->_cellCache[$pCoord])) {
+			//	Return null if requested entry doesn't exist in cache
+			return null;
+		}
+
+		//	Set current entry to the requested entry
+		$this->_currentObjectID = $pCoord;
+		$this->_currentObject = igbinary_unserialize($this->_cellCache[$pCoord]);
+        //    Re-attach this as the cell's parent
+        $this->_currentObject->attach($this);
+
+		//	Return requested entry
+		return $this->_currentObject;
+	}	//	function getCacheData()
+
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return  array of string
+	 */
+	public function getCellList() {
+		if ($this->_currentObjectID !== null) {
+			$this->_storeData();
+		}
+
+		return parent::getCellList();
+	}
+
+
+	/**
+	 * Clear the cell collection and disconnect from our parent
+	 *
+	 * @return	void
+	 */
+	public function unsetWorksheetCells() {
+		if(!is_null($this->_currentObject)) {
+			$this->_currentObject->detach();
+			$this->_currentObject = $this->_currentObjectID = null;
+		}
+		$this->_cellCache = array();
+
+		//	detach ourself from the worksheet, so that it can then delete this object successfully
+		$this->_parent = null;
+	}	//	function unsetWorksheetCells()
+
+
+	/**
+	 * Identify whether the caching method is currently available
+	 * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
+	 *
+	 * @return	boolean
+	 */
+	public static function cacheMethodIsAvailable() {
+		if (!function_exists('igbinary_serialize')) {
+			return false;
+		}
+
+		return true;
+	}
+
+}

lib/Classes/PHPExcel/CachedObjectStorage/Memcache.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_CachedObjectStorage_Memcache
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_CachedObjectStorage
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_CachedObjectStorage_Memcache extends PHPExcel_CachedObjectStorage_CacheBase implements PHPExcel_CachedObjectStorage_ICache {
+
+	/**
+	 * Prefix used to uniquely identify cache data for this worksheet
+	 *
+	 * @var string
+	 */
+	private $_cachePrefix = null;
+
+	/**
+	 * Cache timeout
+	 *
+	 * @var integer
+	 */
+	private $_cacheTime = 600;
+
+	/**
+	 * Memcache interface
+	 *
+	 * @var resource
+	 */
+	private $_memcache = null;
+
+
+    /**
+     * Store cell data in cache for the current cell object if it's "dirty",
+     *     and the 'nullify' the current cell object
+     *
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	protected function _storeData() {
+		if ($this->_currentCellIsDirty && !empty($this->_currentObjectID)) {
+			$this->_currentObject->detach();
+
+			$obj = serialize($this->_currentObject);
+			if (!$this->_memcache->replace($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
+				if (!$this->_memcache->add($this->_cachePrefix.$this->_currentObjectID.'.cache',$obj,NULL,$this->_cacheTime)) {
+					$this->__destruct();
+					throw new PHPExcel_Exception('Failed to store cell '.$this->_currentObjectID.' in MemCache');
+				}
+			}
+			$this->_currentCellIsDirty = false;
+		}
+		$this->_currentObjectID = $this->_currentObject = null;
+	}	//	function _storeData()
+
+
+    /**
+     * Add or Update a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to update
+     * @param	PHPExcel_Cell	$cell		Cell to update
+	 * @return	void
+     * @throws	PHPExcel_Exception
+     */
+	public function addCacheData($pCoord, PHPExcel_Cell $cell) {
+		if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
+			$this->_storeData();
+		}
+		$this->_cellCache[$pCoord] = true;
+
+		$this->_currentObjectID = $pCoord;
+		$this->_currentObject = $cell;
+		$this->_currentCellIsDirty = true;
+
+		return $cell;
+	}	//	function addCacheData()
+
+
+	/**
+	 * Is a value set in the current PHPExcel_CachedObjectStorage_ICache for an indexed cell?
+	 *
+	 * @param	string		$pCoord		Coordinate address of the cell to check
+	 * @return	void
+	 * @return	boolean
+	 */
+	public function isDataSet($pCoord) {
+		//	Check if the requested entry is the current object, or exists in the cache
+		if (parent::isDataSet($pCoord)) {
+			if ($this->_currentObjectID == $pCoord) {
+				return true;
+			}
+			//	Check if the requested entry still exists in Memcache
+			$success = $this->_memcache->get($this->_cachePrefix.$pCoord.'.cache');
+			if ($success === false) {
+				//	Entry no longer exists in Memcache, so clear it from the cache array
+				parent::deleteCacheData($pCoord);
+				throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in MemCache');
+			}
+			return true;
+		}
+		return false;
+	}	//	function isDataSet()
+
+
+	/**
+     * Get cell at a specific coordinate
+     *
+     * @param 	string 			$pCoord		Coordinate of the cell
+     * @throws 	PHPExcel_Exception
+     * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
+     */
+	public function getCacheData($pCoord) {
+		if ($pCoord === $this->_currentObjectID) {
+			return $this->_currentObject;
+		}
+		$this->_storeData();
+
+		//	Check if the entry that has been requested actually exists
+		if (parent::isDataSet($pCoord)) {
+			$obj = $this->_memcache->get($this->_cachePrefix.$pCoord.'.cache');
+			if ($obj === false) {
+				//	Entry no longer exists in Memcache, so clear it from the cache array
+				parent::deleteCacheData($pCoord);
+				throw new PHPExcel_Exception('Cell entry '.$pCoord.' no longer exists in MemCache');
+			}
+		} else {
+			//	Return null if requested entry doesn't exist in cache
+			return null;
+		}
+
+		//	Set current entry to the requested entry
+		$this->_currentObjectID = $pCoord;
+		$this->_currentObject = unserialize($obj);
+        //    Re-attach this as the cell's parent
+        $this->_currentObject->attach($this);
+
+		//	Return requested entry
+		return $this->_currentObject;
+	}	//	function getCacheData()
+
+
+	/**
+	 * Get a list of all cell addresses currently held in cache
+	 *
+	 * @return  array of string
+	 */
+	public function getCellList() {
+		if ($this->_currentObjectID !== null) {
+			$this->_storeData();
+		}
+
+		return parent::getCellList();
+	}
+
+
+    /**
+     * Delete a cell in cache identified by coordinate address
+     *
+     * @param	string			$pCoord		Coordinate address of the cell to delete
+     * @throws	PHPExcel_Exception
+     */
+	public function deleteCacheData($pCoord) {
+		//	Delete the entry from Memcache
+		$this->_memcache->delete($this->_cachePrefix.$pCoord.'.cache');
+
+		//	Delete the entry from our cell address array
+		parent::deleteCacheData($pCoord);
+	}	//	function deleteCacheData()
+
+
+	/**
+	 * Clone the cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The new worksheet
+	 * @return	void
+	 */
+	public function copyCellCollection(PHPExcel_Worksheet $parent) {
+		parent::copyCellCollection($parent);
+		//	Get a new id for the new file name
+		$baseUnique = $this->_getUniqueID();
+		$newCachePrefix = substr(md5($baseUnique),0,8).'.';
+		$cacheList = $this->getCellList();
+		foreach($cacheList as $cellID) {
+			if ($cellID != $this->_currentObjectID) {
+				$obj = $this->_memcache->get($this->_cachePrefix.$cellID.'.cache');
+				if ($obj === false) {
+					//	Entry no longer exists in Memcache, so clear it from the cache array
+					parent::deleteCacheData($cellID);
+					throw new PHPExcel_Exception('Cell entry '.$cellID.' no longer exists in MemCache');
+				}
+				if (!$this->_memcache->add($newCachePrefix.$cellID.'.cache',$obj,NULL,$this->_cacheTime)) {
+					$this->__destruct();
+					throw new PHPExcel_Exception('Failed to store cell '.$cellID.' in MemCache');
+				}
+			}
+		}
+		$this->_cachePrefix = $newCachePrefix;
+	}	//	function copyCellCollection()
+
+
+	/**
+	 * Clear the cell collection and disconnect from our parent
+	 *
+	 * @return	void
+	 */
+	public function unsetWorksheetCells() {
+		if(!is_null($this->_currentObject)) {
+			$this->_currentObject->detach();
+			$this->_currentObject = $this->_currentObjectID = null;
+		}
+
+		//	Flush the Memcache cache
+		$this->__destruct();
+
+		$this->_cellCache = array();
+
+		//	detach ourself from the worksheet, so that it can then delete this object successfully
+		$this->_parent = null;
+	}	//	function unsetWorksheetCells()
+
+
+	/**
+	 * Initialise this new cell collection
+	 *
+	 * @param	PHPExcel_Worksheet	$parent		The worksheet for this cell collection
+	 * @param	array of mixed		$arguments	Additional initialisation arguments
+	 */
+	public function __construct(PHPExcel_Worksheet $parent, $arguments) {
+		$memcacheServer	= (isset($arguments['memcacheServer']))	? $arguments['memcacheServer']	: 'localhost';
+		$memcachePort	= (isset($arguments['memcachePort']))	? $arguments['memcachePort']	: 11211;
+		$cacheTime		= (isset($arguments['cacheTime']))		? $arguments['cacheTime']		: 600;
+
+		if (is_null($this->_cachePrefix)) {
+			$baseUnique = $this->_getUniqueID();
+			$this->_cachePrefix = substr(md5($baseUnique),0,8).'.';
+
+			//	Set a new Memcache object and connect to the Memcache server
+			$this->_memcache = new Memcache();
+			if (!$this->_memcache->addServer($memcacheServer, $memcachePort, false, 50, 5, 5, true, array($this, 'failureCallback'))) {
+				throw new PHPExcel_Exception('Could not connect to MemCache server at '.$memcacheServer.':'.$memcachePort);
+			}
+			$this->_cacheTime = $cacheTime;
+
+			parent::__construct($parent);
+		}
+	}	//	function __construct()
+
+
+	/**
+	 * Memcache error handler
+	 *
+	 * @param	string	$host		Memcache server
+	 * @param	integer	$port		Memcache port
+     * @throws	PHPExcel_Exception
+	 */
+	public function failureCallback($host, $port) {
+		throw new PHPExcel_Exception('memcache '.$host.':'.$port.' failed');
+	}
+
+
+	/**
+	 * Destroy this cell collection
+	 */
+	public function __destruct() {
+		$cacheList = $this->getCellList();
+		foreach($cacheList as $cellID) {
+			$this->_memcache->delete($this->_cachePrefix.$cellID.'.cache');
+		}
+	}	//	function __destruct()
+
+	/**
+	 * Identify whether the caching method is currently available
+	 * Some methods are dependent on the availability of certain extensions being enabled in the PHP build
+	 *
+	 * @return	boolean
+	 */
+	public static function cacheMethodIsAvailable() {
+		if (!function_exists('memcache_add')) {
+			return false;
+		}
+
+		return true;
+	}
+
+}