Current File : /home/tjamichg/cursos.tjamich.gob.mx/vendor/knplabs/doctrine-behaviors/src/Model/Tree/Node.php
<?php
/**
* This file is part of the KnpDoctrineBehaviors package.
*
* (c) KnpLabs <http://knplabs.com/>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Knp\DoctrineBehaviors\Model\Tree;
use Knp\DoctrineBehaviors\Model\Tree\NodeInterface;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\ArrayCollection;
/*
* @author Florian Klein <florian.klein@free.fr>
*/
trait Node
{
/**
* @var ArrayCollection $childNodes the children in the tree
*/
private $childNodes;
/**
* @var NodeInterface $parentNode the parent in the tree
*/
private $parentNode;
protected $materializedPath = '';
public function getNodeId()
{
return $this->getId();
}
/**
* Returns path separator for entity's materialized path.
*
* @return string "/" by default
*/
public static function getMaterializedPathSeparator()
{
return '/';
}
/**
* {@inheritdoc}
**/
public function getRealMaterializedPath()
{
return $this->getMaterializedPath() . self::getMaterializedPathSeparator() . $this->getNodeId();
}
public function getMaterializedPath()
{
return $this->materializedPath;
}
/**
* {@inheritdoc}
**/
public function setMaterializedPath($path)
{
$this->materializedPath = $path;
$this->setParentMaterializedPath($this->getParentMaterializedPath());
return $this;
}
/**
* {@inheritdoc}
**/
public function getParentMaterializedPath()
{
$path = $this->getExplodedPath();
array_pop($path);
$parentPath = static::getMaterializedPathSeparator().implode(static::getMaterializedPathSeparator(), $path);
return $parentPath;
}
/**
* {@inheritdoc}
**/
public function setParentMaterializedPath($path)
{
$this->parentNodePath = $path;
}
/**
* {@inheritdoc}
**/
public function getRootMaterializedPath()
{
$explodedPath = $this->getExplodedPath();
return static::getMaterializedPathSeparator() . array_shift($explodedPath);
}
/**
* {@inheritdoc}
**/
public function getNodeLevel()
{
return count($this->getExplodedPath());
}
public function isRootNode()
{
return self::getMaterializedPathSeparator() === $this->getParentMaterializedPath();
}
public function isLeafNode()
{
return 0 === $this->getChildNodes()->count();
}
/**
* {@inheritdoc}
**/
public function getChildNodes()
{
return $this->childNodes = $this->childNodes ?: new ArrayCollection;
}
/**
* {@inheritdoc}
**/
public function addChildNode(NodeInterface $node)
{
$this->getChildNodes()->add($node);
}
/**
* {@inheritdoc}
**/
public function isIndirectChildNodeOf(NodeInterface $node)
{
return $this->getRealMaterializedPath() !== $node->getRealMaterializedPath()
&& 0 === strpos($this->getRealMaterializedPath(), $node->getRealMaterializedPath());
}
/**
* {@inheritdoc}
**/
public function isChildNodeOf(NodeInterface $node)
{
return $this->getParentMaterializedPath() === $node->getRealMaterializedPath();
}
/**
* {@inheritdoc}
**/
public function setChildNodeOf(NodeInterface $node = null)
{
$id = $this->getNodeId();
if (empty($id)) {
throw new \LogicException('You must provide an id for this node if you want it to be part of a tree.');
}
$path = null !== $node
? rtrim($node->getRealMaterializedPath(), static::getMaterializedPathSeparator())
: static::getMaterializedPathSeparator()
;
$this->setMaterializedPath($path);
if (null !== $this->parentNode) {
$this->parentNode->getChildNodes()->removeElement($this);
}
$this->parentNode = $node;
if (null !== $node) {
$this->parentNode->addChildNode($this);
}
foreach ($this->getChildNodes() as $child) {
$child->setChildNodeOf($this);
}
return $this;
}
/**
* {@inheritdoc}
**/
public function getParentNode()
{
return $this->parentNode;
}
/**
* {@inheritdoc}
**/
public function setParentNode(NodeInterface $node)
{
$this->parentNode = $node;
$this->setChildNodeOf($this->parentNode);
return $this;
}
/**
* {@inheritdoc}
**/
public function getRootNode()
{
$parent = $this;
while (null !== $parent->getParentNode()) {
$parent = $parent->getParentNode();
}
return $parent;
}
/**
* {@inheritdoc}
**/
public function buildTree(array $results)
{
$this->getChildNodes()->clear();
foreach ($results as $i => $node) {
if ($node->getMaterializedPath() === $this->getRealMaterializedPath()) {
$node->setParentNode($this);
$node->buildTree($results);
}
}
}
/**
* @param \Closure $prepare a function to prepare the node before putting into the result
*
* @return string the json representation of the hierarchical result
**/
public function toJson(\Closure $prepare = null)
{
$tree = $this->toArray($prepare);
return json_encode($tree);
}
/**
* @param \Closure $prepare a function to prepare the node before putting into the result
* @param array $tree a reference to an array, used internally for recursion
*
* @return array the hierarchical result
**/
public function toArray(\Closure $prepare = null, array &$tree = null)
{
if (null === $prepare) {
$prepare = function(NodeInterface $node) {
return (string) $node;
};
}
if (null === $tree) {
$tree = array($this->getNodeId() => array('node' => $prepare($this), 'children' => array()));
}
foreach ($this->getChildNodes() as $node) {
$tree[$this->getNodeId()]['children'][$node->getNodeId()] = array('node' => $prepare($node), 'children' => array());
$node->toArray($prepare, $tree[$this->getNodeId()]['children']);
}
return $tree;
}
/**
* @param \Closure $prepare a function to prepare the node before putting into the result
* @param array $tree a reference to an array, used internally for recursion
*
* @return array the flatten result
**/
public function toFlatArray(\Closure $prepare = null, array &$tree = null)
{
if (null === $prepare) {
$prepare = function(NodeInterface $node) {
$pre = $node->getNodeLevel() > 1 ? implode('', array_fill(0, $node->getNodeLevel(), '--')) : '';
return $pre.(string) $node;
};
}
if (null === $tree) {
$tree = array($this->getNodeId() => $prepare($this));
}
foreach ($this->getChildNodes() as $node) {
$tree[$node->getNodeId()] = $prepare($node);
$node->toFlatArray($prepare, $tree);
}
return $tree;
}
public function offsetSet($offset, $node)
{
$node->setChildNodeOf($this);
return $this;
}
public function offsetExists($offset)
{
return isset($this->getChildNodes()[$offset]);
}
public function offsetUnset($offset)
{
unset($this->getChildNodes()[$offset]);
}
public function offsetGet($offset)
{
return $this->getChildNodes()[$offset];
}
/**
* {@inheritdoc}
**/
protected function getExplodedPath()
{
$path = explode(static::getMaterializedPathSeparator(), $this->getRealMaterializedPath());
return array_filter($path, function($item) {
return '' !== $item;
});
}
}
Mini Shell