/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * Important note 2: You are responsible for advancing the reader to the * next element. Not doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseSubTree() will parse the entire sub-tree, and advance to * the next element. * * @param XML\Reader $reader * @return mixed */ public static function deserializeXml(XML\Reader $reader) { $reader->next(); $count = 1; while ($count) { $reader->read(); if ($reader->nodeType === $reader::END_ELEMENT) { $count--; } } $reader->read(); }
/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * Important note 2: You are responsible for advancing the reader to the * next element. Not doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseSubTree() will parse the entire sub-tree, and advance to * the next element. * * @param Xml\Reader $reader * @return mixed */ static function xmlDeserialize(Xml\Reader $reader) { $reader->next(); $count = 1; while ($count) { $reader->read(); if ($reader->nodeType === $reader::END_ELEMENT) { $count--; } } $reader->read(); }
/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * You are responsible for advancing the reader to the next element. Not * doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseInnerTree() will parse the entire sub-tree, and advance to * the next element. * * @param Reader $reader * @return mixed */ static function xmlDeserialize(Reader $reader) { // If there's no children, we don't do anything. if ($reader->isEmptyElement) { $reader->next(); return []; } $values = []; $reader->read(); do { if ($reader->nodeType === Reader::ELEMENT) { $clark = $reader->getClark(); $values[$clark] = self::parseCurrentElement($reader)['value']; } else { $reader->read(); } } while ($reader->nodeType !== Reader::END_ELEMENT); $reader->read(); return $values; }
/** * The deserialize method is called during xml parsing. * * This method is called staticly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * Important note 2: You are responsible for advancing the reader to the * next element. Not doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseInnerTree() will parse the entire sub-tree, and advance to * the next element. * * @param XML\Reader $reader * * @return mixed */ static function xmlDeserialize(SabreXml\Reader $reader) { // If there's no children, we don't do anything. if ($reader->isEmptyElement) { $reader->next(); return []; } $values = []; $reader->read(); do { if ($reader->nodeType === SabreXml\Reader::ELEMENT) { $name = $reader->localName; $values[$name] = $reader->parseCurrentElement()['value']; } else { $reader->read(); } } while ($reader->nodeType !== SabreXml\Reader::END_ELEMENT); $reader->read(); return $values; }
/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * You are responsible for advancing the reader to the next element. Not * doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseInnerTree() will parse the entire sub-tree, and advance to * the next element. * * @param Reader $reader * @return mixed */ static function xmlDeserialize(Reader $reader) { $xml = $reader->readInnerXml(); if ($reader->nodeType === Reader::ELEMENT && $reader->isEmptyElement) { // Easy! $reader->next(); return null; } // Now we have a copy of the inner xml, we need to traverse it to get // all the strings. If there's no non-string data, we just return the // string, otherwise we return an instance of this class. $reader->read(); $nonText = false; $text = ''; while (true) { switch ($reader->nodeType) { case Reader::ELEMENT: $nonText = true; $reader->next(); continue 2; case Reader::TEXT: case Reader::CDATA: $text .= $reader->value; break; case Reader::END_ELEMENT: break 2; } $reader->read(); } // Make sure we advance the cursor one step further. $reader->read(); if ($nonText) { $new = new self($xml); return $new; } else { return $text; } }
/** * The xmlSerialize metod is called during xml writing. * * Use the $writer argument to write its own xml serialization. * * An important note: do _not_ create a parent element. Any element * implementing XmlSerializble should only ever write what's considered * its 'inner xml'. * * The parent of the current element is responsible for writing a * containing element. * * This allows serializers to be re-used for different element names. * * If you are opening new elements, you must also close them again. * * @param Writer $writer * @return void */ function xmlSerialize(Writer $writer) { $reader = new Reader(); // Wrapping the xml in a container, so root-less values can still be // parsed. $xml = <<<XML <?xml version="1.0"?> <xml-fragment xmlns="http://sabre.io/ns">{$this->getXml()}</xml-fragment> XML; $reader->xml($xml); $elementNamespace = null; while ($reader->read()) { if ($reader->depth < 1) { // Skipping the root node. continue; } switch ($reader->nodeType) { case Reader::ELEMENT: $writer->startElement($reader->getClark()); $empty = $reader->isEmptyElement; while ($reader->moveToNextAttribute()) { switch ($reader->namespaceURI) { case '': $writer->writeAttribute($reader->localName, $reader->value); break; case 'http://www.w3.org/2000/xmlns/': // Skip namespace declarations break; default: $writer->writeAttribute($reader->getClark(), $reader->value); break; } } if ($empty) { $writer->endElement(); } break; case Reader::CDATA: case Reader::TEXT: $writer->text($reader->value); break; case Reader::END_ELEMENT: $writer->endElement(); break; } } }
/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * You are responsible for advancing the reader to the next element. Not * doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseInnerTree() will parse the entire sub-tree, and advance to * the next element. * * @param Reader $reader * @return mixed */ static function xmlDeserialize(Reader $reader) { $reader->pushContext(); $reader->elementMap['{DAV:}propstat'] = 'Sabre\\Xml\\Element\\KeyValue'; // We are overriding the parser for {DAV:}prop. This deserializer is // almost identical to the one for Sabre\Xml\Element\KeyValue. // // The difference is that if there are any child-elements inside of // {DAV:}prop, that have no value, normally any deserializers are // called. But we don't want this, because a singular element without // child-elements implies 'no value' in {DAV:}prop, so we want to skip // deserializers and just set null for those. $reader->elementMap['{DAV:}prop'] = function (Reader $reader) { if ($reader->isEmptyElement) { $reader->next(); return []; } $values = []; $reader->read(); do { if ($reader->nodeType === Reader::ELEMENT) { $clark = $reader->getClark(); if ($reader->isEmptyElement) { $values[$clark] = null; $reader->next(); } else { $values[$clark] = $reader->parseCurrentElement()['value']; } } else { $reader->read(); } } while ($reader->nodeType !== Reader::END_ELEMENT); $reader->read(); return $values; }; $elems = $reader->parseInnerTree(); $reader->popContext(); $href = null; $propertyLists = []; $statusCode = null; foreach ($elems as $elem) { switch ($elem['name']) { case '{DAV:}href': $href = $elem['value']; break; case '{DAV:}propstat': $status = $elem['value']['{DAV:}status']; list(, $status, ) = explode(' ', $status, 3); $properties = isset($elem['value']['{DAV:}prop']) ? $elem['value']['{DAV:}prop'] : []; $propertyLists[$status] = $properties; break; case '{DAV:}status': list(, $statusCode, ) = explode(' ', $elem['value'], 3); break; } } return new self($href, $propertyLists, $statusCode); }
/** * The deserialize method is called during xml parsing. * * This method is called statictly, this is because in theory this method * may be used as a type of constructor, or factory method. * * Often you want to return an instance of the current class, but you are * free to return other data as well. * * Important note 2: You are responsible for advancing the reader to the * next element. Not doing anything will result in a never-ending loop. * * If you just want to skip parsing for this element altogether, you can * just call $reader->next(); * * $reader->parseSubTree() will parse the entire sub-tree, and advance to * the next element. * * @param Xml\Reader $reader * @return mixed */ static function xmlDeserialize(Xml\Reader $reader) { // If there's no children, we don't do anything. if ($reader->isEmptyElement) { $reader->next(); return []; } $reader->read(); $currentDepth = $reader->depth; $values = []; do { if ($reader->nodeType === Xml\Reader::ELEMENT) { $values[] = $reader->getClark(); } } while ($reader->depth >= $currentDepth && $reader->next()); $reader->next(); return $values; }
/** * The valueObject deserializer turns an xml element into a PHP object of * a specific class. * * This is primarily used by the mapValueObject function from the Service * class, but it can also easily be used for more specific situations. * * @param Reader $reader * @param string $className * @param string $namespace * @return object */ function valueObject(Reader $reader, $className, $namespace) { $valueObject = new $className(); if ($reader->isEmptyElement) { $reader->next(); return $valueObject; } $defaultProperties = get_class_vars($className); $reader->read(); do { if ($reader->nodeType === Reader::ELEMENT && $reader->namespaceURI == $namespace) { if (property_exists($valueObject, $reader->localName)) { if (is_array($defaultProperties[$reader->localName])) { $valueObject->{$reader->localName}[] = $reader->parseCurrentElement()['value']; } else { $valueObject->{$reader->localName} = $reader->parseCurrentElement()['value']; } } else { // Ignore property $reader->next(); } } else { $reader->read(); } } while ($reader->nodeType !== Reader::END_ELEMENT); $reader->read(); return $valueObject; }