<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file LICENSE.txt.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Search_Lucene

 * @subpackage Storage

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 * @version    $Id: Memory.php 20096 2010-01-06 02:05:09Z bkarwin $

 */

/** Zend_Search_Lucene_Storage_File */

require_once 'Zend/Search/Lucene/Storage/File.php';

/**

 * @category   Zend

 * @package    Zend_Search_Lucene

 * @subpackage Storage

 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Search_Lucene_Storage_File_Memory extends Zend_Search_Lucene_Storage_File

{

    /**

     * FileData

     *

     * @var string

     */

    private $_data;

    /**

     * File Position

     *

     * @var integer

     */

    private $_position = 0;

    /**

     * Object constractor

     *

     * @param string $data

     */

    public function __construct($data)

    {

        $this->_data = $data;

    }

    /**

     * Reads $length number of bytes at the current position in the

     * file and advances the file pointer.

     *

     * @param integer $length

     * @return string

     */

    protected function _fread($length = 1)

    {

        $returnValue = substr($this->_data, $this->_position, $length);

        $this->_position += $length;

        return $returnValue;

    }

    /**

     * Sets the file position indicator and advances the file pointer.

     * The new position, measured in bytes from the beginning of the file,

     * is obtained by adding offset to the position specified by whence,

     * whose values are defined as follows:

     * SEEK_SET - Set position equal to offset bytes.

     * SEEK_CUR - Set position to current location plus offset.

     * SEEK_END - Set position to end-of-file plus offset. (To move to

     * a position before the end-of-file, you need to pass a negative value

     * in offset.)

     * Upon success, returns 0; otherwise, returns -1

     *

     * @param integer $offset

     * @param integer $whence

     * @return integer

     */

    public function seek($offset, $whence=SEEK_SET)

    {

        switch ($whence) {

            case SEEK_SET:

                $this->_position = $offset;

                break;

            case SEEK_CUR:

                $this->_position += $offset;

                break;

            case SEEK_END:

                $this->_position = strlen($this->_data);

                $this->_position += $offset;

                break;

            default:

                break;

        }

    }

    /**

     * Get file position.

     *

     * @return integer

     */

    public function tell()

    {

        return $this->_position;

    }

    /**

     * Flush output.

     *

     * Returns true on success or false on failure.

     *

     * @return boolean

     */

    public function flush()

    {

        // Do nothing

        return true;

    }

    /**

     * Writes $length number of bytes (all, if $length===null) to the end

     * of the file.

     *

     * @param string $data

     * @param integer $length

     */

    protected function _fwrite($data, $length=null)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        if ($length !== null) {

            $this->_data .= substr($data, 0, $length);

        } else {

            $this->_data .= $data;

        }

        $this->_position = strlen($this->_data);

    }

    /**

     * Lock file

     *

     * Lock type may be a LOCK_SH (shared lock) or a LOCK_EX (exclusive lock)

     *

     * @param integer $lockType

     * @return boolean

     */

    public function lock($lockType, $nonBlockinLock = false)

    {

        // Memory files can't be shared

        // do nothing

        return true;

    }

    /**

     * Unlock file

     */

    public function unlock()

    {

        // Memory files can't be shared

        // do nothing

    }

    /**

     * Reads a byte from the current position in the file

     * and advances the file pointer.

     *

     * @return integer

     */

    public function readByte()

    {

        return ord($this->_data[$this->_position++]);

    }

    /**

     * Writes a byte to the end of the file.

     *

     * @param integer $byte

     */

    public function writeByte($byte)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        $this->_data .= chr($byte);

        $this->_position = strlen($this->_data);

        return 1;

    }

    /**

     * Read num bytes from the current position in the file

     * and advances the file pointer.

     *

     * @param integer $num

     * @return string

     */

    public function readBytes($num)

    {

        $returnValue = substr($this->_data, $this->_position, $num);

        $this->_position += $num;

        return $returnValue;

    }

    /**

     * Writes num bytes of data (all, if $num===null) to the end

     * of the string.

     *

     * @param string $data

     * @param integer $num

     */

    public function writeBytes($data, $num=null)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        if ($num !== null) {

            $this->_data .= substr($data, 0, $num);

        } else {

            $this->_data .= $data;

        }

        $this->_position = strlen($this->_data);

    }

    /**

     * Reads an integer from the current position in the file

     * and advances the file pointer.

     *

     * @return integer

     */

    public function readInt()

    {

        $str = substr($this->_data, $this->_position, 4);

        $this->_position += 4;

        return  ord($str[0]) << 24 |

                ord($str[1]) << 16 |

                ord($str[2]) << 8  |

                ord($str[3]);

    }

    /**

     * Writes an integer to the end of file.

     *

     * @param integer $value

     */

    public function writeInt($value)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        settype($value, 'integer');

        $this->_data .= chr($value>>24 & 0xFF) .

                        chr($value>>16 & 0xFF) .

                        chr($value>>8  & 0xFF) .

                        chr($value     & 0xFF);

        $this->_position = strlen($this->_data);

    }

    /**

     * Returns a long integer from the current position in the file

     * and advances the file pointer.

     *

     * @return integer

     * @throws Zend_Search_Lucene_Exception

     */

    public function readLong()

    {

        /**

         * Check, that we work in 64-bit mode.

         * fseek() uses long for offset. Thus, largest index segment file size in 32bit mode is 2Gb

         */

        if (PHP_INT_SIZE > 4) {

            $str = substr($this->_data, $this->_position, 8);

            $this->_position += 8;

            return  ord($str[0]) << 56  |

                    ord($str[1]) << 48  |

                    ord($str[2]) << 40  |

                    ord($str[3]) << 32  |

                    ord($str[4]) << 24  |

                    ord($str[5]) << 16  |

                    ord($str[6]) << 8   |

                    ord($str[7]);

        } else {

            return $this->readLong32Bit();

        }

    }

    /**

     * Writes long integer to the end of file

     *

     * @param integer $value

     * @throws Zend_Search_Lucene_Exception

     */

    public function writeLong($value)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        /**

         * Check, that we work in 64-bit mode.

         * fseek() and ftell() use long for offset. Thus, largest index segment file size in 32bit mode is 2Gb

         */

        if (PHP_INT_SIZE > 4) {

            settype($value, 'integer');

            $this->_data .= chr($value>>56 & 0xFF) .

                            chr($value>>48 & 0xFF) .

                            chr($value>>40 & 0xFF) .

                            chr($value>>32 & 0xFF) .

                            chr($value>>24 & 0xFF) .

                            chr($value>>16 & 0xFF) .

                            chr($value>>8  & 0xFF) .

                            chr($value     & 0xFF);

        } else {

            $this->writeLong32Bit($value);

        }

        $this->_position = strlen($this->_data);

    }

    /**

     * Returns a long integer from the current position in the file,

     * advances the file pointer and return it as float (for 32-bit platforms).

     *

     * @return integer|float

     * @throws Zend_Search_Lucene_Exception

     */

    public function readLong32Bit()

    {

        $wordHigh = $this->readInt();

        $wordLow  = $this->readInt();

        if ($wordHigh & (int)0x80000000) {

            // It's a negative value since the highest bit is set

            if ($wordHigh == (int)0xFFFFFFFF  &&  ($wordLow & (int)0x80000000)) {

                return $wordLow;

            } else {

                require_once 'Zend/Search/Lucene/Exception.php';

                throw new Zend_Search_Lucene_Exception('Long integers lower than -2147483648 (0x80000000) are not supported on 32-bit platforms.');

            }

        }

        if ($wordLow < 0) {

            // Value is large than 0x7FFF FFFF. Represent low word as float.

            $wordLow &= 0x7FFFFFFF;

            $wordLow += (float)0x80000000;

        }

        if ($wordHigh == 0) {

            // Return value as integer if possible

            return $wordLow;

        }

        return $wordHigh*(float)0x100000000/* 0x00000001 00000000 */ + $wordLow;

    }

    /**

     * Writes long integer to the end of file (32-bit platforms implementation)

     *

     * @param integer|float $value

     * @throws Zend_Search_Lucene_Exception

     */

    public function writeLong32Bit($value)

    {

        if ($value < (int)0x80000000) {

            require_once 'Zend/Search/Lucene/Exception.php';

            throw new Zend_Search_Lucene_Exception('Long integers lower than -2147483648 (0x80000000) are not supported on 32-bit platforms.');

        }

        if ($value < 0) {

            $wordHigh = (int)0xFFFFFFFF;

            $wordLow  = (int)$value;

        } else {

            $wordHigh = (int)($value/(float)0x100000000/* 0x00000001 00000000 */);

            $wordLow  = $value - $wordHigh*(float)0x100000000/* 0x00000001 00000000 */;

            if ($wordLow > 0x7FFFFFFF) {

                // Highest bit of low word is set. Translate it to the corresponding negative integer value

                $wordLow -= 0x80000000;

                $wordLow |= 0x80000000;

            }

        }

        $this->writeInt($wordHigh);

        $this->writeInt($wordLow);

    }

    /**

     * Returns a variable-length integer from the current

     * position in the file and advances the file pointer.

     *

     * @return integer

     */

    public function readVInt()

    {

        $nextByte = ord($this->_data[$this->_position++]);

        $val = $nextByte & 0x7F;

        for ($shift=7; ($nextByte & 0x80) != 0; $shift += 7) {

            $nextByte = ord($this->_data[$this->_position++]);

            $val |= ($nextByte & 0x7F) << $shift;

        }

        return $val;

    }

    /**

     * Writes a variable-length integer to the end of file.

     *

     * @param integer $value

     */

    public function writeVInt($value)

    {

        // We do not need to check if file position points to the end of "file".

        // Only append operation is supported now

        settype($value, 'integer');

        while ($value > 0x7F) {

            $this->_data .= chr( ($value & 0x7F)|0x80 );

            $value >>= 7;

        }