PHP Node::hasChildren方法代码示例

 $parsed = str_replace("))", ") )", $parsed);
 $tokens = explode(" ", $parsed);
 // var_dump($tokens);
 foreach ($tokens as $token) {
     if (strcmp(substr($token, 0, 1), "(") == 0) {
         //nāk jauna frāze, jātaisa jauna lapa
         $tokenCategory = trim(substr($token, 1));
         if (!isset($rootNode)) {
             $rootNode = new Node($tokenCategory);
             $currentNode = $rootNode;
             $currentNode->level = 0;
         } else {
             $newNode = new Node($tokenCategory);
             $newNode->setParent($currentNode);
             $newNode->level = $currentNode->level + 1;
             if (!$rootNode->hasChildren()) {
                 $rootNode->addChild($newNode);
             } else {
                 $currentNode->addChild($newNode);
             }
             $currentNode = $newNode;
         }
     } elseif (strcmp(substr($token, -1, 1), ")") == 0) {
         //frāze beidzas
         //ja bija vārds, jāpievieno pie aktuālās lapas, ja nē, jāiet pie vecāka
         $tokenWord = substr($token, 0, -1);
         if (strlen($tokenWord) > 0) {
             $currentNode->setWord($tokenWord);
         }
         if ($currentNode->getParent() != null) {
             $currentNode = $currentNode->getParent();

 /**
  * Returns the DOM representation of the Node.
  *
  * @param \DOMDocument $document   The global document object
  * @param Node         $node       The Node to be converted to string
  * @param bool         $forceCdata Whether the XML content will be enclosed within CDATA tags
  *
  * @return \DOMElement The DOM rappresentation of the Node
  */
 private function createDomStructure(\DOMDocument $document, Node $node, $forceCdata)
 {
     if (!$node->getName()) {
         throw new \RuntimeException('Can not create an XML representation of a Node without a name');
     }
     $element = $document->createElement($node->getName());
     foreach ($node->getAttributes() as $key => $value) {
         $attribute = $document->createAttribute($key);
         $attribute->value = $value;
         $element->appendChild($attribute);
     }
     if (!$node->hasChildren()) {
         // The Node has no children, so only content needs to be displayed
         if ($node->getValue()) {
             // The Node has content to be displayed
             if ($node->getUseCdata() || $forceCdata) {
                 $content = $document->createCDATASection($node->getValue());
             } else {
                 $content = $document->createTextNode($node->getValue());
             }
             $element->appendChild($content);
         } else {
             // The Node has no content, and short-tag is not enabled
             if ($node->getUseCdata() || $forceCdata) {
                 $element->appendChild($document->createCDATASection($node->getValue()));
             }
         }
     } else {
         // The Node has children, so they must be displayed before closing the XML tag
         foreach ($node->getChildren() as $child) {
             $element->appendChild($this->createDomStructure($document, $child, $forceCdata));
         }
     }
     return $element;
 }

 /**
  * Adds containers to a node that is a database
  *
  * References to existing children are returned
  * if this function is called twice on the same node
  *
  * @param Node   $db   The database node, new containers will be
  *                     attached to this node
  * @param string $type The type of item being paginated on
  *                     the second level of the tree
  * @param int    $pos2 The position for the pagination of
  *                     the branch at the second level of the tree
  *
  * @return array An array of new nodes
  */
 private function _addDbContainers($db, $type, $pos2)
 {
     $retval = array();
     if ($db->hasChildren(true) == 0) {
         if ($db->getPresence('tables')) {
             $retval['tables'] = PMA_NodeFactory::getInstance('Node_Table_Container');
         }
         if ($db->getPresence('views')) {
             $retval['views'] = PMA_NodeFactory::getInstance('Node_View_Container');
         }
         if ($db->getPresence('functions')) {
             $retval['functions'] = PMA_NodeFactory::getInstance('Node_Function_Container');
         }
         if ($db->getPresence('procedures')) {
             $retval['procedures'] = PMA_NodeFactory::getInstance('Node_Procedure_Container');
         }
         if ($db->getPresence('events')) {
             $retval['events'] = PMA_NodeFactory::getInstance('Node_Event_Container');
         }
         // Add all new Nodes to the tree
         foreach ($retval as $node) {
             if ($type == $node->real_name) {
                 $node->pos2 = $pos2;
             }
             $db->addChild($node);
         }
     } else {
         foreach ($db->children as $node) {
             if ($type == $node->real_name) {
                 $node->pos2 = $pos2;
             }
             $retval[$node->real_name] = $node;
         }
     }
     return $retval;
 }

 /**
  * Recursively deserialize data for the given node.
  *
  * @param   xml.Node node
  * @return  var
  * @throws  lang.IllegalArgumentException if the data cannot be deserialized
  * @throws  lang.ClassNotFoundException in case a XP object's class could not be loaded
  * @throws  xml.XMLFormatException
  */
 protected function _unmarshall(Node $node)
 {
     // value without type is supposed to be string (XML-RPC specs)
     if ('value' == $node->getName() && !isset($node->children[0])) {
         return (string) $node->getContent();
     }
     if (!isset($node->children[0])) {
         throw new XMLFormatException('Tried to access nonexistant node.');
     }
     // Simple form: If no subnode indicating the type exists, the type
     // is string, e.g. <value>Test</value>
     if (!$node->hasChildren()) {
         return (string) $node->getContent();
     }
     // Long form - with subnode, the type is derived from the node's name,
     // e.g. <value><string>Test</string></value>.
     $c = $node->nodeAt(0);
     switch ($c->getName()) {
         case 'struct':
             $ret = array();
             foreach ($c->getChildren() as $child) {
                 $data = array();
                 $data[$child->nodeAt(0)->getName()] = $child->nodeAt(0);
                 $data[$child->nodeAt(1)->getName()] = $child->nodeAt(1);
                 $ret[$data['name']->getContent()] = $this->_unmarshall($data['value']);
                 unset($data);
             }
             if (!isset($ret['__xp_class'])) {
                 return $ret;
             }
             // Check whether this is a XP object. If so, load the class and
             // create an instance without invoking the constructor.
             $fields = XPClass::forName($ret['__xp_class'])->getFields();
             $cname = array_search($ret['__xp_class'], xp::$cn, TRUE);
             $s = '';
             $n = 0;
             foreach ($fields as $field) {
                 if (!isset($ret[$field->getName()])) {
                     continue;
                 }
                 $m = $field->getModifiers();
                 if ($m & MODIFIER_STATIC) {
                     continue;
                 } else {
                     if ($m & MODIFIER_PUBLIC) {
                         $name = $field->getName();
                     } else {
                         if ($m & MODIFIER_PROTECTED) {
                             $name = "*" . $field->getName();
                         } else {
                             if ($m & MODIFIER_PRIVATE) {
                                 $name = "" . array_search($field->getDeclaringClass()->getName(), xp::$cn, TRUE) . "" . $field->getName();
                             }
                         }
                     }
                 }
                 $s .= 's:' . strlen($name) . ':"' . $name . '";' . serialize($ret[$field->getName()]);
                 $n++;
             }
             return unserialize('O:' . strlen($cname) . ':"' . $cname . '":' . $n . ':{' . $s . '}');
         case 'array':
             $ret = array();
             foreach ($c->nodeAt(0)->getChildren() as $child) {
                 $ret[] = $this->_unmarshall($child);
             }
             return $ret;
         case 'int':
         case 'i4':
             return (int) $c->getContent();
         case 'double':
             return (double) $c->getContent();
         case 'boolean':
             return (bool) $c->getContent();
         case 'string':
             return (string) $c->getContent();
         case 'dateTime.iso8601':
             return Date::fromString($c->getContent());
         case 'nil':
             return NULL;
         case 'base64':
             return new Bytes(base64_decode($c->getContent()));
         default:
             throw new IllegalArgumentException('Could not decode node as its type is not supported: ' . $c->getName());
     }
 }