/** * 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) { $self = new self(); $reader->pushContext(); $reader->elementMap['{DAV:}prop'] = 'Sabre\\Xml\\Element\\Elements'; $elems = KeyValue::xmlDeserialize($reader); $reader->popContext(); $required = ['{DAV:}sync-token', '{DAV:}prop']; foreach ($required as $elem) { if (!array_key_exists($elem, $elems)) { throw new BadRequest('The ' . $elem . ' element in the {DAV:}sync-collection report is required'); } } $self->properties = $elems['{DAV:}prop']; $self->syncToken = $elems['{DAV:}sync-token']; if (isset($elems['{DAV:}limit'])) { $nresults = null; foreach ($elems['{DAV:}limit'] as $child) { if ($child['name'] === '{DAV:}nresults') { $nresults = (int) $child['value']; } } $self->limit = $nresults; } if (isset($elems['{DAV:}sync-level'])) { $value = $elems['{DAV:}sync-level']; if ($value === 'infinity') { $value = \Sabre\DAV\Server::DEPTH_INFINITY; } $self->syncLevel = $value; } return $self; }
/** * 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:}prop'] = 'Sabre\\Xml\\Deserializer\\enum'; $elems = Deserializer\keyValue($reader, 'DAV:'); $reader->popContext(); $report = new self(); if (!empty($elems['prop'])) { $report->properties = $elems['prop']; } return $report; }
/** * 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) { $self = new self(); $reader->pushContext(); $reader->elementMap['{DAV:}prop'] = 'Sabre\\Xml\\Element\\Elements'; foreach (KeyValue::xmlDeserialize($reader) as $k => $v) { switch ($k) { case '{DAV:}prop': $self->properties = $v; break; case '{DAV:}allprop': $self->allProp = true; } } $reader->popContext(); return $self; }
/** * 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:}owner'] = 'Sabre\\Xml\\Element\\XmlFragment'; $values = KeyValue::xmlDeserialize($reader); $reader->popContext(); $new = new self(); $new->owner = !empty($values['{DAV:}owner']) ? $values['{DAV:}owner']->getXml() : null; $new->scope = LockInfo::SHARED; if (isset($values['{DAV:}lockscope'])) { foreach ($values['{DAV:}lockscope'] as $elem) { if ($elem['name'] === '{DAV:}exclusive') { $new->scope = LockInfo::EXCLUSIVE; } } } return $new; }
/** * 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:}prop'] = 'Sabre\\Xml\\Deserializer\\enum'; $elems = Deserializer\keyValue($reader, 'DAV:'); $reader->popContext(); $principalMatch = new self(); if (array_key_exists('self', $elems)) { $principalMatch->type = self::SELF; } if (array_key_exists('principal-property', $elems)) { $principalMatch->type = self::PRINCIPAL_PROPERTY; $principalMatch->principalProperty = $elems['principal-property'][0]['name']; } if (!empty($elems['prop'])) { $principalMatch->properties = $elems['prop']; } return $principalMatch; }
/** * 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. * * 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) { // Temporarily override configuration $reader->pushContext(); $reader->elementMap['{DAV:}share-access'] = 'Sabre\\DAV\\Xml\\Property\\ShareAccess'; $reader->elementMap['{DAV:}prop'] = 'Sabre\\Xml\\Deserializer\\keyValue'; $elems = Deserializer\keyValue($reader, 'DAV:'); // Restore previous configuration $reader->popContext(); $sharee = new self(); if (!isset($elems['href'])) { throw new BadRequest('Every {DAV:}sharee must have a {DAV:}href child-element'); } $sharee->href = $elems['href']; if (isset($elems['prop'])) { $sharee->properties = $elems['prop']; } if (isset($elems['comment'])) { $sharee->comment = $elems['comment']; } if (!isset($elems['share-access'])) { throw new BadRequest('Every {DAV:}sharee must have a {DAV:}share-access child element'); } $sharee->access = $elems['share-access']->getValue(); return $sharee; }