repo_phpExcelReader/PHPExcelReader/SpreadsheetReader/SpreadsheetReader_ODS.php

<?php

class SpreadsheetReader_ODS implements Iterator, Countable {
	private $Options = array(
		'TempDir' => '',
		'ReturnDateTimeObjects' => false
	);

	/**
	 * @var string Path to temporary content file
	 */
	private $ContentPath = '';
	/**
	 * @var XMLReader XML reader object
	 */
	private $Content = false;

	/**
	 * @var array Data about separate sheets in the file
	 */
	private $Sheets = false;

	private $CurrentRow = null;

	/**
	 * @var int Number of the sheet we're currently reading
	 */
	private $CurrentSheet = 0;

	private $Index = 0;

	private $TableOpen = false;
	private $RowOpen = false;

	/**
	 * @param string Path to file
	 * @param array Options:
	 *	TempDir => string Temporary directory path
	 *	ReturnDateTimeObjects => bool True => dates and times will be returned as PHP DateTime objects, false => as strings
	 */
	public function __construct($Filepath, array $Options = null)
	{
		if (!is_readable($Filepath))
		{
			throw new Exception('SpreadsheetReader_ODS: File not readable ('.$Filepath.')');
		}

		$this -> TempDir = isset($Options['TempDir']) && is_writable($Options['TempDir']) ?
			$Options['TempDir'] :
			sys_get_temp_dir();

		$this -> TempDir = rtrim($this -> TempDir, DIRECTORY_SEPARATOR);
		$this -> TempDir = $this -> TempDir.DIRECTORY_SEPARATOR.uniqid().DIRECTORY_SEPARATOR;

		$Zip = new ZipArchive;
		$Status = $Zip -> open($Filepath);

		if ($Status !== true)
		{
			throw new Exception('SpreadsheetReader_ODS: File not readable ('.$Filepath.') (Error '.$Status.')');
		}

		if ($Zip -> locateName('content.xml') !== false)
		{
			$Zip -> extractTo($this -> TempDir, 'content.xml');
			$this -> ContentPath = $this -> TempDir.'content.xml';
		}

		$Zip -> close();

		if ($this -> ContentPath && is_readable($this -> ContentPath))
		{
			$this -> Content = new XMLReader;
			$this -> Content -> open($this -> ContentPath);
			$this -> Valid = true;
		}
	}

	/**
	 * Destructor, destroys all that remains (closes and deletes temp files)
	 */
	public function __destruct()
	{
		if ($this -> Content && $this -> Content instanceof XMLReader)
		{
			$this -> Content -> close();
			unset($this -> Content);
		}
		if (file_exists($this -> ContentPath))
		{
			@unlink($this -> ContentPath);
			unset($this -> ContentPath);
		}
	}

	/**
	 * Retrieves an array with information about sheets in the current file
	 *
	 * @return array List of sheets (key is sheet index, value is name)
	 */
	public function Sheets()
	{
		if ($this -> Sheets === false)
		{
			$this -> Sheets = array();

			if ($this -> Valid)
			{
				$this -> SheetReader = new XMLReader;
				$this -> SheetReader -> open($this -> ContentPath);

				while ($this -> SheetReader -> read())
				{
					if ($this -> SheetReader -> name == 'table:table')
					{
						$this -> Sheets[] = $this -> SheetReader -> getAttribute('table:name');
						$this -> SheetReader -> next();
					}
				}
				
				$this -> SheetReader -> close();
			}
		}
		return $this -> Sheets;
	}

	/**
	 * Changes the current sheet in the file to another
	 *
	 * @param int Sheet index
	 *
	 * @return bool True if sheet was successfully changed, false otherwise.
	 */
	public function ChangeSheet($Index)
	{
		$Index = (int)$Index;

		$Sheets = $this -> Sheets();
		if (isset($Sheets[$Index]))
		{
			$this -> CurrentSheet = $Index;
			$this -> rewind();

			return true;
		}

		return false;
	}

	// !Iterator interface methods
	/** 
	 * Rewind the Iterator to the first element.
	 * Similar to the reset() function for arrays in PHP
	 */ 
	public function rewind()
	{
		if ($this -> Index > 0)
		{
			// If the worksheet was already iterated, XML file is reopened.
			// Otherwise it should be at the beginning anyway
			$this -> Content -> close();
			$this -> Content -> open($this -> ContentPath);
			$this -> Valid = true;

			$this -> TableOpen = false;
			$this -> RowOpen = false;

			$this -> CurrentRow = null;
		}

		$this -> Index = 0;
	}

