Adds an element tag beneath the parent and takes care
of the type (XMLSchema type or complexType).

@param string The datatype
@param string Name of the element
@param domNode The parent domNode
@param bool If the property is optional

@return domNode
190434
protected function addTypeElement($type, $name, $parent, $optional = false)
    {
        $el = $this->addElement('xsd:element', $parent);
        if ($optional) {
            //if it's an optional property, set minOccur to 0
            $el->setAttribute('minOccurs', '0');
            $el->setAttribute('maxOccurs', '1');
        }
        $this->addType($type, $name, $el);

        return $el;
    }
1289669
public function writeXml(DOMDocument $dom = null)
    {
        if (null === $dom) {
            $imp = new DOMImplementation();
            $dtd  = $imp->createDocumentType(
                static::DOCUMENT_TYPE_QUALIFIED_NAME,
                static::DOCUMENT_TYPE_PUBLIC_ID,
                static::DOCUMENT_TYPE_SYSTEM_ID
            );
            $dom = $imp->createDocument('', '', $dtd);
            $dom->encoding = 'UTF-8';
            $dom->xmlVersion = '1.0';
            $dom->formatOutput = true;
        }

        $descriptor = $dom->createElement('workflow');

        $metaAttributes = $this->getMetaAttributes();
        $metaElementBase = $dom->createElement('meta');
        foreach ($metaAttributes as $metaAttributeName => $metaAttributeValue) {
            $metaAttributeNameEncode = XmlUtil::encode($metaAttributeName);
            $metaAttributeValueEnEncode = XmlUtil::encode($metaAttributeValue);

            $metaElement = clone $metaElementBase;
            $metaElement->setAttribute('name', $metaAttributeNameEncode);
            $metaValueElement = $dom->createTextNode($metaAttributeValueEnEncode);
            $metaElement->appendChild($metaValueElement);

            $descriptor->appendChild($metaElement);
        }

        $registers = $this->getRegisters();
        if ($registers->count() > 0) {
            $registersElement = $dom->createElement('registers');
            foreach ($registers as $register) {
                $registerElement = $register->writeXml($dom);
                $registersElement->appendChild($registerElement);
            }

            $descriptor->appendChild($registersElement);
        }


        $timerFunctions = $this->getTriggerFunctions();
        if (count($timerFunctions) > 0) {
            $timerFunctionsElement = $dom->createElement('trigger-functions');
            $timerFunctionElementBase = $dom->createElement('trigger-function');
            foreach ($timerFunctions as $timerFunctionId => $timerFunction) {
                $timerFunctionElement = clone $timerFunctionElementBase;
                $timerFunctionElement->setAttribute('id', $timerFunctionId);

                $functionElement = $timerFunction->writeXml($dom);

                $timerFunctionElement->appendChild($functionElement);

                $timerFunctionsElement->appendChild($timerFunctionElement);
            }
            $descriptor->appendChild($timerFunctionsElement);
        }


        $globalConditions = $this->getGlobalConditions();
        if (null !== $globalConditions) {
            $globalConditionsElement = $dom->createElement('global-conditions');
            $globalConditionElement = $globalConditions->writeXml($dom);
            $globalConditionsElement->appendChild($globalConditionElement);
            $descriptor->appendChild($globalConditionsElement);
        }


        $initialActionsElement = $dom->createElement('initial-actions');
        $initialActions = $this->getInitialActions();
        foreach ($initialActions as $initialAction) {
            $initialActionElement = $initialAction->writeXml($dom);
            $initialActionsElement->appendChild($initialActionElement);
        }
        $descriptor->appendChild($initialActionsElement);


        $globalActions = $this->getGlobalActions();
        if ($globalActions->count() > 0) {
            $globalActionsElement = $dom->createElement('global-actions');
            foreach ($globalActions as $globalAction) {
                $globalActionElement = $globalAction->writeXml($dom);

                $globalActionsElement->appendChild($globalActionElement);
            }

            $descriptor->appendChild($globalActionsElement);
        }

        $commonActions = $this->getCommonActions();
        if (count($commonActions) > 0) {
            $commonActionsElement = $dom->createElement('common-actions');
            foreach ($commonActions as $commonAction) {
                $commonActionElement = $commonAction->writeXml($dom);
                $commonActionsElement->appendChild($commonActionElement);
            }

            $descriptor->appendChild($commonActionsElement);
        }


        $stepsElement = $dom->createElement('steps');
        $steps = $this->getSteps();
        foreach ($steps as $step) {
            $stepElement = $step->writeXml($dom);
            $stepsElement->appendChild($stepElement);
        }

        $descriptor->appendChild($stepsElement);

        $splits = $this->getSplits();
        if ($splits->count() > 0) {
            $splitsElement = $dom->createElement('splits');
            foreach ($splits as $split) {
                $splitElement = $split->writeXml($dom);
                $splitsElement->appendChild($splitElement);
            }

            $descriptor->appendChild($splitsElement);
        }

        $joins = $this->getJoins();
        if ($joins->count() > 0) {
            $joinsElement = $dom->createElement('joins');
            foreach ($joins as $join) {
                $joinElement = $join->writeXml($dom);
                $joinsElement->appendChild($joinElement);
            }

            $descriptor->appendChild($joinsElement);
        }

        $dom->appendChild($descriptor);
        return $dom;
    }
