Subversion-Projekte lars-tiefland.php_share

<?PHP

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**

 * XML_Serializer

 *

 * Creates XML documents from PHP data structures like arrays, objects or scalars.

 *

 * 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: Serializer.php 294967 2010-02-12 03:10:19Z clockwerx $

 * @link      http://pear.php.net/package/XML_Serializer

 * @see       XML_Unserializer

 */

/**

 * uses PEAR error management

 */

require_once 'PEAR.php';

/**

 * uses XML_Util to create XML tags

 */

require_once 'XML/Util.php';

/**

 * option: string used for indentation

 *

 * Possible values:

 * - any string (default is any string)

 */

define('XML_SERIALIZER_OPTION_INDENT', 'indent');

/**

 * option: string used for linebreaks

 *

 * Possible values:

 * - any string (default is \n)

 */

define('XML_SERIALIZER_OPTION_LINEBREAKS', 'linebreak');

/**

 * option: enable type hints

 *

 * Possible values:

 * - true

 * - false

 */

define('XML_SERIALIZER_OPTION_TYPEHINTS', 'typeHints');

/**

 * option: add an XML declaration

 *

 * Possible values:

 * - true

 * - false

 */

define('XML_SERIALIZER_OPTION_XML_DECL_ENABLED', 'addDecl');

/**

 * option: encoding of the document

 *

 * Possible values:

 * - any valid encoding

 * - null (default)

 */

define('XML_SERIALIZER_OPTION_XML_ENCODING', 'encoding');

/**

 * option: default name for tags

 *

 * Possible values:

 * - any string (XML_Serializer_Tag is default)

 */

define('XML_SERIALIZER_OPTION_DEFAULT_TAG', 'defaultTagName');

/**

 * option: use classname for objects in indexed arrays

 *

 * Possible values:

 * - true

 * - false (default)

 */

define('XML_SERIALIZER_OPTION_CLASSNAME_AS_TAGNAME', 'classAsTagName');

/**

 * option: attribute where original key is stored

 *

 * Possible values:

 * - any string (default is _originalKey)

 */

define('XML_SERIALIZER_OPTION_ATTRIBUTE_KEY', 'keyAttribute');

/**

 * option: attribute for type (only if typeHints => true)

 *

 * Possible values:

 * - any string (default is _type)

 */

define('XML_SERIALIZER_OPTION_ATTRIBUTE_TYPE', 'typeAttribute');

/**

 * option: attribute for class (only if typeHints => true)

 *

 * Possible values:

 * - any string (default is _class)

 */

define('XML_SERIALIZER_OPTION_ATTRIBUTE_CLASS', 'classAttribute');

/**

 * option: scalar values (strings, ints,..) will be serialized as attribute

 *

 * Possible values:

 * - true

 * - false (default)

 * - array which sets this option on a per-tag basis

 */

define('XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES', 'scalarAsAttributes');

/**

 * option: prepend string for attributes

 *

 * Possible values:

 * - any string (default is any string)

 */

define('XML_SERIALIZER_OPTION_PREPEND_ATTRIBUTES', 'prependAttributes');

/**

 * option: indent the attributes, if set to '_auto',

 * it will indent attributes so they all start at the same column

 *

 * Possible values:

 * - true

 * - false (default)

 * - '_auto'

 */

define('XML_SERIALIZER_OPTION_INDENT_ATTRIBUTES', 'indentAttributes');

/**

 * option: use 'simplexml' to use parent name as tagname

 * if transforming an indexed array

 *

 * Possible values:

 * - XML_SERIALIZER_MODE_DEFAULT (default)

 * - XML_SERIALIZER_MODE_SIMPLEXML

 */

define('XML_SERIALIZER_OPTION_MODE', 'mode');

/**

 * option: add a doctype declaration

 *

 * Possible values:

 * - true

 * - false (default)

 */

define('XML_SERIALIZER_OPTION_DOCTYPE_ENABLED', 'addDoctype');

/**

 * option: supply a string or an array with id and uri

 * ({@see XML_Util::getDoctypeDeclaration()}

 *

 * Possible values:

 * - string

 * - array

 */

define('XML_SERIALIZER_OPTION_DOCTYPE', 'doctype');

