Static Public Member Functions
static	apiVersion ()
static	attributesToString ( $attributes, $sort=true, $multiline=false, $indent=' ', $linebreak="\n", $entities=XML_UTIL_ENTITIES_XML)
static	collapseEmptyTags ($xml, $mode=XML_UTIL_COLLAPSE_ALL)
static	createCDataSection ($data)
static	createComment ($content)
static	createEndElement ($qname)
static	createStartElement ( $qname, $attributes=array(), $namespaceUri=null, $multiline=false, $indent='_auto', $linebreak="\n", $sortAttributes=true)
static	createTag ( $qname, $attributes=array(), $content=null, $namespaceUri=null, $replaceEntities=XML_UTIL_REPLACE_ENTITIES, $multiline=false, $indent='_auto', $linebreak="\n", $sortAttributes=true, $collapseTagMode=XML_UTIL_COLLAPSE_ALL)
static	createTagFromArray ( $tag, $replaceEntities=XML_UTIL_REPLACE_ENTITIES, $multiline=false, $indent='_auto', $linebreak="\n", $sortAttributes=true, $collapseTagMode=XML_UTIL_COLLAPSE_ALL)
static	getDocTypeDeclaration ( $root, $uri=null, $internalDtd=null)
static	getXMLDeclaration ( $version='1.0', $encoding=null, $standalone=null)
static	isValidName ($string)
static	raiseError ($msg, $code)
static	replaceEntities ( $string, $replaceEntities=XML_UTIL_ENTITIES_XML, $encoding='ISO-8859-1')
static	reverseEntities ( $string, $replaceEntities=XML_UTIL_ENTITIES_XML, $encoding='ISO-8859-1')
static	splitQualifiedName ($qname, $defaultNs=null)

Detailed Description

Definition at line 126 of file Util.php.

Member Function Documentation

◆ apiVersion()

apiVersion ( )

static

Return API version

Returns: string $version API version

Definition at line 133 of file Util.php.

    {
        return '1.4';
    }

◆ attributesToString()

attributesToString	(	$attributes,
		$sort = true,
		$multiline = false,
		$indent = ' ',
		$linebreak = "\n",
		$entities = XML_UTIL_ENTITIES_XML )

static

Create string representation of an attribute list

require_once 'XML/Util.php';

// build an attribute string $att = array( 'foo' => 'bar', 'argh' => 'tomato' );

$attList = XML_Util\attributesToString($att);

Parameters

array	$attributes	attribute array
bool \| array	$sort	sort attribute list alphabetically, may also be an assoc array containing the keys 'sort', 'multiline', 'indent', 'linebreak' and 'entities'
bool	$multiline	use linebreaks, if more than one attribute is given
string	$indent	string used for indentation of multiline attributes
string	$linebreak	string used for linebreaks of multiline attributes
int	$entities	setting for entities in attribute values (one of XML_UTIL_ENTITIES_NONE, XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML)

Returns: string string representation of the attributes @uses replaceEntities() to replace XML entities in attribute values

Todo: allow sort also to be an options array

Definition at line 392 of file Util.php.

      {
        /*
         * second parameter may be an array
         */
        if (is_array($sort)) {
            if (isset($sort['multiline'])) {
                $multiline = $sort['multiline'];
            }
            if (isset($sort['indent'])) {
                $indent = $sort['indent'];
            }
            if (isset($sort['linebreak'])) {
                $multiline = $sort['linebreak'];
            }
            if (isset($sort['entities'])) {
                $entities = $sort['entities'];
            }
            if (isset($sort['sort'])) {
                $sort = $sort['sort'];
            } else {
                $sort = true;
            }
        }
        $string = '';
        if (is_array($attributes) && !empty($attributes)) {
            if ($sort) {
                ksort($attributes);
            }
            if (!$multiline || count($attributes) == 1) {
                foreach ($attributes as $key => $value) {
                    if ($entities != XML_UTIL_ENTITIES_NONE) {
                        if ($entities === XML_UTIL_CDATA_SECTION) {
                            $entities = XML_UTIL_ENTITIES_XML;
                        }
                        $value = XML_Util::replaceEntities($value, $entities);
                    }
                    $string .= ' ' . $key . '="' . $value . '"';
                }
            } else {
                $first = true;
                foreach ($attributes as $key => $value) {
                    if ($entities != XML_UTIL_ENTITIES_NONE) {
                        $value = XML_Util::replaceEntities($value, $entities);
                    }
                    if ($first) {
                        $string .= ' ' . $key . '="' . $value . '"';
                        $first   = false;
                    } else {
                        $string .= $linebreak . $indent . $key . '="' . $value . '"';
                    }
                }
            }
        }
        return $string;
    }