630582
protected function addTypes(TagDescriptor $tag, \DOMElement $child)
    {
        $typeString = '';

        if ($tag instanceof TypedAbstract) {
            $types = $tag->getType();

            if ($types instanceof \IteratorAggregate) {
                foreach ($types as $type) {
                    $typeString .= $type . '|';

                    /** @var \DOMElement $typeNode */
                    $typeNode = $child->appendChild(new \DOMElement('type'));
                    $typeNode->appendChild(new \DOMText((string) $type));
                }
            } else {
                $typeString .= $types . '|';

                /** @var \DOMElement $typeNode */
                $typeNode = $child->appendChild(new \DOMElement('type'));
                $typeNode->appendChild(new \DOMText((string) $types));
            }

            $child->setAttribute('type', str_replace('&', '&amp;', rtrim($typeString, '|')));
        }
    }
392062
public static Node addChildNode(Document doc, Node parentNode, String childName, String childValue){
                if(doc == null || parentNode == null || childName == null){
                        return null;
                }
                Node childNode = doc.createElement(childName);
                if(childValue != null){
                        childNode.setTextContent(childValue);
                }
                parentNode.appendChild(childNode);
                return childNode;
        }
927443
function XmlCommon() {
    //constants
    this.DOM_ELEMENT_NODE = 1;
    this.DOM_ATTRIBUTE_NODE = 2;
    this.DOM_TEXT_NODE = 3;
    this.DOM_CDATA_SECTION_NODE = 4;
    // noinspection JSUnusedGlobalSymbols
    this.DOM_ENTITY_REFERENCE_NODE = 5;
    // noinspection JSUnusedGlobalSymbols
    this.DOM_ENTITY_NODE = 6;
    this.DOM_PROCESSING_INSTRUCTION_NODE = 7;
    this.DOM_COMMENT_NODE = 8;
    this.DOM_DOCUMENT_NODE = 9;
    // noinspection JSUnusedGlobalSymbols
    this.DOM_DOCUMENT_TYPE_NODE = 10;
    this.DOM_DOCUMENT_FRAGMENT_NODE = 11;
    // noinspection JSUnusedGlobalSymbols
    this.DOM_NOTATION_NODE = 12;

    this.REGEXP_UNICODE = function () {
        var tests = [' ', '\u0120', -1,  // Konquerer 3.4.0 fails here.
            '!', '\u0120', -1,
            '\u0120', '\u0120', 0,
            '\u0121', '\u0120', -1,
            '\u0121', '\u0120|\u0121', 0,
            '\u0122', '\u0120|\u0121', -1,
            '\u0120', '[\u0120]', 0,  // Safari 2.0.3 fails here.
            '\u0121', '[\u0120]', -1,
            '\u0121', '[\u0120\u0121]', 0,  // Safari 2.0.3 fails here.
            '\u0122', '[\u0120\u0121]', -1,
            '\u0121', '[\u0120-\u0121]', 0,  // Safari 2.0.3 fails here.
            '\u0122', '[\u0120-\u0121]', -1];
        for (var i = 0; i < tests.length; i += 3) {
            if (tests[i].search(new RegExp(tests[i + 1])) !== tests[i + 2]) {
                return false;
            }
        }
        return true;
    }();

    this.XML_S = '[ \t\r\n]+';
    this.XML_EQ = '(' + this.XML_S + ')?=(' + this.XML_S + ')?';
    this.XML_CHAR_REF = '&#[0-9]+;|&#x[0-9a-fA-F]+;';

    // XML 1.0 tokens.

    this.XML10_VERSION_INFO = this.XML_S + 'version' + this.XML_EQ + '("1\\.0"|' + "'1\\.0')";
    this.XML10_BASE_CHAR = (this.REGEXP_UNICODE) ?
        '\u0041-\u005a\u0061-\u007a\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u00ff' +
        '\u0100-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3' +
        '\u01cd-\u01f0\u01f4-\u01f5\u01fa-\u0217\u0250-\u02a8\u02bb-\u02c1\u0386' +
        '\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03d6\u03da\u03dc' +
        '\u03de\u03e0\u03e2-\u03f3\u0401-\u040c\u040e-\u044f\u0451-\u045c' +
        '\u045e-\u0481\u0490-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04d0-\u04eb' +
        '\u04ee-\u04f5\u04f8-\u04f9\u0531-\u0556\u0559\u0561-\u0586\u05d0-\u05ea' +
        '\u05f0-\u05f2\u0621-\u063a\u0641-\u064a\u0671-\u06b7\u06ba-\u06be' +
        '\u06c0-\u06ce\u06d0-\u06d3\u06d5\u06e5-\u06e6\u0905-\u0939\u093d' +
        '\u0958-\u0961\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2' +
        '\u09b6-\u09b9\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u0a05-\u0a0a' +
        '\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36' +
        '\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8b\u0a8d' +
        '\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9' +
        '\u0abd\u0ae0\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30' +
        '\u0b32-\u0b33\u0b36-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b85-\u0b8a' +
        '\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4' +
        '\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0c05-\u0c0c\u0c0e-\u0c10' +
        '\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c60-\u0c61\u0c85-\u0c8c' +
        '\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cde\u0ce0-\u0ce1' +
        '\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d60-\u0d61' +
        '\u0e01-\u0e2e\u0e30\u0e32-\u0e33\u0e40-\u0e45\u0e81-\u0e82\u0e84' +
        '\u0e87-\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5' +
        '\u0ea7\u0eaa-\u0eab\u0ead-\u0eae\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4' +
        '\u0f40-\u0f47\u0f49-\u0f69\u10a0-\u10c5\u10d0-\u10f6\u1100\u1102-\u1103' +
        '\u1105-\u1107\u1109\u110b-\u110c\u110e-\u1112\u113c\u113e\u1140\u114c' +
        '\u114e\u1150\u1154-\u1155\u1159\u115f-\u1161\u1163\u1165\u1167\u1169' +
        '\u116d-\u116e\u1172-\u1173\u1175\u119e\u11a8\u11ab\u11ae-\u11af' +
        '\u11b7-\u11b8\u11ba\u11bc-\u11c2\u11eb\u11f0\u11f9\u1e00-\u1e9b' +
        '\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d' +
        '\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc' +
        '\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec' +
        '\u1ff2-\u1ff4\u1ff6-\u1ffc\u2126\u212a-\u212b\u212e\u2180-\u2182' +
        '\u3041-\u3094\u30a1-\u30fa\u3105-\u312c\uac00-\ud7a3' :
        'A-Za-z';
    this.XML10_IDEOGRAPHIC = (this.REGEXP_UNICODE) ?
        '\u4e00-\u9fa5\u3007\u3021-\u3029' :
        '';
    this.XML10_COMBINING_CHAR = (this.REGEXP_UNICODE) ?
        '\u0300-\u0345\u0360-\u0361\u0483-\u0486\u0591-\u05a1\u05a3-\u05b9' +
        '\u05bb-\u05bd\u05bf\u05c1-\u05c2\u05c4\u064b-\u0652\u0670\u06d6-\u06dc' +
        '\u06dd-\u06df\u06e0-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0901-\u0903\u093c' +
        '\u093e-\u094c\u094d\u0951-\u0954\u0962-\u0963\u0981-\u0983\u09bc\u09be' +
        '\u09bf\u09c0-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u0a02' +
        '\u0a3c\u0a3e\u0a3f\u0a40-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a70-\u0a71' +
        '\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0b01-\u0b03' +
        '\u0b3c\u0b3e-\u0b43\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b82-\u0b83' +
        '\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c01-\u0c03\u0c3e-\u0c44' +
        '\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c82-\u0c83\u0cbe-\u0cc4' +
        '\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0d02-\u0d03\u0d3e-\u0d43' +
        '\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1' +
        '\u0eb4-\u0eb9\u0ebb-\u0ebc\u0ec8-\u0ecd\u0f18-\u0f19\u0f35\u0f37\u0f39' +
        '\u0f3e\u0f3f\u0f71-\u0f84\u0f86-\u0f8b\u0f90-\u0f95\u0f97\u0f99-\u0fad' +
        '\u0fb1-\u0fb7\u0fb9\u20d0-\u20dc\u20e1\u302a-\u302f\u3099\u309a' :
        '';
    this.XML10_DIGIT = (this.REGEXP_UNICODE) ?
        '\u0030-\u0039\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\u09e6-\u09ef' +
        '\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be7-\u0bef\u0c66-\u0c6f' +
        '\u0ce6-\u0cef\u0d66-\u0d6f\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29' :
        '0-9';
    this.XML10_EXTENDER = (this.REGEXP_UNICODE) ?
        '\u00b7\u02d0\u02d1\u0387\u0640\u0e46\u0ec6\u3005\u3031-\u3035' +
        '\u309d-\u309e\u30fc-\u30fe' :
        '';
    this.XML10_LETTER = this.XML10_BASE_CHAR + this.XML10_IDEOGRAPHIC;
    this.XML10_NAME_CHAR = this.XML10_LETTER + this.XML10_DIGIT + '\\._:' +
        this.XML10_COMBINING_CHAR + this.XML10_EXTENDER + '-';
    this.XML10_NAME = '[' + this.XML10_LETTER + '_:][' + this.XML10_NAME_CHAR + ']*';

    this.XML10_ENTITY_REF = '&' + this.XML10_NAME + ';';
    this.XML10_REFERENCE = this.XML10_ENTITY_REF + '|' + this.XML_CHAR_REF;
    this.XML10_ATT_VALUE = '"(([^<&"]|' + this.XML10_REFERENCE + ')*)"|' +
        "'(([^<&']|" + this.XML10_REFERENCE + ")*)'";
    this.XML10_ATTRIBUTE =
        '(' + this.XML10_NAME + ')' + this.XML_EQ + '(' + this.XML10_ATT_VALUE + ')';

    // XML 1.1 tokens.

    this.XML11_VERSION_INFO = this.XML_S + 'version' + this.XML_EQ + '("1\\.1"|' + "'1\\.1')";
    this.XML11_NAME_START_CHAR = (this.REGEXP_UNICODE) ?
        ':A-Z_a-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02ff\u0370-\u037d' +
        '\u037f-\u1fff\u200c-\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff' +
        '\uf900-\ufdcf\ufdf0-\ufffd' :
        ':A-Z_a-z';
    this.XML11_NAME_CHAR = this.XML11_NAME_START_CHAR +
        ((this.REGEXP_UNICODE) ? '\\.0-9\u00b7\u0300-\u036f\u203f-\u2040-' : '\\.0-9-');
    this.XML11_NAME = '[' + this.XML11_NAME_START_CHAR + '][' + this.XML11_NAME_CHAR + ']*';

    this.XML11_ENTITY_REF = '&' + this.XML11_NAME + ';';
    this.XML11_REFERENCE = this.XML11_ENTITY_REF + '|' + this.XML_CHAR_REF;
    this.XML11_ATT_VALUE = '"(([^<&"]|' + this.XML11_REFERENCE + ')*)"|' +
        "'(([^<&']|" + this.XML11_REFERENCE + ")*)'";
    this.XML11_ATTRIBUTE =
        '(' + this.XML11_NAME + ')' + this.XML_EQ + '(' + this.XML11_ATT_VALUE + ')';

    // XML namespace tokens.
    // Used in XML parser and XPath parser.

    this.XML_NC_NAME_CHAR = this.XML10_LETTER + this.XML10_DIGIT + '\\._' +
        this.XML10_COMBINING_CHAR + this.XML10_EXTENDER + '-';
    this.XML_NC_NAME = '[' + this.XML10_LETTER + '_][' + this.XML_NC_NAME_CHAR + ']*';

    this.XML10_TAGNAME_REGEXP = new RegExp('^(' + this.XML10_NAME + ')');
    this.XML10_ATTRIBUTE_REGEXP = new RegExp(this.XML10_ATTRIBUTE, 'g');
    this.XML11_TAGNAME_REGEXP = new RegExp('^(' + this.XML11_NAME + ')');
    this.XML11_ATTRIBUTE_REGEXP = new RegExp(this.XML11_ATTRIBUTE, 'g');


}
1187134
private static function createTypeElement(\DOMDocument $document, $parentElement = null, $type)
    {
        if ($parentElement->parentNode === null) {
            $typeElement = $document->createElementNS(
                'https://github.com/RhubarbPHP/Rhubarb/blob/master/docs/simple-xml-transcoder.md',
                self::XMLNS . ':' . $type
            );
            $parentElement->appendChild($typeElement);
        } else {
            $parentElement->setAttribute(self::XMLNS . ':' . self::ATTR_TYPE, $type);
            $typeElement = $parentElement;
        }

        return $typeElement;
    }