/**

 * option: name of the root tag

 *

 * Possible values:

 * - string

 * - null (default)

 */

define('XML_SERIALIZER_OPTION_ROOT_NAME', 'rootName');

/**

 * option: attributes of the root tag

 *

 * Possible values:

 * - array

 */

define('XML_SERIALIZER_OPTION_ROOT_ATTRIBS', 'rootAttributes');

/**

 * option: all values in this key will be treated as attributes

 *

 * Possible values:

 * - string

 */

define('XML_SERIALIZER_OPTION_ATTRIBUTES_KEY', 'attributesArray');

/**

 * option: this value will be used directly as content,

 * instead of creating a new tag, may only be used

 * in conjuction with attributesArray

 *

 * Possible values:

 * - string

 * - null (default)

 */

define('XML_SERIALIZER_OPTION_CONTENT_KEY', 'contentName');

/**

 * option: this value will be used in a comment, instead of creating a new tag

 *

 * Possible values:

 * - string

 * - null (default)

 */

define('XML_SERIALIZER_OPTION_COMMENT_KEY', 'commentName');

/**

 * option: tag names that will be changed

 *

 * Possible values:

 * - array

 */

define('XML_SERIALIZER_OPTION_TAGMAP', 'tagMap');

/**

 * option: function that will be applied before serializing

 *

 * Possible values:

 * - any valid PHP callback

 */

define('XML_SERIALIZER_OPTION_ENCODE_FUNC', 'encodeFunction');

/**

 * option: namespace to use for the document

 *

 * Possible values:

 * - string

 * - null (default)

 */

define('XML_SERIALIZER_OPTION_NAMESPACE', 'namespace');

/**

 * option: type of entities to replace

 *

 * Possible values:

 * - XML_SERIALIZER_ENTITIES_NONE

 * - XML_SERIALIZER_ENTITIES_XML (default)

 * - XML_SERIALIZER_ENTITIES_XML_REQUIRED

 * - XML_SERIALIZER_ENTITIES_HTML

 */

define('XML_SERIALIZER_OPTION_ENTITIES', 'replaceEntities');

/**

 * option: whether to return the result of the serialization from serialize()

 *

 * Possible values:

 * - true

 * - false (default)

 */

define('XML_SERIALIZER_OPTION_RETURN_RESULT', 'returnResult');

/**

 * option: whether to ignore properties that are set to null

 *

 * Possible values:

 * - true

 * - false (default)

 */

define('XML_SERIALIZER_OPTION_IGNORE_NULL', 'ignoreNull');

/**

 * option: whether to use cdata sections for character data

 *

 * Possible values:

 * - true

 * - false (default)

 */

define('XML_SERIALIZER_OPTION_CDATA_SECTIONS', 'cdata');

/**

 * option: whether a boolean FALSE value should become a string

 *

 * Possible values:

 * - true

 * - false (default)

 *

 * @since 0.20.0

 */

define('XML_SERIALIZER_OPTION_FALSE_AS_STRING', 'falseAsString');

/**

 * default mode

 */

define('XML_SERIALIZER_MODE_DEFAULT', 'default');

/**

 * SimpleXML mode

 *

 * When serializing indexed arrays, the key of the parent value is used as a tagname.

 */

define('XML_SERIALIZER_MODE_SIMPLEXML', 'simplexml');

/**

 * error code for no serialization done

 */

define('XML_SERIALIZER_ERROR_NO_SERIALIZATION', 51);

/**

 * do not replace entitites

 */

define('XML_SERIALIZER_ENTITIES_NONE', XML_UTIL_ENTITIES_NONE);

/**

 * replace all XML entitites

 * This setting will replace <, >, ", ' and &

 */

define('XML_SERIALIZER_ENTITIES_XML', XML_UTIL_ENTITIES_XML);

/**

 * replace only required XML entitites

 * This setting will replace <, " and &

 */

define('XML_SERIALIZER_ENTITIES_XML_REQUIRED', XML_UTIL_ENTITIES_XML_REQUIRED);

/**

 * replace HTML entitites

 * @link    http://www.php.net/htmlentities

 */

define('XML_SERIALIZER_ENTITIES_HTML', XML_UTIL_ENTITIES_HTML);