References replaceEntities(), XML_UTIL_CDATA_SECTION, XML_UTIL_ENTITIES_NONE, and XML_UTIL_ENTITIES_XML.

Referenced by createStartElement(), createTagFromArray(), and getXMLDeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collapseEmptyTags()

collapseEmptyTags	(		$xml,
			$mode = XML_UTIL_COLLAPSE_ALL )

static

Collapses empty tags.

Parameters

string	$xml	XML
int	$mode	Whether to collapse all empty tags (XML_UTIL_COLLAPSE_ALL) or only XHTML (XML_UTIL_COLLAPSE_XHTML_ONLY) ones.

Returns: string XML

Definition at line 460 of file Util.php.

    {
        if (preg_match('~<([^>])+/>~s', $xml, $matches)) {
            // it's already an empty tag
            return $xml;
        }
        switch ($mode) {
            case XML_UTIL_COLLAPSE_ALL:
                $preg1 =
                    '~<' .
                        '(?:' .
                            '(https?://[^:\s]+:\w+)' .  // <http://foo.com:bar  ($1)
                            '|(\w+:\w+)' .              // <foo:bar             ($2)
                            '|(\w+)' .                  // <foo                 ($3)
                        ')+' .
                        '([^>]*)' .                     // attributes           ($4)
                    '>' .
                    '<\/(\1|\2|\3)>' .                  // 1, 2, or 3 again     ($5)
                    '~s'
                ;
                $preg2 =
                    '<' .
                        '${1}${2}${3}' .    // tag (only one should have been populated)
                        '${4}' .            // attributes
                    ' />'
                ;
                return (preg_replace($preg1, $preg2, $xml)?:$xml);
                break;
            case XML_UTIL_COLLAPSE_XHTML_ONLY:
                return (
                    preg_replace(
                        '/<(area|base(?:font)?|br|col|frame|hr|img|input|isindex|link|meta|'
                        . 'param)([^>]*)><\/\\1>/s',
                        '<\\1\\2 />',
                        $xml
                    ) ?: $xml
                );
                break;
            case XML_UTIL_COLLAPSE_NONE:
                // fall thru
            default:
                return $xml;
        }
    }

References XML_UTIL_COLLAPSE_ALL, XML_UTIL_COLLAPSE_NONE, and XML_UTIL_COLLAPSE_XHTML_ONLY.

◆ createCDataSection()

createCDataSection ( $data )

static

Create a CData section

require_once 'XML/Util.php';

// create a CData section $tag = XML_Util\createCDataSection('I am content.');

Parameters

string $data data of the CData section

Returns: string CData section with content

Definition at line 847 of file Util.php.

    {
        return sprintf(
            '<![CDATA[%s]]>',
            preg_replace('/\‍]\‍]>/', ']]]]><![CDATA[>', strval($data))
        );
    }

Referenced by createTagFromArray().

Here is the caller graph for this function:

◆ createComment()

createComment ( $content )

static

Create an XML comment

require_once 'XML/Util.php';

// create an XML start element: $tag = XML_Util\createComment('I am a comment');

Parameters

string $content content of the comment

Returns: string XML comment

Definition at line 827 of file Util.php.

    {
        $comment = sprintf('<!-- %s -->', $content);
        return $comment;
    }

