Viewing file:  Unserializer.php (29.29 KB) -rw-rw-rw-
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?PHP
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/**
* XML_Unserializer
*
* Parses any XML document into PHP data structures.
*
* PHP versions 4 and 5
*
* LICENSE:
*
* Copyright (c) 2003-2008 Stephan Schmidt <schst@php.net>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @category XML
* @package XML_Serializer
* @author Stephan Schmidt <schst@php.net>
* @copyright 2003-2008 Stephan Schmidt <schst@php.net>
* @license http://opensource.org/licenses/bsd-license New BSD License
* @version CVS: $Id: Unserializer.php 303099 2010-09-06 16:23:06Z clockwerx $
* @link http://pear.php.net/package/XML_Serializer
* @see XML_Unserializer
*/
/**
* uses PEAR error managemt
*/
require_once 'PEAR.php';
/**
* uses XML_Parser to unserialize document
*/
require_once 'XML/Parser.php';
/**
* option: Convert nested tags to array or object
*
* Possible values:
* - array
* - object
* - associative array to define this option per tag name
*/
define('XML_UNSERIALIZER_OPTION_COMPLEXTYPE', 'complexType');
/**
* option: Name of the attribute that stores the original key
*
* Possible values:
* - any string
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY', 'keyAttribute');
/**
* option: Name of the attribute that stores the type
*
* Possible values:
* - any string
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE', 'typeAttribute');
/**
* option: Name of the attribute that stores the class name
*
* Possible values:
* - any string
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS', 'classAttribute');
/**
* option: Whether to use the tag name as a class name
*
* Possible values:
* - true or false
*/
define('XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME', 'tagAsClass');
/**
* option: Name of the default class
*
* Possible values:
* - any string
*/
define('XML_UNSERIALIZER_OPTION_DEFAULT_CLASS', 'defaultClass');
/**
* option: Whether to parse attributes
*
* Possible values:
* - true or false
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE', 'parseAttributes');
/**
* option: Key of the array to store attributes (if any)
*
* Possible values:
* - any string
* - false (disabled)
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY', 'attributesArray');
/**
* option: string to prepend attribute name (if any)
*
* Possible values:
* - any string
* - false (disabled)
*/
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND', 'prependAttributes');
/**
* option: key to store the content,
* if XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE is used
*
* Possible values:
* - any string
*/
define('XML_UNSERIALIZER_OPTION_CONTENT_KEY', 'contentName');
/**
* option: map tag names
*
* Possible values:
* - associative array
*/
define('XML_UNSERIALIZER_OPTION_TAG_MAP', 'tagMap');
/**
* option: list of tags that will always be enumerated
*
* Possible values:
* - indexed array
*/
define('XML_UNSERIALIZER_OPTION_FORCE_ENUM', 'forceEnum');
/**
* option: Encoding of the XML document
*
* Possible values:
* - UTF-8
* - ISO-8859-1
*/
define('XML_UNSERIALIZER_OPTION_ENCODING_SOURCE', 'encoding');
/**
* option: Desired target encoding of the data
*
* Possible values:
* - UTF-8
* - ISO-8859-1
*/
define('XML_UNSERIALIZER_OPTION_ENCODING_TARGET', 'targetEncoding');
/**
* option: Callback that will be applied to textual data
*
* Possible values:
* - any valid PHP callback
*/
define('XML_UNSERIALIZER_OPTION_DECODE_FUNC', 'decodeFunction');
/**
* option: whether to return the result of the unserialization from unserialize()
*
* Possible values:
* - true
* - false (default)
*/
define('XML_UNSERIALIZER_OPTION_RETURN_RESULT', 'returnResult');
/**
* option: set the whitespace behaviour
*
* Possible values:
* - XML_UNSERIALIZER_WHITESPACE_KEEP
* - XML_UNSERIALIZER_WHITESPACE_TRIM
* - XML_UNSERIALIZER_WHITESPACE_NORMALIZE
*/
define('XML_UNSERIALIZER_OPTION_WHITESPACE', 'whitespace');
/**
* Keep all whitespace
*/
define('XML_UNSERIALIZER_WHITESPACE_KEEP', 'keep');
/**
* remove whitespace from start and end of the data
*/
define('XML_UNSERIALIZER_WHITESPACE_TRIM', 'trim');
/**
* normalize whitespace
*/
define('XML_UNSERIALIZER_WHITESPACE_NORMALIZE', 'normalize');
/**
* option: whether to ovverride all options that have been set before
*
* Possible values:
* - true
* - false (default)
*/
define('XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS', 'overrideOptions');
/**
* option: list of tags, that will not be used as keys
*/
define('XML_UNSERIALIZER_OPTION_IGNORE_KEYS', 'ignoreKeys');
/**
* option: whether to use type guessing for scalar values
*/
define('XML_UNSERIALIZER_OPTION_GUESS_TYPES', 'guessTypes');
/**
* error code for no serialization done
*/
define('XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION', 151);
/**
* XML_Unserializer
*
* class to unserialize XML documents that have been created with
* XML_Serializer. To unserialize an XML document you have to add
* type hints to the XML_Serializer options.
*
* If no type hints are available, XML_Unserializer will guess how
* the tags should be treated, that means complex structures will be
* arrays and tags with only CData in them will be strings.
*
* <code>
* require_once 'XML/Unserializer.php';
*
* // be careful to always use the ampersand in front of the new operator
* $unserializer = &new XML_Unserializer();
*
* $unserializer->unserialize($xml);
*
* $data = $unserializer->getUnserializedData();
* </code>
*
* @category XML
* @package XML_Serializer
* @author Stephan Schmidt <schst@php.net>
* @copyright 2003-2008 Stephan Schmidt <schst@php.net>
* @license http://opensource.org/licenses/bsd-license New BSD License
* @version Release: @package_version@
* @link http://pear.php.net/package/XML_Serializer
* @see XML_Serializer
*/
class XML_Unserializer extends PEAR
{
/**
* list of all available options
*
* @access private
* @var array
*/
var $_knownOptions = array(
XML_UNSERIALIZER_OPTION_COMPLEXTYPE,
XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY,
XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE,
XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS,
XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME,
XML_UNSERIALIZER_OPTION_DEFAULT_CLASS,
XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE,
XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY,
XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND,
XML_UNSERIALIZER_OPTION_CONTENT_KEY,
XML_UNSERIALIZER_OPTION_TAG_MAP,
XML_UNSERIALIZER_OPTION_FORCE_ENUM,
XML_UNSERIALIZER_OPTION_ENCODING_SOURCE,
XML_UNSERIALIZER_OPTION_ENCODING_TARGET,
XML_UNSERIALIZER_OPTION_DECODE_FUNC,
XML_UNSERIALIZER_OPTION_RETURN_RESULT,
XML_UNSERIALIZER_OPTION_WHITESPACE,
XML_UNSERIALIZER_OPTION_IGNORE_KEYS,
XML_UNSERIALIZER_OPTION_GUESS_TYPES
);
/**
* default options for the serialization
*
* @access private
* @var array
*/
var $_defaultOptions = array(
// complex types will be converted to arrays, if no type hint is given
XML_UNSERIALIZER_OPTION_COMPLEXTYPE => 'array',
// get array key/property name from this attribute
XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY => '_originalKey',
// get type from this attribute
XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE => '_type',
// get class from this attribute (if not given, use tag name)
XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS => '_class',
// use the tagname as the classname
XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME => true,
// name of the class that is used to create objects
XML_UNSERIALIZER_OPTION_DEFAULT_CLASS => 'stdClass',
// parse the attributes of the tag into an array
XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE => false,
// parse them into sperate array (specify name of array here)
XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY => false,
// prepend attribute names with this string
XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND => '',
// put cdata found in a tag that has been converted
// to a complex type in this key
XML_UNSERIALIZER_OPTION_CONTENT_KEY => '_content',
// use this to map tagnames
XML_UNSERIALIZER_OPTION_TAG_MAP => array(),
// these tags will always be an indexed array
XML_UNSERIALIZER_OPTION_FORCE_ENUM => array(),
// specify the encoding character of the document to parse
XML_UNSERIALIZER_OPTION_ENCODING_SOURCE => null,
// specify the target encoding
XML_UNSERIALIZER_OPTION_ENCODING_TARGET => null,
// function used to decode data
XML_UNSERIALIZER_OPTION_DECODE_FUNC => null,
// unserialize() returns the result of the unserialization instead of true
XML_UNSERIALIZER_OPTION_RETURN_RESULT => false,
// remove whitespace around data
XML_UNSERIALIZER_OPTION_WHITESPACE => XML_UNSERIALIZER_WHITESPACE_TRIM,
// List of tags that will automatically be added to the parent,
// instead of adding a new key
XML_UNSERIALIZER_OPTION_IGNORE_KEYS => array(),
// Whether to use type guessing
XML_UNSERIALIZER_OPTION_GUESS_TYPES => false
);
/**
* current options for the serialization
*
* @access public
* @var array
*/
var $options = array();
/**
* unserialized data
*
* @access private
* @var string
*/
var $_unserializedData = null;
/**
* name of the root tag
*
* @access private
* @var string
*/
var $_root = null;
/**
* stack for all data that is found
*
* @access private
* @var array
*/
var $_dataStack = array();
/**
* stack for all values that are generated
*
* @access private
* @var array
*/
var $_valStack = array();
/**
* current tag depth
*
* @access private
* @var int
*/
var $_depth = 0;
/**
* XML_Parser instance
*
* @access private
* @var object XML_Parser
*/
var $_parser = null;
/**
* constructor
*
* @param mixed $options array containing options for the unserialization
*
* @access public
*/
function XML_Unserializer($options = null)
{
if (is_array($options)) {
$this->options = array_merge($this->_defaultOptions, $options);
} else {
$this->options = $this->_defaultOptions;
}
}
/**
* return API version
*
* @access public
* @return string $version API version
* @static
*/
function apiVersion()
{
return '@package_version@';
}
/**
* reset all options to default options
*
* @return void
* @access public
* @see setOption(), XML_Unserializer(), setOptions()
*/
function resetOptions()
{
$this->options = $this->_defaultOptions;
}
/**
* set an option
*
* You can use this method if you do not want
* to set all options in the constructor
*
* @param string $name name of option
* @param mixed $value value of option
*
* @return void
* @access public
* @see resetOption(), XML_Unserializer(), setOptions()
*/
function setOption($name, $value)
{
$this->options[$name] = $value;
}
/**
* sets several options at once
*
* You can use this method if you do not want
* to set all options in the constructor
*
* @param array $options options array
*
* @return void
* @access public
* @see resetOption(), XML_Unserializer(), setOption()
*/
function setOptions($options)
{
$this->options = array_merge($this->options, $options);
}
/**
* unserialize data
*
* @param mixed $data data to unserialize (string, filename or resource)
* @param boolean $isFile data should be treated as a file
* @param array $options options that will override
* the global options for this call
*
* @return boolean $success
* @access public
*/
function unserialize($data, $isFile = false, $options = null)
{
$this->_unserializedData = null;
$this->_root = null;
// if options have been specified, use them instead
// of the previously defined ones
if (is_array($options)) {
$optionsBak = $this->options;
if (isset($options[XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS])
&& $options[XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS] == true
) {
$this->options = array_merge($this->_defaultOptions, $options);
} else {
$this->options = array_merge($this->options, $options);
}
} else {
$optionsBak = null;
}
$this->_valStack = array();
$this->_dataStack = array();
$this->_depth = 0;
$this->_createParser();
if (is_string($data)) {
if ($isFile) {
$result = $this->_parser->setInputFile($data);
if (PEAR::isError($result)) {
return $result;
}
$result = $this->_parser->parse();
} else {
$result = $this->_parser->parseString($data, true);
}
} else {
$this->_parser->setInput($data);
$result = $this->_parser->parse();
}
if ($this->options[XML_UNSERIALIZER_OPTION_RETURN_RESULT] === true) {
$return = $this->_unserializedData;
} else {
$return = true;
}
if ($optionsBak !== null) {
$this->options = $optionsBak;
}
if (PEAR::isError($result)) {
return $result;
}
return $return;
}
/**
* get the result of the serialization
*
* @access public
* @return string $serializedData
*/
function getUnserializedData()
{
if ($this->_root === null) {
return $this->raiseError('No unserialized data available. '
. 'Use XML_Unserializer::unserialize() first.',
XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION);
}
return $this->_unserializedData;
}
/**
* get the name of the root tag
*
* @access public
* @return string $rootName
*/
function getRootName()
{
if ($this->_root === null) {
return $this->raiseError('No unserialized data available. '
. 'Use XML_Unserializer::unserialize() first.',
XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION);
}
return $this->_root;
}
/**
* Start element handler for XML parser
*
* @param object $parser XML parser object
* @param string $element XML element
* @param array $attribs attributes of XML tag
*
* @return void
* @access private
*/
function startHandler($parser, $element, $attribs)
{
if (isset($attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE]])
) {
$type = $attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE]];
$guessType = false;
} else {
$type = 'string';
if ($this->options[XML_UNSERIALIZER_OPTION_GUESS_TYPES] === true) {
$guessType = true;
} else {
$guessType = false;
}
}
if ($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC] !== null) {
$attribs = array_map($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC],
$attribs);
}
$this->_depth++;
$this->_dataStack[$this->_depth] = null;
if (is_array($this->options[XML_UNSERIALIZER_OPTION_TAG_MAP])
&& isset($this->options[XML_UNSERIALIZER_OPTION_TAG_MAP][$element])
) {
$element = $this->options[XML_UNSERIALIZER_OPTION_TAG_MAP][$element];
}
$val = array(
'name' => $element,
'value' => null,
'type' => $type,
'guessType' => $guessType,
'childrenKeys' => array(),
'aggregKeys' => array()
);
if ($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE] == true
&& (count($attribs) > 0)
) {
$val['children'] = array();
$val['type'] = $this->_getComplexType($element);
$val['class'] = $element;
if ($this->options[XML_UNSERIALIZER_OPTION_GUESS_TYPES] === true) {
$attribs = $this->_guessAndSetTypes($attribs);
}
if ($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY] != false
) {
$val['children'][$this->
options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY]] = $attribs;
} else {
foreach ($attribs as $attrib => $value) {
$val['children'][$this->
options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND]
. $attrib] = $value;
}
}
}
$keyAttr = false;
if (is_string($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY])) {
$keyAttr = $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY];
} elseif (is_array($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY])) {
if (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
[$element])
) {
$keyAttr =
$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY][$element];
} elseif (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
['#default'])
) {
$keyAttr = $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
['#default'];
} elseif (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
['__default'])
) {
// keep this for BC
$keyAttr =
$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
['__default'];
}
}
if ($keyAttr !== false && isset($attribs[$keyAttr])) {
$val['name'] = $attribs[$keyAttr];
}
if (isset($attribs[$this->
options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS]])
) {
$val['class'] =
$attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS]];
}
array_push($this->_valStack, $val);
}
/**
* Try to guess the type of several values and
* set them accordingly
*
* @param array $array array containing the values
*
* @return array array, containing the values with their correct types
* @access private
*/
function _guessAndSetTypes($array)
{
foreach ($array as $key => $value) {
$array[$key] = $this->_guessAndSetType($value);
}
return $array;
}
/**
* Try to guess the type of a value and
* set it accordingly
*
* @param string $value character data
*
* @return mixed value with the best matching type
* @access private
*/
function _guessAndSetType($value)
{
if ($value === 'true') {
return true;
}
if ($value === 'false') {
return false;
}
if ($value === 'NULL') {
return null;
}
if (preg_match('/^[-+]?[0-9]{1,}\\z/', $value)) {
return intval($value);
}
if (preg_match('/^[-+]?[0-9]{1,}\.[0-9]{1,}\\z/', $value)) {
return doubleval($value);
}
return (string)$value;
}
/**
* End element handler for XML parser
*
* @param object $parser XML parser object
* @param string $element element
*
* @return void
* @access private
*/
function endHandler($parser, $element)
{
$value = array_pop($this->_valStack);
switch ($this->options[XML_UNSERIALIZER_OPTION_WHITESPACE]) {
case XML_UNSERIALIZER_WHITESPACE_KEEP:
$data = $this->_dataStack[$this->_depth];
break;
case XML_UNSERIALIZER_WHITESPACE_NORMALIZE:
$data = trim(preg_replace('/\s\s+/m', ' ',
$this->_dataStack[$this->_depth]));
break;
case XML_UNSERIALIZER_WHITESPACE_TRIM:
default:
$data = trim($this->_dataStack[$this->_depth]);
break;
}
// adjust type of the value
switch(strtolower($value['type'])) {
// unserialize an object
case 'object':
if (isset($value['class'])) {
$classname = $value['class'];
} else {
$classname = '';
}
// instantiate the class
if ($this->options[XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME] === true
&& class_exists($classname)
) {
$value['value'] = new $classname;
} else {
$value['value'] =
new $this->options[XML_UNSERIALIZER_OPTION_DEFAULT_CLASS];
}
if (trim($data) !== '') {
if ($value['guessType'] === true) {
$data = $this->_guessAndSetType($data);
}
$value['children'][$this->
options[XML_UNSERIALIZER_OPTION_CONTENT_KEY]] = $data;
}
// set properties
foreach ($value['children'] as $prop => $propVal) {
// check whether there is a special method to set this property
$setMethod = 'set'.$prop;
if (method_exists($value['value'], $setMethod)) {
call_user_func(array(&$value['value'], $setMethod), $propVal);
} else {
$value['value']->$prop = $propVal;
}
}
// check for magic function
if (method_exists($value['value'], '__wakeup')) {
$value['value']->__wakeup();
}
break;
// unserialize an array
case 'array':
if (trim($data) !== '') {
if ($value['guessType'] === true) {
$data = $this->_guessAndSetType($data);
}
$value['children'][$this->
options[XML_UNSERIALIZER_OPTION_CONTENT_KEY]] = $data;
}
if (isset($value['children'])) {
$value['value'] = $value['children'];
} else {
$value['value'] = array();
}
break;
// unserialize a null value
case 'null':
$data = null;
break;
// unserialize a resource => this is not possible :-(
case 'resource':
$value['value'] = $data;
break;
// unserialize any scalar value
default:
if ($value['guessType'] === true) {
$data = $this->_guessAndSetType($data);
} else {
settype($data, $value['type']);
}
$value['value'] = $data;
break;
}
$parent = array_pop($this->_valStack);
if ($parent === null) {
$this->_unserializedData = &$value['value'];
$this->_root = &$value['name'];
return true;
} else {
// parent has to be an array
if (!isset($parent['children']) || !is_array($parent['children'])) {
$parent['children'] = array();
if (!in_array($parent['type'], array('array', 'object'))) {
$parent['type'] = $this->_getComplexType($parent['name']);
if ($parent['type'] == 'object') {
$parent['class'] = $parent['name'];
}
}
}
if (in_array($element,
$this->options[XML_UNSERIALIZER_OPTION_IGNORE_KEYS])
) {
$ignoreKey = true;
} else {
$ignoreKey = false;
}
if (!empty($value['name']) && $ignoreKey === false) {
// there already has been a tag with this name
if (in_array($value['name'], $parent['childrenKeys'])
|| in_array($value['name'],
$this->options[XML_UNSERIALIZER_OPTION_FORCE_ENUM])
) {
// no aggregate has been created for this tag
if (!in_array($value['name'], $parent['aggregKeys'])) {
if (isset($parent['children'][$value['name']])) {
$parent['children'][$value['name']] =
array($parent['children'][$value['name']]);
} else {
$parent['children'][$value['name']] = array();
}
array_push($parent['aggregKeys'], $value['name']);
}
array_push($parent['children'][$value['name']], $value['value']);
} else {
$parent['children'][$value['name']] = &$value['value'];
array_push($parent['childrenKeys'], $value['name']);
}
} else {
array_push($parent['children'], $value['value']);
}
array_push($this->_valStack, $parent);
}
$this->_depth--;
}
/**
* Handler for character data
*
* @param object $parser XML parser object
* @param string $cdata CDATA
*
* @return void
* @access private
*/
function cdataHandler($parser, $cdata)
{
if ($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC] !== null) {
$cdata = call_user_func($this->
options[XML_UNSERIALIZER_OPTION_DECODE_FUNC], $cdata);
}
$this->_dataStack[$this->_depth] .= $cdata;
}
/**
* get the complex type, that should be used for a specified tag
*
* @param string $tagname name of the tag
*
* @return string complex type ('array' or 'object')
* @access private
*/
function _getComplexType($tagname)
{
if (is_string($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE])) {
return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE];
}
if (isset($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE][$tagname])) {
return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE][$tagname];
}
if (isset($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE]['#default'])) {
return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE]['#default'];
}
return 'array';
}
/**
* create the XML_Parser instance
*
* @return boolean
* @access private
*/
function _createParser()
{
if (is_object($this->_parser)) {
$this->_parser->free();
unset($this->_parser);
}
$this->_parser = new XML_Parser($this->
options[XML_UNSERIALIZER_OPTION_ENCODING_SOURCE],
'event', $this->options[XML_UNSERIALIZER_OPTION_ENCODING_TARGET]);
$this->_parser->folding = false;
$this->_parser->setHandlerObj($this);
return true;
}
}
?>
|