PHP Reader::pushContext方法代碼示例

 /**
  * 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;
 }