◆ createEndElement()

createEndElement ( $qname )

static

Create an end element

require_once 'XML/Util.php';

// create an XML start element: $tag = XML_Util\createEndElement('myNs:myTag');

Parameters

string $qname qualified tagname (including namespace)

Returns: string XML end element

See also: createStartElement(), createTag()

Definition at line 807 of file Util.php.

    {
        $element = sprintf('</%s>', $qname);
        return $element;
    }

◆ createStartElement()

createStartElement	(	$qname,
		$attributes = array(),
		$namespaceUri = null,
		$multiline = false,
		$indent = '_auto',
		$linebreak = "\n",
		$sortAttributes = true )

static

Create a start element

require_once 'XML/Util.php';

// create an XML start element: $tag = XML_Util\createStartElement('myNs:myTag', array('foo' => 'bar') ,'http://www.w3c.org/myNs#');

Parameters

string	$qname	qualified tagname (including namespace)
array	$attributes	array containg attributes
string	$namespaceUri	URI of the namespace
bool	$multiline	whether to create a multiline tag where each attribute gets written to a single line
string	$indent	string used to indent attributes (_auto indents attributes so they start at the same column)
string	$linebreak	string used for linebreaks
bool	$sortAttributes	Whether to sort the attributes or not

Returns: string XML start element

See also: createEndElement(), createTag()

Definition at line 752 of file Util.php.

      {
        // if no attributes hav been set, use empty attributes
        if (!isset($attributes) || !is_array($attributes)) {
            $attributes = array();
        }
 
        if ($namespaceUri != null) {
            $parts = XML_Util::splitQualifiedName($qname);
        }
 
        // check for multiline attributes
        if ($multiline === true) {
            if ($indent === '_auto') {
                $indent = str_repeat(' ', (strlen($qname)+2));
            }
        }
 
        if ($namespaceUri != null) {
            // is a namespace given
            if (isset($parts['namespace']) && !empty($parts['namespace'])) {
                $attributes['xmlns:' . $parts['namespace']] = $namespaceUri;
            } else {
                // define this Uri as the default namespace
                $attributes['xmlns'] = $namespaceUri;
            }
        }
 
        // create attribute list
        $attList = XML_Util::attributesToString(
            $attributes, $sortAttributes,
            $multiline, $indent, $linebreak
        );
        $element = sprintf('<%s%s>', $qname, $attList);
        return  $element;
    }

References attributesToString(), and splitQualifiedName().

Here is the call graph for this function:

◆ createTag()

createTag	(	$qname,
		$attributes = array(),
		$content = null,
		$namespaceUri = null,
		$replaceEntities = XML_UTIL_REPLACE_ENTITIES,
		$multiline = false,
		$indent = '_auto',
		$linebreak = "\n",
		$sortAttributes = true,
		$collapseTagMode = XML_UTIL_COLLAPSE_ALL )

static

Create a tag

This method will call XML_Util::createTagFromArray(), which is more flexible.

require_once 'XML/Util.php';

// create an XML tag: $tag = XML_Util\createTag('myNs:myTag', array('foo' => 'bar'), 'This is inside the tag', 'http://www.w3c.org/myNs#');

Parameters

string	$qname	qualified tagname (including namespace)
array	$attributes	array containg attributes
mixed	$content	the content
string	$namespaceUri	URI of the namespace
int	$replaceEntities	whether to replace XML special chars in content, embedd it in a CData section or none of both
bool	$multiline	whether to create a multiline tag where each attribute gets written to a single line
string	$indent	string used to indent attributes (_auto indents attributes so they start at the same column)
string	$linebreak	string used for linebreaks
bool	$sortAttributes	Whether to sort the attributes or not
int	$collapseTagMode	How to handle a content-less, and thus collapseable, tag

Returns: string XML tag

See also: createTagFromArray() @uses createTagFromArray() to create the tag

