PHP NodeInterface::getName方法代码示例

 /**
  * Process the given node and return eventual extra operations determined from the node.
  *
  * @param NodeInterface $node
  *
  * @return AddNodeOperation[] Additional operations that the client must execute for autocreated nodes.
  */
 public function process(NodeInterface $node)
 {
     $this->validateNamespace($node->getName());
     $nodeDef = $node->getPrimaryNodeType();
     $nodeTypes = $node->getMixinNodeTypes();
     array_unshift($nodeTypes, $nodeDef);
     $additionalOperations = array();
     foreach ($nodeTypes as $nodeType) {
         /* @var $nodeType NodeTypeDefinitionInterface */
         $additionalOperations = array_merge($additionalOperations, $this->processNodeWithType($node, $nodeType));
     }
     return $additionalOperations;
 }

 private function renameNode(NodeInterface $node, $nodeName)
 {
     if ($node->getName() == $nodeName) {
         return;
     }
     $node->rename($nodeName);
 }

 /**
  * Adds child node to this node for internal reference
  *
  * @param string  $node  The name of the child node
  * @param boolean $check whether to check state
  * @param string  $name  is used in cases where $node->getName would not return the correct name (during move operation)
  *
  * @private
  */
 public function addChildNode(NodeInterface $node, $check, $name = null)
 {
     if ($check) {
         $this->checkState();
     }
     if (is_null($name)) {
         $name = $node->getName();
     }
     $nt = $this->getPrimaryNodeType();
     //will throw a ConstraintViolationException if this node can't be added
     $nt->canAddChildNode($name, $node->getPrimaryNodeType()->getName(), true);
     // TODO: same name siblings
     $this->nodes[] = $name;
     if (null !== $this->originalNodesOrder) {
         $this->originalNodesOrder[] = $name;
     }
 }

 private function resolveSiblingName($siblingId, NodeInterface $parentNode, NodeInterface $node)
 {
     if (null === $siblingId) {
         return;
     }
     $siblingPath = $siblingId;
     if (UUIDHelper::isUUID($siblingId)) {
         $siblingPath = $this->nodeManager->find($siblingId)->getPath();
     }
     if ($siblingPath !== null && PathHelper::getParentPath($siblingPath) !== $parentNode->getPath()) {
         throw new DocumentManagerException(sprintf('Cannot reorder documents which are not siblings. Trying to reorder "%s" to "%s"', $node->getPath(), $siblingPath));
     }
     if (null !== $siblingPath) {
         return PathHelper::getNodeName($siblingPath);
     }
     return $node->getName();
 }

 /**
  * Recursively output node and all its children into the file in the
  * document view format
  *
  * @param NodeInterface              $node       the node to output
  * @param NamespaceRegistryInterface $ns         The namespace registry to export namespaces too
  * @param resource                   $stream     the resource to write data out to
  * @param boolean                    $skipBinary A boolean governing whether binary properties
  *      are to be serialized.
  * @param boolean $noRecurse A boolean governing whether the subgraph at
  *      absPath is to be recursed.
  * @param boolean $root Whether this is the root node of the resulting
  *      document, meaning the namespace declarations have to be included in
  *      it.
  */
 private static function exportDocumentViewRecursive(NodeInterface $node, NamespaceRegistryInterface $ns, $stream, $skipBinary, $noRecurse, $root = false)
 {
     $nodename = self::escapeXmlName($node->getName());
     fwrite($stream, "<{$nodename}");
     if ($root) {
         self::exportNamespaceDeclarations($ns, $stream);
     }
     foreach ($node->getProperties() as $name => $property) {
         /** @var $property \PHPCR\PropertyInterface */
         if ($property->isMultiple()) {
             // skip multiple properties. jackrabbit does this too. cheap but whatever. use system view for a complete export
             continue;
         }
         if (PropertyType::BINARY == $property->getType()) {
             if ($skipBinary) {
                 continue;
             }
             $value = base64_encode($property->getString());
         } else {
             $value = htmlspecialchars($property->getString());
         }
         fwrite($stream, ' ' . self::escapeXmlName($name) . '="' . $value . '"');
     }
     if ($noRecurse || !$node->hasNodes()) {
         fwrite($stream, '/>');
     } else {
         fwrite($stream, '>');
         foreach ($node as $child) {
             if (!($child->getDepth() == 1 && NodeHelper::isSystemItem($child))) {
                 self::exportDocumentViewRecursive($child, $ns, $stream, $skipBinary, $noRecurse);
             }
         }
         fwrite($stream, "</{$nodename}>");
     }
 }

 /**
  * TODO: This is a workaround for a bug in Jackalope which will be fixed in the next
  *       release 1.2: https://github.com/jackalope/jackalope/pull/262.
  */
 private function rename(NodeInterface $node, $name)
 {
     $names = (array) $node->getParent()->getNodeNames();
     $pos = array_search($node->getName(), $names);
     $next = isset($names[$pos + 1]) ? $names[$pos + 1] : null;
     $node->rename($name);
     if ($next) {
         $node->getParent()->orderBefore($name, $next);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getName()
 {
     return $this->node->getName();
 }

 public function testGetName()
 {
     $name = $this->node->getName();
     $this->assertNotNull($name);
     $this->assertEquals('tests_general_base', $name);
 }

 public function formatNodeName(NodeInterface $node)
 {
     return sprintf('%s%s', $node->getName(), $node->hasNodes() ? '/' : '');
 }