*/ protected array $adhocNamespaces = []; /** * When the first element is written, this flag is set to true. * * This ensures that the namespaces in the namespaces map are only written * once. */ protected bool $namespacesWritten = false; /** * Writes a value to the output stream. * * The following values are supported: * 1. Scalar values will be written as-is, as text. * 2. Null values will be skipped (resulting in a short xml tag). * 3. If a value is an instance of an Element class, writing will be * delegated to the object. * 4. If a value is an array, two formats are supported. * * Array format 1: * [ * "{namespace}name1" => "..", * "{namespace}name2" => "..", * ] * * One element will be created for each key in this array. The values of * this array support any format this method supports (this method is * called recursively). * * Array format 2: * * [ * [ * "name" => "{namespace}name1" * "value" => "..", * "attributes" => [ * "attr" => "attribute value", * ] * ], * [ * "name" => "{namespace}name1" * "value" => "..", * "attributes" => [ * "attr" => "attribute value", * ] * ] * ] * * @param mixed $value PHP value to be written */ public function write($value): void { Serializer\standardSerializer($this, $value); } /** * Opens a new element. * * You can either just use a local element name, or you can use clark- * notation to start a new element. * * Example: * * $writer->startElement('{http://www.w3.org/2005/Atom}entry'); * * Would result in something like: * * * * Note: this function doesn't have the string typehint, because PHP's * XMLWriter::startElement doesn't either. * From PHP 8.0 the typehint exists, so it can be added here after PHP 7.4 is dropped. * * @param string $name */ public function startElement($name): bool { if ('{' === $name[0]) { list($namespace, $localName) = Service::parseClarkNotation($name); if (array_key_exists($namespace, $this->namespaceMap)) { $result = $this->startElementNS( '' === $this->namespaceMap[$namespace] ? null : $this->namespaceMap[$namespace], $localName, null ); } else { // An empty namespace means it's the global namespace. This is // allowed, but it mustn't get a prefix. if ('' === $namespace) { $result = $this->startElement($localName); $this->writeAttribute('xmlns', ''); } else { if (!isset($this->adhocNamespaces[$namespace])) { $this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1); } $result = $this->startElementNS($this->adhocNamespaces[$namespace], $localName, $namespace); } } } else { $result = parent::startElement($name); } if (!$this->namespacesWritten) { foreach ($this->namespaceMap as $namespace => $prefix) { $this->writeAttribute($prefix ? 'xmlns:'.$prefix : 'xmlns', $namespace); } $this->namespacesWritten = true; } return $result; } /** * Write a full element tag and it's contents. * * This method automatically closes the element as well. * * The element name may be specified in clark-notation. * * Examples: * * $writer->writeElement('{http://www.w3.org/2005/Atom}author',null); * becomes: * * * $writer->writeElement('{http://www.w3.org/2005/Atom}author', [ * '{http://www.w3.org/2005/Atom}name' => 'Evert Pot', * ]); * becomes: * Evert Pot * * Note: this function doesn't have the string typehint, because PHP's * XMLWriter::startElement doesn't either. * From PHP 8.0 the typehint exists, so it can be added here after PHP 7.4 is dropped. * * @param string $name * @param array|string|object|null $content */ public function writeElement($name, $content = null): bool { $this->startElement($name); if (!is_null($content)) { $this->write($content); } $this->endElement(); return true; } /** * Writes a list of attributes. * * Attributes are specified as a key->value array. * * The key is an attribute name. If the key is a 'localName', the current * xml namespace is assumed. If it's a 'clark notation key', this namespace * will be used instead. * * @param array $attributes */ public function writeAttributes(array $attributes): void { foreach ($attributes as $name => $value) { $this->writeAttribute($name, $value); } } /** * Writes a new attribute. * * The name may be specified in clark-notation. * * Returns true when successful. * * Note: this function doesn't have typehints, because for some reason * PHP's XMLWriter::writeAttribute doesn't either. * From PHP 8.0 the typehint exists, so it can be added here after PHP 7.4 is dropped. * * @param string $name * @param string $value */ public function writeAttribute($name, $value): bool { if ('{' !== $name[0]) { return parent::writeAttribute($name, $value); } list( $namespace, $localName, ) = Service::parseClarkNotation($name); if (array_key_exists($namespace, $this->namespaceMap)) { // It's an attribute with a namespace we know return $this->writeAttribute( $this->namespaceMap[$namespace].':'.$localName, $value ); } // We don't know the namespace, we must add it in-line if (!isset($this->adhocNamespaces[$namespace])) { $this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1); } return $this->writeAttributeNS( $this->adhocNamespaces[$namespace], $localName, $namespace, $value ); } }