/**

 * Creates XML documents from PHP data structures like arrays, objects or scalars.

 *

 * This class can be used in two modes:

 *

 *  1. Create an XML document from an array or object that is processed by other

 *    applications. That means you can create an RDF document from an array in the

 *    following format:

 *    <code>

 *    $data = array(

 *        'channel' => array(

 *            'title' => 'Example RDF channel',

 *            'link'  => 'http://www.php-tools.de',

 *            'image' => array(

 *                'title' => 'Example image',

 *                'url'   => 'http://www.php-tools.de/image.gif',

 *                'link'  => 'http://www.php-tools.de'

 *            ),

 *            array(

 *                'title' => 'Example item',

 *                'link'  => 'http://example.com'

 *            ),

 *            array(

 *                'title' => 'Another Example item',

 *                'link'  => 'http://example.org'

 *            )

 *        )

 *    );

 *    </code>

 *

 *    To create an RDF document from this array, do the following:

 *

 *    <code>

 *    require_once 'XML/Serializer.php';

 *    $options = array(

 *       XML_SERIALIZER_OPTION_INDENT      => "\t",     // indent with tabs

 *       XML_SERIALIZER_OPTION_LINEBREAKS  => "\n",     // use UNIX line breaks

 *       XML_SERIALIZER_OPTION_ROOT_NAME   => 'rdf:RDF',// root tag

 *       XML_SERIALIZER_OPTION_DEFAULT_TAG => 'item'    // tag for values

 *                                                      // with numeric keys

 *    );

 *    $serializer = new XML_Serializer($options);

 *    $rdf        = $serializer->serialize($data);

 *    </code>

 *

 *    You will get a complete XML document that can be processed like any RDF document.

 *

 * 2. This class can be used to serialize any data structure in a way that it can

 *    later be unserialized again.  XML_Serializer will store the type of the value

 *    and additional meta information in attributes of the surrounding tag. This

 *    meta information can later be used to restore the original data structure

 *    in PHP. If you want XML_Serializer to add meta information to the tags, add

 *    <code>

 *      XML_SERIALIZER_OPTION_TYPEHINTS => true

 *    </code>

 *    to the options array in the constructor.

 *

 * @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_Unserializer

 * @todo      replace extending PEAR class with instead using a PEAR_Error object

 */

class XML_Serializer extends PEAR

{

    /**

     * List of all available options

     *

     * @access private

     * @var    array

     */

    var $_knownOptions = array(

        XML_SERIALIZER_OPTION_INDENT,

        XML_SERIALIZER_OPTION_LINEBREAKS,

        XML_SERIALIZER_OPTION_TYPEHINTS,

        XML_SERIALIZER_OPTION_XML_DECL_ENABLED,

        XML_SERIALIZER_OPTION_XML_ENCODING,

        XML_SERIALIZER_OPTION_DEFAULT_TAG,

        XML_SERIALIZER_OPTION_CLASSNAME_AS_TAGNAME,

        XML_SERIALIZER_OPTION_ATTRIBUTE_KEY,

        XML_SERIALIZER_OPTION_ATTRIBUTE_TYPE,

        XML_SERIALIZER_OPTION_ATTRIBUTE_CLASS,

        XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES,

        XML_SERIALIZER_OPTION_PREPEND_ATTRIBUTES,

        XML_SERIALIZER_OPTION_INDENT_ATTRIBUTES,

        XML_SERIALIZER_OPTION_MODE,

        XML_SERIALIZER_OPTION_DOCTYPE_ENABLED,

        XML_SERIALIZER_OPTION_DOCTYPE,

        XML_SERIALIZER_OPTION_ROOT_NAME,

        XML_SERIALIZER_OPTION_ROOT_ATTRIBS,

        XML_SERIALIZER_OPTION_ATTRIBUTES_KEY,

        XML_SERIALIZER_OPTION_CONTENT_KEY,

        XML_SERIALIZER_OPTION_COMMENT_KEY,

        XML_SERIALIZER_OPTION_TAGMAP,

        XML_SERIALIZER_OPTION_ENCODE_FUNC,

        XML_SERIALIZER_OPTION_NAMESPACE,

        XML_SERIALIZER_OPTION_ENTITIES,

        XML_SERIALIZER_OPTION_RETURN_RESULT,

        XML_SERIALIZER_OPTION_IGNORE_NULL,

        XML_SERIALIZER_OPTION_CDATA_SECTIONS,

    );