1350832
private function addNewXmlElement(DOMDocument $dom, DOMElement $node, $name, $value)
    {
        $new = $dom->createElement($name);
        $new->appendChild($dom->createTextNode($value));
        $node->appendChild($new);
    }
279195
public XElement add(String name) {
        XElement result = new XElement(name);
        result.parent = this;
        children.add(result);
        return result;
    }
274976
function XmlNode(name, children) {
    if (children === void 0) { children = []; }
    this.name = name;
    this.children = children;
    this.attributes = {};
}
324048
public function AddAttribute( $prefix, $name, $parentType = "xs:anySimpleType" )
	{
		$attribute = array();

		$parts = explode( ":", $parentType );
		$parentLocalName = count( $parts ) == 1 ? $parts[0] : $parts[1];
		// BMS 2018-04-09 Fixing the kluge
		$parentPrefix = count( $parts ) == 1 ? SCHEMA_PREFIX : $parts[0];

		$type = $this->getType( $parentLocalName, $parentPrefix );
		if ( ! $type )
		{
			return false;
		}

		$attribute['types'][] = $type;

		$attribute += array(
			'name' => $name,
			'prefix' => $prefix,
			'use' => "optional",
			'class' => 'attribute',
		);

		$this->attributes[ "$prefix:$name"] = $attribute;

		return $this->attributes[ "$prefix:$name"];
	}