Definition at line 541 of file Util.php.

      {
        $tag = array(
            'qname'      => $qname,
            'attributes' => $attributes
        );
 
        // add tag content
        if ($content !== null) {
            $tag['content'] = $content;
        }
 
        // add namespace Uri
        if ($namespaceUri !== null) {
            $tag['namespaceUri'] = $namespaceUri;
        }
 
        return XML_Util::createTagFromArray(
            $tag, $replaceEntities, $multiline,
            $indent, $linebreak, $sortAttributes,
            $collapseTagMode
        );
    }

References createTagFromArray(), XML_UTIL_COLLAPSE_ALL, and XML_UTIL_REPLACE_ENTITIES.

Here is the call graph for this function:

◆ createTagFromArray()

createTagFromArray	(	$tag,
		$replaceEntities = XML_UTIL_REPLACE_ENTITIES,
		$multiline = false,
		$indent = '_auto',
		$linebreak = "\n",
		$sortAttributes = true,
		$collapseTagMode = XML_UTIL_COLLAPSE_ALL )

static

Create a tag from an array. This method awaits an array in the following format

array(
    // qualified name of the tag
    'qname' => $qname

    // namespace prefix (optional, if qname is specified or no namespace)
    'namespace' => $namespace

    // local part of the tagname (optional, if qname is specified)
    'localpart' => $localpart,

    // array containing all attributes (optional)
    'attributes' => array(),

    // tag content (optional)
    'content' => $content,

    // namespaceUri for the given namespace (optional)
    'namespaceUri' => $namespaceUri
)

require_once 'XML/Util.php';

$tag = array( 'qname' => 'foo:bar', 'namespaceUri' => 'http://foo.com', 'attributes' => array('key' => 'value', 'argh' => 'fruit&vegetable'), 'content' => 'I\'m inside the tag', ); // creating a tag with qualified name and namespaceUri $string = XML_Util\createTagFromArray($tag);

Parameters

array	$tag	tag definition
int	$replaceEntities	whether to replace XML special chars in content, embedd it in a CData section or none of both
bool	$multiline	whether to create a multiline tag where each attribute gets written to a single line
string	$indent	string used to indent attributes (_auto indents attributes so they start at the same column)
string	$linebreak	string used for linebreaks
bool	$sortAttributes	Whether to sort the attributes or not
int	$collapseTagMode	How to handle a content-less, and thus collapseable, tag

Returns: string XML tag

See also: createTag() @uses attributesToString() to serialize the attributes of the tag @uses splitQualifiedName() to get local part and namespace of a qualified name @uses createCDataSection() @uses collapseEmptyTags() @uses raiseError()

