Add Zend_Io package proposal
git-svn-id: http://php-reader.googlecode.com/svn/branches/zend@151 51a70ab9-7547-0410-9469-37e369ee0574
This commit is contained in:
svollbehr
675
src/Zend/Io/Reader.php
Normal file
675
src/Zend/Io/Reader.php
Normal file
@@ -0,0 +1,675 @@
|
||||
<?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_Io
|
||||
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
* @version $Id$
|
||||
*/
|
||||
|
||||
/**
|
||||
* The Zend_Io_Reader class represents a character stream providing means to
|
||||
* read primitive types (string, integers, ...) from it.
|
||||
*
|
||||
* @category Zend
|
||||
* @package Zend_Io
|
||||
* @author Sven Vollbehr <sven@vollbehr.eu>
|
||||
* @author Ryan Butterfield <buttza@gmail.com>
|
||||
* @copyright Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com)
|
||||
* @license http://framework.zend.com/license/new-bsd New BSD License
|
||||
* @version $Id$
|
||||
*/
|
||||
class Zend_Io_Reader
|
||||
{
|
||||
const MACHINE_ENDIAN_ORDER = 0;
|
||||
const LITTLE_ENDIAN_ORDER = 1;
|
||||
const BIG_ENDIAN_ORDER = 2;
|
||||
|
||||
/**
|
||||
* The endianess of the current machine.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
private static $_endianess = 0;
|
||||
|
||||
/**
|
||||
* The resource identifier of the stream.
|
||||
*
|
||||
* @var resource
|
||||
*/
|
||||
protected $_fd = null;
|
||||
|
||||
/**
|
||||
* Size of the underlying stream.
|
||||
*
|
||||
* @var integer
|
||||
*/
|
||||
protected $_size = 0;
|
||||
|
||||
/**
|
||||
* Constructs the Zend_Io_Reader class with given open file descriptor.
|
||||
*
|
||||
* @param resource $fd The file descriptor.
|
||||
* @throws Zend_Io_Exception if given file descriptor is not valid
|
||||
*/
|
||||
public function __construct($fd)
|
||||
{
|
||||
if (!is_resource($fd) ||
|
||||
!in_array(get_resource_type($fd), array('stream'))) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Invalid resource type (only resources of type stream are supported)');
|
||||
}
|
||||
|
||||
$this->_fd = $fd;
|
||||
|
||||
$offset = $this->getOffset();
|
||||
fseek($this->_fd, 0, SEEK_END);
|
||||
$this->_size = ftell($this->_fd);
|
||||
fseek($this->_fd, $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Default destructor.
|
||||
*/
|
||||
public function __destruct() {}
|
||||
|
||||
/**
|
||||
* Checks whether there is more to be read from the stream. Returns
|
||||
* <var>true</var> if the end has not yet been reached; <var>false</var>
|
||||
* otherwise.
|
||||
*
|
||||
* @return boolean
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public function available()
|
||||
{
|
||||
return $this->getOffset() < $this->getSize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current point of operation.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public function getOffset()
|
||||
{
|
||||
if ($this->_fd === null) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Cannot operate on a closed stream');
|
||||
}
|
||||
return ftell($this->_fd);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the point of operation, ie the cursor offset value. The offset may
|
||||
* also be set to a negative value when it is interpreted as an offset from
|
||||
* the end of the stream instead of the beginning.
|
||||
*
|
||||
* @param integer $offset The new point of operation.
|
||||
* @return void
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public function setOffset($offset)
|
||||
{
|
||||
if ($this->_fd === null) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Cannot operate on a closed stream');
|
||||
}
|
||||
fseek($this->_fd, $offset < 0 ? $this->getSize() + $offset : $offset);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the stream size in bytes.
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
public function getSize()
|
||||
{
|
||||
return $this->_size;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the underlying stream file descriptor.
|
||||
*
|
||||
* @return resource
|
||||
*/
|
||||
public function getFileDescriptor()
|
||||
{
|
||||
return $this->_fd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Jumps <var>size</var> amount of bytes in the stream.
|
||||
*
|
||||
* @param integer $size The amount of bytes.
|
||||
* @return void
|
||||
* @throws Zend_Io_Exception if <var>size</var> attribute is negative or if
|
||||
* an I/O error occurs
|
||||
*/
|
||||
public function skip($size)
|
||||
{
|
||||
if ($size < 0) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Size cannot be negative');
|
||||
}
|
||||
if ($size == 0) {
|
||||
return;
|
||||
}
|
||||
if ($this->_fd === null) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Cannot operate on a closed stream');
|
||||
}
|
||||
fseek($this->_fd, $size, SEEK_CUR);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads <var>length</var> amount of bytes from the stream.
|
||||
*
|
||||
* @param integer $length The amount of bytes.
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if <var>length</var> attribute is negative or
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
public function read($length)
|
||||
{
|
||||
if ($length < 0) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Length cannot be negative');
|
||||
}
|
||||
if ($length == 0) {
|
||||
return '';
|
||||
}
|
||||
if ($this->_fd === null) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Cannot operate on a closed stream');
|
||||
}
|
||||
return fread($this->_fd, $length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 1 byte from the stream and returns binary data as an 8-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt8()
|
||||
{
|
||||
list(, $int) = unpack('c*', $this->read(1));
|
||||
return $int;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 1 byte from the stream and returns binary data as an unsigned 8-bit
|
||||
* integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readUInt8()
|
||||
{
|
||||
list(, $int) = unpack('C*', $this->read(1));
|
||||
return $int;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns machine endian ordered binary data as signed 16-bit integer.
|
||||
*
|
||||
* @param string $value The binary data string.
|
||||
* @return integer
|
||||
*/
|
||||
private function _fromInt16($value)
|
||||
{
|
||||
list(, $int) = unpack('s*', $value);
|
||||
return $int;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 2 bytes from the stream and returns little-endian ordered binary
|
||||
* data as signed 16-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt16LE()
|
||||
{
|
||||
if ($this->_isBigEndian()) {
|
||||
return $this->_fromInt16(strrev($this->read(2)));
|
||||
} else {
|
||||
return $this->_fromInt16($this->read(2));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 2 bytes from the stream and returns big-endian ordered binary data
|
||||
* as signed 16-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt16BE()
|
||||
{
|
||||
if ($this->_isLittleEndian()) {
|
||||
return $this->_fromInt16(strrev($this->read(2)));
|
||||
} else {
|
||||
return $this->_fromInt16($this->read(2));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns machine endian ordered binary data as unsigned 16-bit integer.
|
||||
*
|
||||
* @param string $value The binary data string.
|
||||
* @param integer $order The byte order of the binary data string.
|
||||
* @return integer
|
||||
*/
|
||||
private function _fromUInt16($value, $order = 0)
|
||||
{
|
||||
list(, $int) = unpack
|
||||
(($order == self::BIG_ENDIAN_ORDER ? 'n' :
|
||||
($order == self::LITTLE_ENDIAN_ORDER ? 'v' : 'S')) . '*',
|
||||
$value);
|
||||
return $int;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 2 bytes from the stream and returns little-endian ordered binary
|
||||
* data as unsigned 16-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readUInt16LE()
|
||||
{
|
||||
return $this->_fromUInt16($this->read(2), self::LITTLE_ENDIAN_ORDER);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 2 bytes from the stream and returns big-endian ordered binary data
|
||||
* as unsigned 16-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readUInt16BE()
|
||||
{
|
||||
return $this->_fromUInt16($this->read(2), self::BIG_ENDIAN_ORDER);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns machine-endian ordered binary data as signed 32-bit integer.
|
||||
*
|
||||
* @param string $value The binary data string.
|
||||
* @return integer
|
||||
*/
|
||||
private final function _fromInt32($value)
|
||||
{
|
||||
list(, $int) = unpack('l*', $value);
|
||||
return $int;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 4 bytes from the stream and returns little-endian ordered binary
|
||||
* data as signed 32-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt32LE()
|
||||
{
|
||||
if ($this->_isBigEndian())
|
||||
return $this->_fromInt32(strrev($this->read(4)));
|
||||
else
|
||||
return $this->_fromInt32($this->read(4));
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 4 bytes from the stream and returns big-endian ordered binary data
|
||||
* as signed 32-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt32BE()
|
||||
{
|
||||
if ($this->_isLittleEndian())
|
||||
return $this->_fromInt32(strrev($this->read(4)));
|
||||
else
|
||||
return $this->_fromInt32($this->read(4));
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 4 bytes from the stream and returns little-endian ordered binary
|
||||
* data as unsigned 32-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readUInt32LE()
|
||||
{
|
||||
if (PHP_INT_SIZE < 8) {
|
||||
list(, $lo, $hi) = unpack('v*', $this->read(4));
|
||||
return $hi * (0xffff+1) + $lo; // eq $hi << 16 | $lo
|
||||
} else {
|
||||
list(, $int) = unpack('V*', $this->read(4));
|
||||
return $int;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 4 bytes from the stream and returns big-endian ordered binary data
|
||||
* as unsigned 32-bit integer.
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readUInt32BE()
|
||||
{
|
||||
if (PHP_INT_SIZE < 8) {
|
||||
list(, $hi, $lo) = unpack('n*', $this->read(4));
|
||||
return $hi * (0xffff+1) + $lo; // eq $hi << 16 | $lo
|
||||
} else {
|
||||
list(, $int) = unpack('N*', $this->read(4));
|
||||
return $int;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 8 bytes from the stream and returns little-endian ordered binary
|
||||
* data as 64-bit float.
|
||||
*
|
||||
* {@internal PHP does not support 64-bit integers as the long
|
||||
* integer is of 32-bits but using aritmetic operations it is implicitly
|
||||
* converted into floating point which is of 64-bits long.}
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt64LE()
|
||||
{
|
||||
list(, $lolo, $lohi, $hilo, $hihi) = unpack('v*', $this->read(8));
|
||||
return ($hihi * (0xffff+1) + $hilo) * (0xffffffff+1) +
|
||||
($lohi * (0xffff+1) + $lolo);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 8 bytes from the stream and returns big-endian ordered binary data
|
||||
* as 64-bit float.
|
||||
*
|
||||
* {@internal PHP does not support 64-bit integers as the long integer is of
|
||||
* 32-bits but using aritmetic operations it is implicitly converted into
|
||||
* floating point which is of 64-bits long.}
|
||||
*
|
||||
* @return integer
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readInt64BE()
|
||||
{
|
||||
list(, $hihi, $hilo, $lohi, $lolo) = unpack('n*', $this->read(8));
|
||||
return ($hihi * (0xffff+1) + $hilo) * (0xffffffff+1) +
|
||||
($lohi * (0xffff+1) + $lolo);
|
||||
}
|
||||
|
||||
// TODO: How to determine float size?
|
||||
//
|
||||
// /**
|
||||
// * Returns machine endian ordered binary data as a floating point number.
|
||||
// *
|
||||
// * @param string $value The binary data string.
|
||||
// * @return float
|
||||
// */
|
||||
// private function _fromFloat($value)
|
||||
// {
|
||||
// list(, $float) = unpack('f*', $value);
|
||||
// return $float;
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Reads machine dependent size of bytes from the stream and returns
|
||||
// * little-endian ordered binary data as a floating point number.
|
||||
// *
|
||||
// * @return float
|
||||
// * @throws Zend_Io_Exception if an I/O error occurs
|
||||
// */
|
||||
// public final function readFloatLE()
|
||||
// {
|
||||
// if ($this->_isBigEndian())
|
||||
// return $this->_fromFloat(strrev($this->read(?)));
|
||||
// else
|
||||
// return $this->_fromFloat($this->read(?));
|
||||
// }
|
||||
//
|
||||
// /**
|
||||
// * Reads machine dependent size of bytes from the stream and returns
|
||||
// * big-endian ordered binary data as a float point number.
|
||||
// *
|
||||
// * @return float
|
||||
// * @throws Zend_Io_Exception if an I/O error occurs
|
||||
// */
|
||||
// public final function readFloatBE()
|
||||
// {
|
||||
// if ($this->_isLittleEndian())
|
||||
// return $this->_fromFloat(strrev($this->read(?)));
|
||||
// else
|
||||
// return $this->_fromFloat($this->read(?));
|
||||
// }
|
||||
|
||||
/**
|
||||
* Reads <var>length</var> amount of bytes from the stream and returns
|
||||
* binary data as string. Removes terminating zero.
|
||||
*
|
||||
* @param integer $length The amount of bytes.
|
||||
* @param string $charList The list of characters you want to strip.
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if <var>length</var> attribute is negative or
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
public final function readString8($length, $charList = "\0")
|
||||
{
|
||||
return rtrim($this->read($length), $charList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads <var>length</var> amount of bytes from the stream and returns
|
||||
* binary data as multibyte Unicode string. Removes terminating zero.
|
||||
*
|
||||
* The byte order is possibly determined from the byte order mark included
|
||||
* in the binary data string. The order parameter is updated if the BOM is
|
||||
* found.
|
||||
*
|
||||
* @param integer $length The amount of bytes.
|
||||
* @param integer $order The endianess of the string.
|
||||
* @param integer $trimOrder Whether to remove the byte order mark read the
|
||||
* string.
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if <var>length</var> attribute is negative or
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
public final function readString16($length, &$order = null, $trimOrder = false)
|
||||
{
|
||||
$value = $this->read($length);
|
||||
|
||||
if (strlen($value) < 2) {
|
||||
return '';
|
||||
}
|
||||
|
||||
if (ord($value[0]) == 0xfe && ord($value[1]) == 0xff) {
|
||||
$order = self::BIG_ENDIAN_ORDER;
|
||||
if ($trimOrder) {
|
||||
$value = substr($value, 2);
|
||||
}
|
||||
}
|
||||
if (ord($value[0]) == 0xff && ord($value[1]) == 0xfe) {
|
||||
$order = self::LITTLE_ENDIAN_ORDER;
|
||||
if ($trimOrder) {
|
||||
$value = substr($value, 2);
|
||||
}
|
||||
}
|
||||
|
||||
return substr($value, -2) == "\0\0" ? substr($value, 0, -2) : $value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads <var>length</var> amount of bytes from the stream and returns
|
||||
* binary data as hexadecimal string having high nibble first.
|
||||
*
|
||||
* @param integer $length The amount of bytes.
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if <var>length</var> attribute is negative or
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
public final function readHHex($length)
|
||||
{
|
||||
list($hex) = unpack('H*0', $this->read($length));
|
||||
return $hex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads <var>length</var> amount of bytes from the stream and returns
|
||||
* binary data as hexadecimal string having low nibble first.
|
||||
*
|
||||
* @param integer $length The amount of bytes.
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if <var>length</var> attribute is negative or
|
||||
* if an I/O error occurs
|
||||
*/
|
||||
public final function readLHex($length)
|
||||
{
|
||||
list($hex) = unpack('h*0', $this->read($length));
|
||||
return $hex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads 16 bytes from the stream and returns the little-endian ordered
|
||||
* binary data as mixed-ordered hexadecimal GUID string.
|
||||
*
|
||||
* @return string
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public final function readGuid()
|
||||
{
|
||||
$C = @unpack('V1V/v2v/N2N', $this->read(16));
|
||||
list($hex) = @unpack('H*0', pack
|
||||
('NnnNN', $C['V'], $C['v1'], $C['v2'], $C['N1'], $C['N2']));
|
||||
|
||||
/* Fixes a bug in PHP versions earlier than Jan 25 2006 */
|
||||
if (implode('', unpack('H*', pack('H*', 'a'))) == 'a00') {
|
||||
$hex = substr($hex, 0, -1);
|
||||
}
|
||||
|
||||
return preg_replace
|
||||
('/^(.{8})(.{4})(.{4})(.{4})/', "\\1-\\2-\\3-\\4-", $hex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets the stream. Attempts to reset it in some way appropriate to the
|
||||
* particular stream, for example by repositioning it to its starting point.
|
||||
*
|
||||
* @return void
|
||||
* @throws Zend_Io_Exception if an I/O error occurs
|
||||
*/
|
||||
public function reset()
|
||||
{
|
||||
if ($this->_fd === null) {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Cannot operate on a closed stream');
|
||||
}
|
||||
fseek($this->_fd, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Closes the stream. Once a stream has been closed, further calls to read
|
||||
* methods will throw an exception. Closing a previously-closed stream,
|
||||
* however, has no effect.
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public function close()
|
||||
{
|
||||
if ($this->_fd !== null) {
|
||||
@fclose($this->_fd);
|
||||
$this->_fd = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current machine endian order.
|
||||
*
|
||||
* @return integer
|
||||
*/
|
||||
private function _getEndianess()
|
||||
{
|
||||
if (self::$_endianess === 0) {
|
||||
self::$_endianess = $this->_fromInt32("\x01\x00\x00\x00") == 1 ?
|
||||
self::LITTLE_ENDIAN_ORDER : self::BIG_ENDIAN_ORDER;
|
||||
}
|
||||
return self::$_endianess;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the current machine endian order is little endian.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
private function _isLittleEndian()
|
||||
{
|
||||
return $this->_getEndianess() == self::LITTLE_ENDIAN_ORDER;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the current machine endian order is big endian.
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
private function _isBigEndian()
|
||||
{
|
||||
return $this->_getEndianess() == self::BIG_ENDIAN_ORDER;
|
||||
}
|
||||
|
||||
/**
|
||||
* Magic function so that $obj->value will work.
|
||||
*
|
||||
* @param string $name The field name.
|
||||
* @return mixed
|
||||
*/
|
||||
public function __get($name)
|
||||
{
|
||||
if (method_exists($this, 'get' . ucfirst(strtolower($name)))) {
|
||||
return call_user_func
|
||||
(array($this, 'get' . ucfirst(strtolower($name))));
|
||||
} else {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Unknown field: ' . $name);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Magic function so that assignments with $obj->value will work.
|
||||
*
|
||||
* @param string $name The field name.
|
||||
* @param string $value The field value.
|
||||
* @return mixed
|
||||
*/
|
||||
public function __set($name, $value)
|
||||
{
|
||||
if (method_exists($this, 'set' . ucfirst(strtolower($name)))) {
|
||||
call_user_func
|
||||
(array($this, 'set' . ucfirst(strtolower($name))), $value);
|
||||
} else {
|
||||
require_once('Zend/Io/Exception.php');
|
||||
throw new Zend_Io_Exception('Unknown field: ' . $name);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user