PHP NodeInterface类代码示例

 public function createFromNode(NodeInterface $node)
 {
     $item = $this->createItem($node->getName(), $node->getOptions());
     foreach ($node->getChildren() as $childNode) {
         $item->addChild($this->createFromNode($childNode));
     }
     return $item;
 }

 /**
  * Processes an array of configurations.
  *
  * @param NodeInterface $configTree The node tree describing the configuration
  * @param array         $configs    An array of configuration items to process
  *
  * @return array The processed configuration
  */
 public function process(NodeInterface $configTree, array $configs)
 {
     $currentConfig = array();
     foreach ($configs as $config) {
         $config = $configTree->normalize($config);
         $currentConfig = $configTree->merge($currentConfig, $config);
     }
     return $configTree->finalize($currentConfig);
 }

 private function translateChild(ValueObject $meta, ResultInterface $result, NodeInterface $node) : CollectionInterface
 {
     $relMeta = $meta->relationship();
     $relationships = $result->relationships()->filter(function (RelationshipInterface $relationship) use($node, $relMeta) {
         return (string) $relationship->type() === (string) $relMeta->type() && $relationship->endNode()->value() === $node->id()->value();
     });
     if ($relationships->count() > 1) {
         throw MoreThanOneRelationshipFoundException::for($meta);
     }
     return $this->translateRelationship($meta, $result, $relationships->first());
 }

 /**
  * Processes an array of configurations.
  *
  * @param NodeInterface $configTree The node tree describing the configuration
  * @param array         $configs    An array of configuration items to process
  * @param bool          $normalizeKeys Flag indicating if config key normalization is needed. True by default.
  *
  * @return array The processed configuration
  */
 public function process(NodeInterface $configTree, array $configs, $normalizeKeys = true)
 {
     if ($normalizeKeys) {
         $configs = self::normalizeKeys($configs);
     }
     $currentConfig = array();
     foreach ($configs as $config) {
         $config = $configTree->normalize($config);
         $currentConfig = $configTree->merge($currentConfig, $config);
     }
     return $configTree->finalize($currentConfig);
 }

/**
 * Allows to prevent unpublication of a scheduled node.
 *
 * @param \Drupal\node\NodeInterface $node
 *   The scheduled node that is about to be unpublished.
 *
 * @return bool
 *   FALSE if the node should not be unpublished. TRUE otherwise.
 */
function hook_scheduler_allow_unpublishing(NodeInterface $node)
{
    $allowed = TRUE;
    // Prevent unpublication of competition entries if not all prizes have been
    // claimed.
    if ($node->getType() == 'competition' && ($items = $node->field_competition_prizes->getValue())) {
        $allowed = (bool) count($items);
        // If unpublication is denied then inform the user why.
        if (!$allowed) {
            drupal_set_message(t('The competition will only be unpublished after all prizes have been claimed by the winners.'));
        }
    }
    return $allowed;
}

 public function registerChild(NodeInterface $node, $overwrite = false, $prepend = false)
 {
     $this->registerAdopters();
     if ($node->getParent() !== $this) {
         throw new \RuntimeException('Nodes being registered must return this node from their getParentNode method.');
     }
     $name = $node->getName();
     if (!$overwrite && isset($this->childNodes[$name])) {
         throw new \RuntimeException(sprintf('Node name %s is already registered.', $name));
     }
     if ($prepend) {
         $this->childNodes = array_merge([$name => null], $this->getChildren(), [$name => $node]);
     } else {
         $this->childNodes[$name] = $node;
     }
 }

 /**
  * Adiciona um Nó ao Conteúdo
  * @param NodeInterface $node Nó de Conteúdo Interno
  */
 public function addContentNode(NodeInterface $node)
 {
     $node->setParentNode($this);
     $this->_content[] = $node;
     return $this;
 }

 /**
  * Render a node label
  *
  * @param NodeInterface $node
  * @param boolean $crop This argument is deprecated as of Neos 1.2 and will be removed. Don't rely on this behavior and crop labels in the view.
  * @return string
  */
 public function getLabel(NodeInterface $node, $crop = true)
 {
     return $this->nodeDataLabelGenerator->getLabel($node->getNodeData(), $crop);
 }

 private function check(NodeInterface $node) : bool
 {
     return $node instanceof ElementInterface && $node->attributes()->contains('role') && $node->attributes()->get('role')->value() === $this->role;
 }

 public function __construct(NodeInterface $entity)
 {
     $this->originalData = array('id' => $entity->getId(), 'left' => $entity->getLeftValue(), 'right' => $entity->getRightValue(), 'level' => $entity->getLevel(), 'isLeaf' => $entity instanceof NodeLeafInterface);
 }

 /**
  * Get the uri for the given node
  *
  * @param NodeInterface $node
  * @return string
  */
 protected function getUriFromNode(NodeInterface $node)
 {
     return $node->getUri();
 }

 public function appendChild(NodeInterface $node)
 {
     $node->setParent($this);
     $this->children->add($node);
     return $this;
 }

 public function mergeWith(NodeInterface $node, $deep = true)
 {
     // @todo ensure that this method work as expected
     foreach ($node->getChildren() as $key => $child) {
         if (!$this->hasChild($key)) {
             $this->addChild($child->duplicate());
         } else {
             if ($deep) {
                 $this->getChild($key)->mergeWith($child, $deep);
             }
         }
     }
 }

 /**
  * Set child
  *
  * @param int $position
  * @param NodeInterface|null $child
  * @return $this
  */
 public function setChild($position, NodeInterface $child = null)
 {
     $this->children[$position] = $child;
     if (null !== $child) {
         $child->setParent($this)->setPosition($position);
     }
     return $this;
 }

 public function setParent(NodeInterface $parent)
 {
     $this->parent = $parent;
     $this->setDepth($parent->getDepth() + 1);
 }