Definition at line 629 of file Util.php.

      {
        if (isset($tag['content']) && !is_scalar($tag['content'])) {
            return XML_Util::raiseError(
                'Supplied non-scalar value as tag content',
                XML_UTIL_ERROR_NON_SCALAR_CONTENT
            );
        }
 
        if (!isset($tag['qname']) && !isset($tag['localPart'])) {
            return XML_Util::raiseError(
                'You must either supply a qualified name '
                . '(qname) or local tag name (localPart).',
                XML_UTIL_ERROR_NO_TAG_NAME
            );
        }
 
        // if no attributes hav been set, use empty attributes
        if (!isset($tag['attributes']) || !is_array($tag['attributes'])) {
            $tag['attributes'] = array();
        }
 
        if (isset($tag['namespaces'])) {
            foreach ($tag['namespaces'] as $ns => $uri) {
                $tag['attributes']['xmlns:' . $ns] = $uri;
            }
        }
 
        if (!isset($tag['qname'])) {
            // qualified name is not given
 
            // check for namespace
            if (isset($tag['namespace']) && !empty($tag['namespace'])) {
                $tag['qname'] = $tag['namespace'] . ':' . $tag['localPart'];
            } else {
                $tag['qname'] = $tag['localPart'];
            }
        } elseif (isset($tag['namespaceUri']) && !isset($tag['namespace'])) {
            // namespace URI is set, but no namespace
 
            $parts = XML_Util::splitQualifiedName($tag['qname']);
 
            $tag['localPart'] = $parts['localPart'];
            if (isset($parts['namespace'])) {
                $tag['namespace'] = $parts['namespace'];
            }
        }
 
        if (isset($tag['namespaceUri']) && !empty($tag['namespaceUri'])) {
            // is a namespace given
            if (isset($tag['namespace']) && !empty($tag['namespace'])) {
                $tag['attributes']['xmlns:' . $tag['namespace']]
                    = $tag['namespaceUri'];
            } else {
                // define this Uri as the default namespace
                $tag['attributes']['xmlns'] = $tag['namespaceUri'];
            }
        }
 
        if (!array_key_exists('content', $tag)) {
            $tag['content'] = '';
        }
 
        // check for multiline attributes
        if ($multiline === true) {
            if ($indent === '_auto') {
                $indent = str_repeat(' ', (strlen($tag['qname'])+2));
            }
        }
 
        // create attribute list
        $attList = XML_Util::attributesToString(
            $tag['attributes'],
            $sortAttributes, $multiline, $indent, $linebreak
        );
 
        switch ($replaceEntities) {
        case XML_UTIL_ENTITIES_NONE:
            break;
        case XML_UTIL_CDATA_SECTION:
            $tag['content'] = XML_Util::createCDataSection($tag['content']);
            break;
        default:
            $tag['content'] = XML_Util::replaceEntities(
                $tag['content'], $replaceEntities
            );
            break;
        }
        $tag = sprintf(
            '<%s%s>%s</%s>', $tag['qname'], $attList, $tag['content'],
            $tag['qname']
        );
 
        return self::collapseEmptyTags($tag, $collapseTagMode);
    }

References attributesToString(), createCDataSection(), raiseError(), replaceEntities(), splitQualifiedName(), XML_UTIL_CDATA_SECTION, XML_UTIL_COLLAPSE_ALL, XML_UTIL_ENTITIES_NONE, XML_UTIL_ERROR_NO_TAG_NAME, XML_UTIL_ERROR_NON_SCALAR_CONTENT, and XML_UTIL_REPLACE_ENTITIES.

Referenced by createTag().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getDocTypeDeclaration()

getDocTypeDeclaration	(	$root,
		$uri = null,
		$internalDtd = null )

static

Build a document type declaration

require_once 'XML/Util.php';

// get a doctype declaration: $xmlDecl = XML_Util\getDocTypeDeclaration('rootTag','myDocType.dtd');

Parameters

string	$root	name of the root tag
string	$uri	uri of the doctype definition (or array with uri and public id)
string	$internalDtd	internal dtd entries

Returns: string doctype declaration

Since: 0.2

Definition at line 338 of file Util.php.

      {
        if (is_array($uri)) {
            $ref = sprintf(' PUBLIC "%s" "%s"', $uri['id'], $uri['uri']);
        } elseif (!empty($uri)) {
            $ref = sprintf(' SYSTEM "%s"', $uri);
        } else {
            $ref = '';
        }
 
        if (empty($internalDtd)) {
            return sprintf('<!DOCTYPE %s%s>', $root, $ref);
        } else {
            return sprintf("<!DOCTYPE %s%s [\n%s\n]>", $root, $ref, $internalDtd);
        }
    }

◆ getXMLDeclaration()

getXMLDeclaration	(	$version = '1.0',
		$encoding = null,
		$standalone = null )

static

Build an xml declaration

require_once 'XML/Util.php';

// get an XML declaration: $xmlDecl = XML_Util\getXMLDeclaration('1.0', 'UTF-8', true);

Parameters

string	$version	xml version
string	$encoding	character encoding
bool	$standalone	document is standalone (or not)

Returns: string xml declaration @uses attributesToString() to serialize the attributes of the XML declaration