    /**

     * Default options for the serialization

     *

     * @access private

     * @var    array

     */

    var $_defaultOptions = array(

        // string used for indentation

        XML_SERIALIZER_OPTION_INDENT => '',

        // string used for newlines

        XML_SERIALIZER_OPTION_LINEBREAKS => "\n",

        // automatically add type hin attributes

        XML_SERIALIZER_OPTION_TYPEHINTS => false,

        // add an XML declaration

        XML_SERIALIZER_OPTION_XML_DECL_ENABLED => false,

        // encoding specified in the XML declaration

        XML_SERIALIZER_OPTION_XML_ENCODING => null,

        // tag used for indexed arrays or invalid names

        XML_SERIALIZER_OPTION_DEFAULT_TAG => 'XML_Serializer_Tag',

        // use classname for objects in indexed arrays

        XML_SERIALIZER_OPTION_CLASSNAME_AS_TAGNAME => false,

        // attribute where original key is stored

        XML_SERIALIZER_OPTION_ATTRIBUTE_KEY => '_originalKey',

        // attribute for type (only if typeHints => true)

        XML_SERIALIZER_OPTION_ATTRIBUTE_TYPE => '_type',

        // attribute for class of objects (only if typeHints => true)

        XML_SERIALIZER_OPTION_ATTRIBUTE_CLASS => '_class',

        // scalar values (strings, ints,..) will be serialized as attribute

        XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES => false,

        // prepend string for attributes

        XML_SERIALIZER_OPTION_PREPEND_ATTRIBUTES => '',

        // indent the attributes, if set to '_auto',

        // it will indent attributes so they all start at the same column

        XML_SERIALIZER_OPTION_INDENT_ATTRIBUTES => false,

        // use XML_SERIALIZER_MODE_SIMPLEXML to use parent name as tagname

        // if transforming an indexed array

        XML_SERIALIZER_OPTION_MODE => XML_SERIALIZER_MODE_DEFAULT,

        // add a doctype declaration

        XML_SERIALIZER_OPTION_DOCTYPE_ENABLED => false,

        // supply a string or an array with id and uri

        // ({@see XML_Util::getDoctypeDeclaration()}

        XML_SERIALIZER_OPTION_DOCTYPE => null,

        // name of the root tag

        XML_SERIALIZER_OPTION_ROOT_NAME => null,

        // attributes of the root tag

        XML_SERIALIZER_OPTION_ROOT_ATTRIBS => array(),

        // all values in this key will be treated as attributes

        XML_SERIALIZER_OPTION_ATTRIBUTES_KEY => null,

        // this value will be used directly as content,

        // instead of creating a new tag, may only be used

        // in conjuction with attributesArray

        XML_SERIALIZER_OPTION_CONTENT_KEY => null,

        // this value will be used directly as comment,

        // instead of creating a new tag, may only be used

        // in conjuction with attributesArray

        XML_SERIALIZER_OPTION_COMMENT_KEY => null,

        // tag names that will be changed

        XML_SERIALIZER_OPTION_TAGMAP => array(),

        // function that will be applied before serializing

        XML_SERIALIZER_OPTION_ENCODE_FUNC => null,

        // namespace to use

        XML_SERIALIZER_OPTION_NAMESPACE => null,

        // type of entities to replace,

        XML_SERIALIZER_OPTION_ENTITIES => XML_SERIALIZER_ENTITIES_XML,

        // serialize() returns the result of the serialization instead of true

        XML_SERIALIZER_OPTION_RETURN_RESULT => false,

        // ignore properties that are set to null

        XML_SERIALIZER_OPTION_IGNORE_NULL => false,

        // Whether to use cdata sections for plain character data

        XML_SERIALIZER_OPTION_CDATA_SECTIONS => false,

        // Whether to convert a boolean FALSE into a string

        XML_SERIALIZER_OPTION_FALSE_AS_STRING => false,

    );