197979
private function addNewNotEmptyXmlElement(DOMDocument $dom, DOMElement $node, $name, $value)
    {
        if (!empty($value)) {
            $this->addNewXmlElement($dom, $node, $name, $value);
        }
    }
350952
public function createElement(Node $parent, $name)
    {
        if (array_key_exists($name, $this->elementMap)) {
            $class = $this->elementMap[$name];

            return new $class($parent);
        }

        return null;
    }
1055732
function node(name, attributes) {
    "use strict";
    var _node   = document.createElementNS('', name);
    for (var attrName in attributes) {
        var value = attributes[attrName];
        if (attributes.hasOwnProperty(attrName) && isString(attrName)) {
            _node.setAttribute(attrName, value);
        }
    }
    return _node;
}
314133
private function buildXml($data, \DOMDocument $doc, \DOMNode $parentNode = null)
    {
        if (is_array($data)) {
            foreach ($data as $elementName => $element) {
                if (is_int($elementName)) {
                    $elementName = 'item';
                }

                $newElement = $doc->createElement($elementName);

                if ($parentNode) {
                    $parentNode->appendChild($newElement);
                } else {
                    $doc->appendChild($newElement);
                }

                $this->buildXml($element, $doc, $newElement);
            }
        } else {
            $parentNode->nodeValue = $data;
        }
    }