Definition at line 299 of file Util.php.

      {
        $attributes = array(
            'version' => $version,
        );
        // add encoding
        if ($encoding !== null) {
            $attributes['encoding'] = $encoding;
        }
        // add standalone, if specified
        if ($standalone !== null) {
            $attributes['standalone'] = $standalone ? 'yes' : 'no';
        }
 
        return sprintf(
            '<?xml%s?>',
            XML_Util::attributesToString($attributes, false)
        );
    }

References attributesToString().

Here is the call graph for this function:

◆ isValidName()

isValidName ( $string )

static

Check, whether string is valid XML name

XML names are used for tagname, attribute names and various other, lesser known entities.

An XML name may only consist of alphanumeric characters, dashes, undescores and periods, and has to start with a letter or an underscore.

require_once 'XML/Util.php';

// verify tag name $result = XML_Util\isValidName('invalidTag?'); if (is_a($result, 'PEAR_Error')) { print 'Invalid XML name: ' . $result->getMessage(); }

Parameters

string $string string that should be checked

Returns: mixed true, if string is a valid XML name, PEAR error otherwise

Todo

support for other charsets

PEAR CS - unable to avoid 85-char limit on second preg_match

Definition at line 918 of file Util.php.

    {
        // check for invalid chars
        if (!is_string($string) || !strlen($string) || !preg_match('/^[[:alpha:]_]\\z/', $string[0])) {
            return XML_Util::raiseError(
                'XML names may only start with letter or underscore',
                XML_UTIL_ERROR_INVALID_START
            );
        }
 
        // check for invalid chars
        $match = preg_match(
            '/^([[:alpha:]_]([[:alnum:]\-\.]*)?:)?'
            . '[[:alpha:]_]([[:alnum:]\_\-\.]+)?\\z/',
            $string
        );
        if (!$match) {
            return XML_Util::raiseError(
                'XML names may only contain alphanumeric '
                . 'chars, period, hyphen, colon and underscores',
                XML_UTIL_ERROR_INVALID_CHARS
            );
        }
        // XML name is valid
        return true;
    }

References raiseError(), XML_UTIL_ERROR_INVALID_CHARS, and XML_UTIL_ERROR_INVALID_START.

Here is the call graph for this function:

◆ raiseError()

raiseError	(		$msg,
			$code )

static

Replacement for XML_Util\raiseError

Avoids the necessity to always require PEAR.php

Parameters

string	$msg	error message
int	$code	error code

Returns: PEAR_Error

Todo: PEAR CS - should this use include_once instead?

Definition at line 957 of file Util.php.

    {
        include_once 'PEAR.php';
        return PEAR::raiseError($msg, $code);
    }

Referenced by createTagFromArray(), and isValidName().

Here is the caller graph for this function:

◆ replaceEntities()

replaceEntities	(	$string,
		$replaceEntities = XML_UTIL_ENTITIES_XML,
		$encoding = 'ISO-8859-1' )

static

Replace XML entities

With the optional second parameter, you may select, which entities should be replaced.

require_once 'XML/Util.php';

// replace XML entites: $string = XML_Util\replaceEntities('This string contains < & >.');

With the optional third parameter, you may pass the character encoding require_once 'XML/Util.php';

// replace XML entites in UTF-8: $string = XML_Util\replaceEntities( 'This string contains < & > as well as ä, ö, ß, à and ê', XML_UTIL_ENTITIES_HTML, 'UTF-8' );

Parameters

string	$string	string where XML special chars should be replaced
int	$replaceEntities	setting for entities in attribute values (one of XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML)
string	$encoding	encoding value (if any)... must be a valid encoding as determined by the htmlentities() function

Returns: string string with replaced chars

See also: reverseEntities()

Definition at line 176 of file Util.php.

      {
        switch ($replaceEntities) {
        case XML_UTIL_ENTITIES_XML:
            return strtr(
                $string,
                array(
                    '&'  => '&amp;',
                    '>'  => '&gt;',
                    '<'  => '&lt;',
                    '"'  => '&quot;',
                    '\'' => '&apos;'
                )
            );
            break;
        case XML_UTIL_ENTITIES_XML_REQUIRED:
            return strtr(
                $string,
                array(
                    '&' => '&amp;',
                    '<' => '&lt;',
                    '"' => '&quot;'
                )
            );
            break;
        case XML_UTIL_ENTITIES_HTML:
            return htmlentities($string, ENT_COMPAT, $encoding);
            break;
        }
        return $string;
    }