    /**

     * Options for the serialization

     *

     * @access public

     * @var    array

     */

    var $options = array();

    /**

     * Current tag depth

     *

     * @access private

     * @var    integer

     */

    var $_tagDepth = 0;

    /**

     * Serialized representation of the data

     *

     * @access private

     * @var    string

     */

    var $_serializedData = null;

    /**

     * Constructor

     *

     * @param mixed $options array containing options for the serialization

     *

     * @access public

     */

    function XML_Serializer( $options = null )

    {

        $this->PEAR();

        if (is_array($options)) {

            $this->options = array_merge($this->_defaultOptions, $options);

        } else {

            $this->options = $this->_defaultOptions;

        }

    }

    /**

     * Return the package version number

     *

     * @access public

     * @static

     * @return string the version number of XML_Serializer

     */

    function apiVersion()

    {

        return '@package_version@';

    }

    /**

     * Reset all options to default options

     *

     * @return void

     * @access public

     */

    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  option name

     * @param mixed  $value option value

     *

     * @return void

     * @access public

     */

    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

     */

    function setOptions($options)

    {

        $this->options = array_merge($this->options, $options);

    }

    /**

     * serialize data

     *

     * @param mixed $data    data to serialize

     * @param array $options options array

     *

     * @return boolean true on success, pear error on failure

     * @access public

     * @uses XML_Util::getDoctypeDeclaration()

     * @uses XML_Util::getXMLDeclaration()

     * @internal uses error suppression "@settype()"

     */

    function serialize($data, $options = null)

    {

        // if options have been specified, use them instead

        // of the previously defined ones

        if (is_array($options)) {

            $optionsBak = $this->options;

            if (isset($options['overrideOptions'])

                && $options['overrideOptions'] == true

            ) {

                $this->options = array_merge($this->_defaultOptions, $options);

            } else {

                $this->options = array_merge($this->options, $options);

            }

        } else {

            $optionsBak = null;

        }

        //  start depth is zero

        $this->_tagDepth = 0;

        $rootAttributes = $this->options[XML_SERIALIZER_OPTION_ROOT_ATTRIBS];

        if (isset($this->options[XML_SERIALIZER_OPTION_NAMESPACE])

            && is_array($this->options[XML_SERIALIZER_OPTION_NAMESPACE])

        ) {

            $rootAttributes['xmlns:'

                . $this->options[XML_SERIALIZER_OPTION_NAMESPACE][0]] =

                $this->options[XML_SERIALIZER_OPTION_NAMESPACE][1];

        }

        $this->_serializedData = '';

        // serialize an array

        if (is_array($data)) {

            if (isset($this->options[XML_SERIALIZER_OPTION_ROOT_NAME])) {

                $tagName = $this->options[XML_SERIALIZER_OPTION_ROOT_NAME];

            } else {

                $tagName = 'array';

            }

            $this->_serializedData .=

                $this->_serializeArray($data, $tagName, $rootAttributes);

        } elseif (is_object($data)) {

            // serialize an object

            if (isset($this->options[XML_SERIALIZER_OPTION_ROOT_NAME])) {

                $tagName = $this->options[XML_SERIALIZER_OPTION_ROOT_NAME];

            } else {

                $tagName = get_class($data);

            }

            $this->_serializedData .=

                $this->_serializeObject($data, $tagName, $rootAttributes);

        } else {

            $tag = array();

            if (isset($this->options[XML_SERIALIZER_OPTION_ROOT_NAME])) {

                $tag['qname'] = $this->options[XML_SERIALIZER_OPTION_ROOT_NAME];

            } else {

                $tag['qname'] = gettype($data);

            }

            $tagName = $tag['qname'];

            if ($this->options[XML_SERIALIZER_OPTION_TYPEHINTS] === true) {

                $rootAttributes[$this->

                    options[XML_SERIALIZER_OPTION_ATTRIBUTE_TYPE]] = gettype($data);

            }

            if (!is_bool($data)) {

                $tag['content'] = $data;

            } elseif ($data === false) {

                if ($this->options[XML_SERIALIZER_OPTION_FALSE_AS_STRING] === true) {

                    $tag['content'] = '0';

                } else {

                    $tag['content'] = '';

                }

            } else {

                $tag['content'] = $data;

            }

            @settype($data, 'string');

            $tag['attributes']     = $rootAttributes;

            $this->_serializedData = $this->_createXMLTag($tag);

        }

        // add doctype declaration

        if ($this->options[XML_SERIALIZER_OPTION_DOCTYPE_ENABLED] === true) {

            $this->_serializedData =

                XML_Util::getDoctypeDeclaration($tagName,

                $this->options[XML_SERIALIZER_OPTION_DOCTYPE])

                . $this->options[XML_SERIALIZER_OPTION_LINEBREAKS]

                . $this->_serializedData;

        }

        //  build xml declaration

        if ($this->options[XML_SERIALIZER_OPTION_XML_DECL_ENABLED]) {

            $atts                  = array();

            $this->_serializedData = XML_Util::getXMLDeclaration('1.0',

                $this->options[XML_SERIALIZER_OPTION_XML_ENCODING])

                . $this->options[XML_SERIALIZER_OPTION_LINEBREAKS]

                . $this->_serializedData;

        }

        if ($this->options[XML_SERIALIZER_OPTION_RETURN_RESULT] === true) {

            $result = $this->_serializedData;

        } else {

            $result = true;

        }

        if ($optionsBak !== null) {

            $this->options = $optionsBak;

        }

        return $result;

    }

