PHP NodeInterface::createSingleNode方法代码示例

 /**
  * Create a recursive copy of this node below $referenceNode with $nodeName.
  *
  * @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $referenceNode
  * @param string $nodeName
  * @return \TYPO3\TYPO3CR\Domain\Model\NodeInterface
  */
 protected function createRecursiveCopy(NodeInterface $referenceNode, $nodeName)
 {
     $copiedNode = $referenceNode->createSingleNode($nodeName);
     $copiedNode->similarize($this);
     /** @var $childNode Node */
     foreach ($this->getChildNodes() as $childNode) {
         // Prevent recursive copy when copying into itself
         if ($childNode !== $copiedNode) {
             $childNode->copyInto($copiedNode, $childNode->getName());
         }
     }
     return $copiedNode;
 }

 /**
  * Create a recursive copy of this node below $referenceNode with $nodeName.
  *
  * $detachedCopy only has an influence if we are copying from one dimension to the other, possibly creating a new
  * node variant:
  *
  * - If $detachedCopy is TRUE, the whole (recursive) copy is done without connecting original and copied node,
  *   so NOT CREATING a new node variant.
  * - If $detachedCopy is FALSE, and the node does not yet have a variant in the target dimension, we are CREATING
  *   a new node variant.
  *
  * As a caller of this method, $detachedCopy should be TRUE if $this->getNodeType()->isAggregate() is TRUE, and FALSE
  * otherwise.
  *
  * @param NodeInterface $referenceNode
  * @param boolean $detachedCopy
  * @param string $nodeName
  * @return NodeInterface
  */
 protected function createRecursiveCopy(NodeInterface $referenceNode, $nodeName, $detachedCopy)
 {
     $identifier = null;
     $referenceNodeDimensions = $referenceNode->getDimensions();
     $referenceNodeDimensionsHash = Utility::sortDimensionValueArrayAndReturnDimensionsHash($referenceNodeDimensions);
     $thisDimensions = $this->getDimensions();
     $thisNodeDimensionsHash = Utility::sortDimensionValueArrayAndReturnDimensionsHash($thisDimensions);
     if ($detachedCopy === false && $referenceNodeDimensionsHash !== $thisNodeDimensionsHash && $referenceNode->getContext()->getNodeByIdentifier($this->getIdentifier()) === null) {
         // If the target dimensions are different than this one, and there is no node shadowing this one in the target dimension yet, we use the same
         // node identifier, effectively creating a new node variant.
         $identifier = $this->getIdentifier();
     }
     $copiedNode = $referenceNode->createSingleNode($nodeName, null, $identifier);
     $copiedNode->similarize($this, true);
     /** @var $childNode Node */
     foreach ($this->getChildNodes() as $childNode) {
         // Prevent recursive copy when copying into itself
         if ($childNode->getIdentifier() !== $copiedNode->getIdentifier()) {
             $childNode->copyIntoInternal($copiedNode, $childNode->getName(), $detachedCopy);
         }
     }
     return $copiedNode;
 }

 /**
  * Converts the given $nodeXml to a node and adds it to the $parentNode (or overrides an existing node)
  *
  * @param \SimpleXMLElement $nodeXml
  * @param NodeInterface $parentNode
  * @return void
  */
 protected function importNode(\SimpleXMLElement $nodeXml, NodeInterface $parentNode)
 {
     $nodeName = (string) $nodeXml['nodeName'];
     $nodeType = $this->parseNodeType($nodeXml);
     $node = $parentNode->getNode($nodeName);
     if ($node === null) {
         $identifier = (string) $nodeXml['identifier'] === '' ? null : (string) $nodeXml['identifier'];
         $node = $parentNode->createSingleNode((string) $nodeXml['nodeName'], $nodeType, $identifier);
     } else {
         $node->setNodeType($nodeType);
     }
     $this->importNodeVisibility($nodeXml, $node);
     $this->importNodeProperties($nodeXml, $node);
     $this->importNodeAccessRoles($nodeXml, $node);
     if ($nodeXml->node) {
         foreach ($nodeXml->node as $childNodeXml) {
             $this->importNode($childNodeXml, $node);
         }
     }
 }

 /**
  * Iterates over the nodes and adds them to the workspace.
  *
  * @param \SimpleXMLElement $parentXml
  * @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $parentNode
  * @return void
  */
 protected function parseNodes(\SimpleXMLElement $parentXml, \TYPO3\TYPO3CR\Domain\Model\NodeInterface $parentNode)
 {
     foreach ($parentXml->node as $childNodeXml) {
         $childNode = $parentNode->getNode((string) $childNodeXml['nodeName']);
         $contentTypeName = (string) $childNodeXml['type'];
         if (!$this->contentTypeManager->hasContentType($contentTypeName)) {
             $contentType = $this->contentTypeManager->createContentType($contentTypeName);
         } else {
             $contentType = $this->contentTypeManager->getContentType($contentTypeName);
         }
         if ($childNode === NULL) {
             $identifier = (string) $childNodeXml['identifier'] === '' ? NULL : (string) $childNodeXml['identifier'];
             $childNode = $parentNode->createSingleNode((string) $childNodeXml['nodeName'], $contentType, $identifier);
         } else {
             $childNode->setContentType($contentType);
         }
         $childNode->setHidden((bool) $childNodeXml['hidden']);
         $childNode->setHiddenInIndex((bool) $childNodeXml['hiddenInIndex']);
         if ($childNodeXml['hiddenBeforeDateTime'] != '') {
             $childNode->setHiddenBeforeDateTime(\DateTime::createFromFormat(\DateTime::W3C, (string) $childNodeXml['hiddenBeforeDateTime']));
         }
         if ($childNodeXml['hiddenAfterDateTime'] != '') {
             $childNode->setHiddenAfterDateTime(\DateTime::createFromFormat(\DateTime::W3C, (string) $childNodeXml['hiddenAfterDateTime']));
         }
         if ($childNodeXml->properties) {
             foreach ($childNodeXml->properties->children() as $childXml) {
                 if (isset($childXml['__type']) && (string) $childXml['__type'] == 'object') {
                     $childNode->setProperty($childXml->getName(), $this->xmlToObject($childXml));
                 } else {
                     $childNode->setProperty($childXml->getName(), (string) $childXml);
                 }
             }
         }
         if ($childNodeXml->accessRoles) {
             $accessRoles = array();
             foreach ($childNodeXml->accessRoles->children() as $childXml) {
                 $accessRoles[] = (string) $childXml;
             }
             $childNode->setAccessRoles($accessRoles);
         }
         if ($childNodeXml->node) {
             $this->parseNodes($childNodeXml, $childNode);
         }
     }
 }