References XML_UTIL_ENTITIES_HTML, XML_UTIL_ENTITIES_XML, and XML_UTIL_ENTITIES_XML_REQUIRED.

Referenced by attributesToString(), and createTagFromArray().

Here is the caller graph for this function:

◆ reverseEntities()

reverseEntities	(	$string,
		$replaceEntities = XML_UTIL_ENTITIES_XML,
		$encoding = 'ISO-8859-1' )

static

Reverse XML entities

With the optional second parameter, you may select, which entities should be reversed.

require_once 'XML/Util.php';

// reverse XML entites: $string = XML_Util\reverseEntities('This string contains < & >.');

With the optional third parameter, you may pass the character encoding require_once 'XML/Util.php';

// reverse XML entites in UTF-8: $string = XML_Util\reverseEntities( 'This string contains < & > as well as' . ' ä, ö, ß, à and ê', XML_UTIL_ENTITIES_HTML, 'UTF-8' );

Parameters

string	$string	string where XML special chars should be replaced
int	$replaceEntities	setting for entities in attribute values (one of XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML)
string	$encoding	encoding value (if any)... must be a valid encoding as determined by the html_entity_decode() function

Returns: string string with replaced chars

See also: replaceEntities()

Definition at line 248 of file Util.php.

      {
        switch ($replaceEntities) {
        case XML_UTIL_ENTITIES_XML:
            return strtr(
                $string,
                array(
                    '&amp;'  => '&',
                    '&gt;'   => '>',
                    '&lt;'   => '<',
                    '&quot;' => '"',
                    '&apos;' => '\''
                )
            );
            break;
        case XML_UTIL_ENTITIES_XML_REQUIRED:
            return strtr(
                $string,
                array(
                    '&amp;'  => '&',
                    '&lt;'   => '<',
                    '&quot;' => '"'
                )
            );
            break;
        case XML_UTIL_ENTITIES_HTML:
            return html_entity_decode($string, ENT_COMPAT, $encoding);
            break;
        }
        return $string;
    }

References XML_UTIL_ENTITIES_HTML, XML_UTIL_ENTITIES_XML, and XML_UTIL_ENTITIES_XML_REQUIRED.

◆ splitQualifiedName()

splitQualifiedName	(		$qname,
			$defaultNs = null )

static

Split qualified name and return namespace and local part

require_once 'XML/Util.php';

// split qualified tag $parts = XML_Util\splitQualifiedName('xslt:stylesheet'); the returned array will contain two elements:

array(
    'namespace' => 'xslt',
    'localPart' => 'stylesheet'
);

Parameters

string	$qname	qualified tag name
string	$defaultNs	default namespace (optional)

Returns: array array containing namespace and local part

Definition at line 877 of file Util.php.

    {
        if (strstr($qname, ':')) {
            $tmp = explode(':', $qname);
            return array(
                'namespace' => $tmp[0],
                'localPart' => $tmp[1]
            );
        }
        return array(
            'namespace' => $defaultNs,
            'localPart' => $qname
        );
    }

Referenced by createStartElement(), and createTagFromArray().

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

E:/Bearsampp-development/sandbox/core/libs/php/pear/pear/XML/Util.php

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ apiVersion()

◆ attributesToString()

◆ collapseEmptyTags()

◆ createCDataSection()

◆ createComment()

◆ createEndElement()

◆ createStartElement()

◆ createTag()

◆ createTagFromArray()

◆ getDocTypeDeclaration()

◆ getXMLDeclaration()

◆ isValidName()

◆ raiseError()

◆ replaceEntities()

◆ reverseEntities()

◆ splitQualifiedName()