    /**

     * get the result of the serialization

     *

     * @access public

     * @return string serialized XML

     */

    function getSerializedData()

    {

        if ($this->_serializedData == null) {

            return $this->raiseError('No serialized data available. '

                . 'Use XML_Serializer::serialize() first.',

                XML_SERIALIZER_ERROR_NO_SERIALIZATION);

        }

        return $this->_serializedData;

    }

    /**

     * serialize any value

     *

     * This method checks for the type of the value and calls the appropriate method

     *

     * @param mixed  $value      tag value

     * @param string $tagName    tag name

     * @param array  $attributes attributes

     *

     * @return string

     * @access private

     */

    function _serializeValue($value, $tagName = null, $attributes = array())

    {

        if (is_array($value)) {

            $xml = $this->_serializeArray($value, $tagName, $attributes);

        } elseif (is_object($value)) {

            $xml = $this->_serializeObject($value, $tagName);

        } else {

            $tag = array(

                          'qname'      => $tagName,

                          'attributes' => $attributes,

                          'content'    => $value

                        );

            $xml = $this->_createXMLTag($tag);

        }

        return $xml;

    }

    /**

     * serialize an array

     *

     * @param array  &$array     array to serialize

     * @param string $tagName    name of the root tag

     * @param array  $attributes attributes for the root tag

     *

     * @return string $string serialized data

     * @access private

     * @uses XML_Util::isValidName() to check, whether key has to be substituted

     * @uses XML_Util::replaceEntities()

     * @uses XML_Util::createComment()

     * @uses PEAR::popExpect()

     * @uses PEAR::expectError()

     */

    function _serializeArray(&$array, $tagName = null, $attributes = array())

