261 lines
8.5 KiB
PHP
261 lines
8.5 KiB
PHP
<?php
|
|
|
|
namespace Box\Spout\Reader\CSV;
|
|
|
|
use Box\Spout\Reader\IteratorInterface;
|
|
use Box\Spout\Common\Helper\EncodingHelper;
|
|
|
|
/**
|
|
* Class RowIterator
|
|
* Iterate over CSV rows.
|
|
*
|
|
* @package Box\Spout\Reader\CSV
|
|
*/
|
|
class RowIterator implements IteratorInterface
|
|
{
|
|
/**
|
|
* Value passed to fgetcsv. 0 means "unlimited" (slightly slower but accomodates for very long lines).
|
|
*/
|
|
const MAX_READ_BYTES_PER_LINE = 0;
|
|
|
|
/** @var resource Pointer to the CSV file to read */
|
|
protected $filePointer;
|
|
|
|
/** @var int Number of read rows */
|
|
protected $numReadRows = 0;
|
|
|
|
/** @var array|null Buffer used to store the row data, while checking if there are more rows to read */
|
|
protected $rowDataBuffer = null;
|
|
|
|
/** @var bool Indicates whether all rows have been read */
|
|
protected $hasReachedEndOfFile = false;
|
|
|
|
/** @var string Defines the character used to delimit fields (one character only) */
|
|
protected $fieldDelimiter;
|
|
|
|
/** @var string Defines the character used to enclose fields (one character only) */
|
|
protected $fieldEnclosure;
|
|
|
|
/** @var string Encoding of the CSV file to be read */
|
|
protected $encoding;
|
|
|
|
/** @var string End of line delimiter, given by the user as input. */
|
|
protected $inputEOLDelimiter;
|
|
|
|
/** @var bool Whether empty rows should be returned or skipped */
|
|
protected $shouldPreserveEmptyRows;
|
|
|
|
/** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
|
|
protected $globalFunctionsHelper;
|
|
|
|
/** @var \Box\Spout\Common\Helper\EncodingHelper Helper to work with different encodings */
|
|
protected $encodingHelper;
|
|
|
|
/** @var string End of line delimiter, encoded using the same encoding as the CSV */
|
|
protected $encodedEOLDelimiter;
|
|
|
|
/**
|
|
* @param resource $filePointer Pointer to the CSV file to read
|
|
* @param \Box\Spout\Reader\CSV\ReaderOptions $options
|
|
* @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
|
|
*/
|
|
public function __construct($filePointer, $options, $globalFunctionsHelper)
|
|
{
|
|
$this->filePointer = $filePointer;
|
|
$this->fieldDelimiter = $options->getFieldDelimiter();
|
|
$this->fieldEnclosure = $options->getFieldEnclosure();
|
|
$this->encoding = $options->getEncoding();
|
|
$this->inputEOLDelimiter = $options->getEndOfLineCharacter();
|
|
$this->shouldPreserveEmptyRows = $options->shouldPreserveEmptyRows();
|
|
$this->globalFunctionsHelper = $globalFunctionsHelper;
|
|
|
|
$this->encodingHelper = new EncodingHelper($globalFunctionsHelper);
|
|
}
|
|
|
|
/**
|
|
* Rewind the Iterator to the first element
|
|
* @link http://php.net/manual/en/iterator.rewind.php
|
|
*
|
|
* @return void
|
|
*/
|
|
public function rewind()
|
|
{
|
|
$this->rewindAndSkipBom();
|
|
|
|
$this->numReadRows = 0;
|
|
$this->rowDataBuffer = null;
|
|
|
|
$this->next();
|
|
}
|
|
|
|
/**
|
|
* This rewinds and skips the BOM if inserted at the beginning of the file
|
|
* by moving the file pointer after it, so that it is not read.
|
|
*
|
|
* @return void
|
|
*/
|
|
protected function rewindAndSkipBom()
|
|
{
|
|
$byteOffsetToSkipBom = $this->encodingHelper->getBytesOffsetToSkipBOM($this->filePointer, $this->encoding);
|
|
|
|
// sets the cursor after the BOM (0 means no BOM, so rewind it)
|
|
$this->globalFunctionsHelper->fseek($this->filePointer, $byteOffsetToSkipBom);
|
|
}
|
|
|
|
/**
|
|
* Checks if current position is valid
|
|
* @link http://php.net/manual/en/iterator.valid.php
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function valid()
|
|
{
|
|
return ($this->filePointer && !$this->hasReachedEndOfFile);
|
|
}
|
|
|
|
/**
|
|
* Move forward to next element. Reads data for the next unprocessed row.
|
|
* @link http://php.net/manual/en/iterator.next.php
|
|
*
|
|
* @return void
|
|
* @throws \Box\Spout\Common\Exception\EncodingConversionException If unable to convert data to UTF-8
|
|
*/
|
|
public function next()
|
|
{
|
|
$this->hasReachedEndOfFile = $this->globalFunctionsHelper->feof($this->filePointer);
|
|
|
|
if (!$this->hasReachedEndOfFile) {
|
|
$this->readDataForNextRow();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return void
|
|
* @throws \Box\Spout\Common\Exception\EncodingConversionException If unable to convert data to UTF-8
|
|
*/
|
|
protected function readDataForNextRow()
|
|
{
|
|
do {
|
|
$rowData = $this->getNextUTF8EncodedRow();
|
|
} while ($this->shouldReadNextRow($rowData));
|
|
|
|
if ($rowData !== false) {
|
|
// str_replace will replace NULL values by empty strings
|
|
$this->rowDataBuffer = str_replace(null, null, $rowData);
|
|
$this->numReadRows++;
|
|
} else {
|
|
// If we reach this point, it means end of file was reached.
|
|
// This happens when the last lines are empty lines.
|
|
$this->hasReachedEndOfFile = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param array|bool $currentRowData
|
|
* @return bool Whether the data for the current row can be returned or if we need to keep reading
|
|
*/
|
|
protected function shouldReadNextRow($currentRowData)
|
|
{
|
|
$hasSuccessfullyFetchedRowData = ($currentRowData !== false);
|
|
$hasNowReachedEndOfFile = $this->globalFunctionsHelper->feof($this->filePointer);
|
|
$isEmptyLine = $this->isEmptyLine($currentRowData);
|
|
|
|
return (
|
|
(!$hasSuccessfullyFetchedRowData && !$hasNowReachedEndOfFile) ||
|
|
(!$this->shouldPreserveEmptyRows && $isEmptyLine)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns the next row, converted if necessary to UTF-8.
|
|
* As fgetcsv() does not manage correctly encoding for non UTF-8 data,
|
|
* we remove manually whitespace with ltrim or rtrim (depending on the order of the bytes)
|
|
*
|
|
* @return array|false The row for the current file pointer, encoded in UTF-8 or FALSE if nothing to read
|
|
* @throws \Box\Spout\Common\Exception\EncodingConversionException If unable to convert data to UTF-8
|
|
*/
|
|
protected function getNextUTF8EncodedRow()
|
|
{
|
|
$encodedRowData = $this->globalFunctionsHelper->fgetcsv($this->filePointer, self::MAX_READ_BYTES_PER_LINE, $this->fieldDelimiter, $this->fieldEnclosure);
|
|
if ($encodedRowData === false) {
|
|
return false;
|
|
}
|
|
|
|
foreach ($encodedRowData as $cellIndex => $cellValue) {
|
|
switch($this->encoding) {
|
|
case EncodingHelper::ENCODING_UTF16_LE:
|
|
case EncodingHelper::ENCODING_UTF32_LE:
|
|
// remove whitespace from the beginning of a string as fgetcsv() add extra whitespace when it try to explode non UTF-8 data
|
|
$cellValue = ltrim($cellValue);
|
|
break;
|
|
|
|
case EncodingHelper::ENCODING_UTF16_BE:
|
|
case EncodingHelper::ENCODING_UTF32_BE:
|
|
// remove whitespace from the end of a string as fgetcsv() add extra whitespace when it try to explode non UTF-8 data
|
|
$cellValue = rtrim($cellValue);
|
|
break;
|
|
}
|
|
|
|
$encodedRowData[$cellIndex] = $this->encodingHelper->attemptConversionToUTF8($cellValue, $this->encoding);
|
|
}
|
|
|
|
return $encodedRowData;
|
|
}
|
|
|
|
/**
|
|
* Returns the end of line delimiter, encoded using the same encoding as the CSV.
|
|
* The return value is cached.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function getEncodedEOLDelimiter()
|
|
{
|
|
if (!isset($this->encodedEOLDelimiter)) {
|
|
$this->encodedEOLDelimiter = $this->encodingHelper->attemptConversionFromUTF8($this->inputEOLDelimiter, $this->encoding);
|
|
}
|
|
|
|
return $this->encodedEOLDelimiter;
|
|
}
|
|
|
|
/**
|
|
* @param array|bool $lineData Array containing the cells value for the line
|
|
* @return bool Whether the given line is empty
|
|
*/
|
|
protected function isEmptyLine($lineData)
|
|
{
|
|
return (is_array($lineData) && count($lineData) === 1 && $lineData[0] === null);
|
|
}
|
|
|
|
/**
|
|
* Return the current element from the buffer
|
|
* @link http://php.net/manual/en/iterator.current.php
|
|
*
|
|
* @return array|null
|
|
*/
|
|
public function current()
|
|
{
|
|
return $this->rowDataBuffer;
|
|
}
|
|
|
|
/**
|
|
* Return the key of the current element
|
|
* @link http://php.net/manual/en/iterator.key.php
|
|
*
|
|
* @return int
|
|
*/
|
|
public function key()
|
|
{
|
|
return $this->numReadRows;
|
|
}
|
|
|
|
/**
|
|
* Cleans up what was created to iterate over the object.
|
|
*
|
|
* @return void
|
|
*/
|
|
public function end()
|
|
{
|
|
// do nothing
|
|
}
|
|
}
|