912568
function processBySchemaPresence( $element )
    {
        $parent = $element->parentNode;
        if ( $parent instanceof DOMElement )
        {
            // If this is a foreign element, remove it
            if ( !$this->XMLSchema->exists( $element ) )
            {
                if ( $element->nodeName == 'custom' )
                {
                    $this->handleError( self::ERROR_SCHEMA,
                                        ezpI18n::tr( 'kernel/classes/datatypes/ezxmltext', "Custom tag '%1' is not allowed.",
                                        false, array( $element->getAttribute( 'name' ) ) ) );
                }
                $element = $parent->removeChild( $element );
                return false;
            }

            // Delete if children required and no children
            // If this is an auto-added element, then do not throw error

            if ( $element->nodeType == XML_ELEMENT_NODE && ( $this->XMLSchema->childrenRequired( $element ) || $element->getAttribute( 'children_required' ) )
                 && !$element->hasChildNodes() )
            {
                $element = $parent->removeChild( $element );
                if ( !$element->getAttributeNS( 'http://ez.no/namespaces/ezpublish3/temporary/', 'new-element' ) )
                {
                    $this->handleError( self::ERROR_SCHEMA, ezpI18n::tr( 'kernel/classes/datatypes/ezxmltext', "&lt;%1&gt; tag can't be empty.",
                                        false, array( $element->nodeName ) ) );
                    return false;
                }
            }
        }
        // TODO: break processing of any node that doesn't have parent
        //       and is not a root node.
        elseif ( $element->nodeName != 'section' )
        {
            return false;
        }
        return true;
    }
1139674
private function createTextNodeWithTypeAttribute(\DOMDocument $dom, \DOMNode $node, $value, $type = 'int')
    {
        $text = $dom->createTextNode($value);
        $attr = $dom->createAttribute('type');
        $attr->value = $type;

        $node->appendChild($text);
        $node->appendChild($attr);
    }
320557
public static NodeImpl createMethodNode(final String name, final NodeImpl parent,
      final Class<?>[] parameterTypes) {
    return new NodeImpl( //
        name, //
        parent, //
        false, //
        null, //
        null, //
        ElementKind.METHOD, //
        parameterTypes, //
        null, //
        null, //
        null, //
        null //
    );
  }