    {

        $_content = null;

        $_comment = null;

        // check for comment

        if ($this->options[XML_SERIALIZER_OPTION_COMMENT_KEY] !== null) {

            if (isset($array[$this->options[XML_SERIALIZER_OPTION_COMMENT_KEY]])

            ) {

                $_comment =

                    $array[$this->options[XML_SERIALIZER_OPTION_COMMENT_KEY]];

                unset($array[$this->options[XML_SERIALIZER_OPTION_COMMENT_KEY]]);

            }

        }

        /**

         * check for special attributes

         */

        if ($this->options[XML_SERIALIZER_OPTION_ATTRIBUTES_KEY] !== null) {

            if (isset($array[$this->options[XML_SERIALIZER_OPTION_ATTRIBUTES_KEY]])

            ) {

                $attributes =

                    $array[$this->options[XML_SERIALIZER_OPTION_ATTRIBUTES_KEY]];

                unset($array[$this->options[XML_SERIALIZER_OPTION_ATTRIBUTES_KEY]]);

            }

            /**

             * check for special content

             */

            if ($this->options[XML_SERIALIZER_OPTION_CONTENT_KEY] !== null) {

                if (isset($array[$this->options[XML_SERIALIZER_OPTION_CONTENT_KEY]])

                ) {

                    $_content =

                        XML_Util::replaceEntities($array

                        [$this->options[XML_SERIALIZER_OPTION_CONTENT_KEY]]);

                    unset($array[$this->options[XML_SERIALIZER_OPTION_CONTENT_KEY]]);

                }

            }

        }

        if ($this->options[XML_SERIALIZER_OPTION_IGNORE_NULL] === true) {

            foreach (array_keys($array) as $key) {

                if (is_null($array[$key])) {

                    unset($array[$key]);

                }

            }

        }

        /*

        * if mode is set to simpleXML, check whether

        * the array is associative or indexed

        */

        if (is_array($array) && !empty($array)

            && $this->options[XML_SERIALIZER_OPTION_MODE]

            == XML_SERIALIZER_MODE_SIMPLEXML

        ) {

            $indexed = true;

            foreach ($array as $key => $val) {

                if (!is_int($key)) {

                    $indexed = false;

                    break;

                }

            }

            if ($indexed

                && $this->options[XML_SERIALIZER_OPTION_MODE]

                == XML_SERIALIZER_MODE_SIMPLEXML

            ) {

                $string = '';

                foreach ($array as $key => $val) {

                    $string .= $this->_serializeValue($val, $tagName, $attributes);

                    $string .= $this->options[XML_SERIALIZER_OPTION_LINEBREAKS];

                    // do indentation

                    if ($this->options[XML_SERIALIZER_OPTION_INDENT]!==null

                        && $this->_tagDepth>0

                    ) {

                        $string .=

                            str_repeat($this->options[XML_SERIALIZER_OPTION_INDENT],

                            $this->_tagDepth);

                    }

                }

                return rtrim($string);

            }

        }

        $scalarAsAttributes = false;

        if (is_array($this->options[XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES])

            && isset($this->options[XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES]

            [$tagName])

        ) {

            $scalarAsAttributes =

                $this->options[XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES][$tagName];

        } elseif ($this->options[XML_SERIALIZER_OPTION_SCALAR_AS_ATTRIBUTES] === true

        ) {

            $scalarAsAttributes = true;

        }

        if ($scalarAsAttributes === true) {

            $this->expectError('*');

            foreach ($array as $key => $value) {

                if (is_scalar($value) && (XML_Util::isValidName($key) === true)) {

                    unset($array[$key]);

                    $attributes[$this->options

                        [XML_SERIALIZER_OPTION_PREPEND_ATTRIBUTES].$key] = $value;

                }

            }

            $this->popExpect();

        } elseif (is_array($scalarAsAttributes)) {

            $this->expectError('*');

            foreach ($scalarAsAttributes as $key) {

                if (!isset($array[$key])) {

                    continue;

                }

                $value = $array[$key];

                if (is_scalar($value) && (XML_Util::isValidName($key) === true)) {

                    unset($array[$key]);

                    $attributes[$this->options

                        [XML_SERIALIZER_OPTION_PREPEND_ATTRIBUTES].$key] = $value;

                }

            }

            $this->popExpect();

        }

        // check for empty array => create empty tag

        if (empty($array)) {

            $tag = array(

                            'qname'      => $tagName,

                            'content'    => $_content,

                            'attributes' => $attributes

                        );

        } else {

            $this->_tagDepth++;

            $tmp = $_content . $this->options[XML_SERIALIZER_OPTION_LINEBREAKS];

            foreach ($array as $key => $value) {

                // do indentation

                if ($this->options[XML_SERIALIZER_OPTION_INDENT]!==null

                    && $this->_tagDepth>0

                ) {

                    $tmp .= str_repeat($this->options[XML_SERIALIZER_OPTION_INDENT],

                        $this->_tagDepth);

                }

                // copy key

                $origKey = $key;

                $this->expectError('*');

                // key cannot be used as tagname => use default tag

                $valid = XML_Util::isValidName($key);

                $this->popExpect();

                if (PEAR::isError($valid)) {

                    if ($this->options[XML_SERIALIZER_OPTION_CLASSNAME_AS_TAGNAME]