	/**
	 * Return the current element.
	 * Similar to the current() function for arrays in PHP
	 *
	 * @return mixed current element from the collection
	 */
	public function current()
	{
		if ($this -> Index == 0 && is_null($this -> CurrentRow))
		{
			$this -> next();
			$this -> Index--;
		}
		return $this -> CurrentRow;
	}

	/** 
	 * Move forward to next element. 
	 * Similar to the next() function for arrays in PHP 
	 */ 
	public function next()
	{
		$this -> Index++;

		$this -> CurrentRow = array();

		if (!$this -> TableOpen)
		{
			$TableCounter = 0;
			$SkipRead = false;

			while ($this -> Valid = ($SkipRead || $this -> Content -> read()))
			{
				if ($SkipRead)
				{
					$SkipRead = false;
				}

				if ($this -> Content -> name == 'table:table' && $this -> Content -> nodeType != XMLReader::END_ELEMENT)
				{
					if ($TableCounter == $this -> CurrentSheet)
					{
						$this -> TableOpen = true;
						break;
					}

					$TableCounter++;
					$this -> Content -> next();
					$SkipRead = true;
				}
			}
		}

		if ($this -> TableOpen && !$this -> RowOpen)
		{
			while ($this -> Valid = $this -> Content -> read())
			{
				switch ($this -> Content -> name)
				{
					case 'table:table':
						$this -> TableOpen = false;
						$this -> Content -> next('office:document-content');
						$this -> Valid = false;
						break 2;
					case 'table:table-row':
						if ($this -> Content -> nodeType != XMLReader::END_ELEMENT)
						{
							$this -> RowOpen = true;
							break 2;
						}
						break;
				}
			}
		}

		if ($this -> RowOpen)
		{
			$LastCellContent = '';

			while ($this -> Valid = $this -> Content -> read())
			{
				switch ($this -> Content -> name)
				{
					case 'table:table-cell':
						if ($this -> Content -> nodeType == XMLReader::END_ELEMENT || $this -> Content -> isEmptyElement)
						{
							if ($this -> Content -> nodeType == XMLReader::END_ELEMENT)
							{
								$CellValue = $LastCellContent;
							}
							elseif ($this -> Content -> isEmptyElement)
							{
								$LastCellContent = '';
								$CellValue = $LastCellContent;
							}

							$this -> CurrentRow[] = $LastCellContent;

							if ($this -> Content -> getAttribute('table:number-columns-repeated') !== null)
							{                                                                                            
								$RepeatedColumnCount = $this -> Content -> getAttribute('table:number-columns-repeated');
								// Checking if larger than one because the value is already added to the row once before
								if ($RepeatedColumnCount > 1)
								{
									$this -> CurrentRow = array_pad($this -> CurrentRow, count($this -> CurrentRow) + $RepeatedColumnCount - 1, $LastCellContent);
								}
							}
						}
						else
						{
							$LastCellContent = '';
						}
					case 'text:p':
						if ($this -> Content -> nodeType != XMLReader::END_ELEMENT)
						{
							$LastCellContent = $this -> Content -> readString();
						}
						break;
					case 'table:table-row':
						$this -> RowOpen = false;
						break 2;
				}
			}
		}

		return $this -> CurrentRow;
	}

	/** 
	 * Return the identifying key of the current element.
	 * Similar to the key() function for arrays in PHP
	 *
	 * @return mixed either an integer or a string
	 */ 
	public function key()
	{
		return $this -> Index;
	}

	/** 
	 * Check if there is a current element after calls to rewind() or next().
	 * Used to check if we've iterated to the end of the collection
	 *
	 * @return boolean FALSE if there's nothing more to iterate over
	 */ 
	public function valid()
	{
		return $this -> Valid;
	}

	// !Countable interface method
	/**
	 * Ostensibly should return the count of the contained items but this just returns the number
	 * of rows read so far. It's not really correct but at least coherent.
	 */
	public function count()
	{
		return $this -> Index + 1;
	}
}