1. <?php
3. namespace Jackalope;
5. use ArrayIterator;
6. use Iterator;
7. use IteratorAggregate;
8. use Exception;
9. use InvalidArgumentException;
10. use Jackalope\NodeType\NodeType;
11. use LogicException;
12. use PHPCR\AccessDeniedException;
13. use PHPCR\Lock\LockException;
14. use PHPCR\NamespaceException;
15. use PHPCR\NodeType\NodeDefinitionInterface;
16. use PHPCR\NodeType\NodeTypeInterface;
17. use PHPCR\PropertyType;
18. use PHPCR\NodeInterface;
19. use PHPCR\NodeType\ConstraintViolationException;
20. use PHPCR\NodeType\NoSuchNodeTypeException;
21. use PHPCR\RepositoryException;
22. use PHPCR\PathNotFoundException;
23. use PHPCR\ItemNotFoundException;
24. use PHPCR\InvalidItemStateException;
25. use PHPCR\ItemExistsException;
26. use PHPCR\UnsupportedRepositoryOperationException;
27. use PHPCR\Util\PathHelper;
28. use PHPCR\Util\NodeHelper;
29. use PHPCR\Util\UUIDHelper;
30. use PHPCR\ValueFormatException;
31. use PHPCR\Version\VersionException;
33. /**
34.  * {@inheritDoc}
35.  *
36.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
37.  * @license http://opensource.org/licenses/MIT MIT License
38.  *
39.  * @api
40.  */
41. class Node extends Item implements IteratorAggregate, NodeInterface
42. {
43.     /**
44.      * The index if this is a same-name sibling.
45.      *
46.      * TODO: fully implement same-name siblings
47.      * @var int
48.      */
49.     protected $index = 1;
51.     /**
52.      * The primary type name of this node
53.      *
54.      * @var string
55.      */
56.     protected $primaryType;
58.     /**
59.      * mapping of property name to PropertyInterface objects.
60.      *
61.      * all properties are instantiated in the constructor
62.      *
63.      * OPTIMIZE: lazy instantiate property objects, just have local array of values
64.      *
65.      * @var Property[]
66.      */
67.     protected $properties = [];
69.     /**
70.      * keep track of properties to be deleted until the save operation was successful.
71.      *
72.      * this is needed in order to track deletions in case of refresh
73.      *
74.      * keys are the property names, values the properties (in state deleted)
75.      */
76.     protected $deletedProperties = [];
78.     /**
79.      * ordered list of the child node names
80.      *
81.      * @var array
82.      */
83.     protected $nodes = [];
85.     /**
86.      * ordered list of the child node names as known to be at the backend
87.      *
88.      * used to calculate reordering operations if orderBefore() was used
89.      *
90.      * @var array
91.      */
92.     protected $originalNodesOrder = null;
94.     /**
95.      * Cached instance of the node definition that defines this node
96.      *
97.      * @var NodeDefinitionInterface
98.      * @see Node::getDefinition()
99.      */
100.     protected $definition;
102.     /**
103.      * Create a new node instance with data from the storage layer
104.      *
105.      * This is only to be called by the Factory::get() method even inside the
106.      * Jackalope implementation to allow for custom implementations of Nodes.
107.      *
108.      * @param FactoryInterface $factory       the object factory
109.      * @param array            $rawData       in the format as returned from TransportInterface::getNode
110.      * @param string           $path          the absolute path of this node
111.      * @param Session          $session
112.      * @param ObjectManager    $objectManager
113.      * @param boolean          $new           set to true if this is a new node being created.
114.      *      Defaults to false which means the node is loaded from storage.
115.      *
116.      * @see TransportInterface::getNode()
117.      *
118.      * @throws RepositoryException
119.      *
120.      * @private
121.      */
122.     public function __construct(FactoryInterface $factory, $rawData, $path, Session $session, ObjectManager $objectManager, $new = false)
123.     {
124.         parent::__construct($factory, $path, $session, $objectManager, $new);
125.         $this->isNode = true;
127.         $this->parseData($rawData, false);
128.     }
130.     /**
131.      * Initialize or update this object with raw data from backend.
132.      *
133.      * @param array $rawData in the format as returned from Jackalope\Transport\TransportInterface
134.      * @param boolean $update whether to initialize this object or update
135.      * @param boolean $keepChanges only used if $update is true, same as $keepChanges in refresh()
136.      *
137.      * @see Node::__construct()
138.      * @see Node::refresh()
139.      *
140.      * @throws \InvalidArgumentException
141.      * @throws LockException
142.      * @throws ConstraintViolationException
143.      * @throws RepositoryException
144.      * @throws ValueFormatException
145.      * @throws VersionException
146.      */
147.     private function parseData($rawData, $update, $keepChanges = false)
148.     {
149.         //TODO: refactor to use hash array instead of stdClass struct
151.         if ($update) {
152.             // keep backup of old state so we can remove what needs to be removed
153.             $oldNodes = array_flip(array_values($this->nodes));
154.             $oldProperties = $this->properties;
155.         }
156.         /*
157.          * we collect all nodes coming from the backend. if we update with
158.          * $keepChanges, we use this to update the node list rather than losing
159.          * reorders
160.          *
161.          * properties are easy as they are not ordered.
162.          */
163.         $nodesInBackend = [];
165.         foreach ($rawData as $key => $value) {
166.             $node = false; // reset to avoid trouble
167.             if (is_object($value)) {
168.                 // this is a node. add it if
169.                 if (! $update // init new node
170.                     || ! $keepChanges // want to discard changes
171.                     || isset($oldNodes[$key]) // it was already existing before reloading
172.                     || ! ($node = $this->objectManager->getCachedNode($this->path . '/' . $key)) // we know nothing about it
173.                 ) {
174.                     // for all those cases, if the node was moved away or is deleted in current session, we do not add it
175.                     if (! $this->objectManager->isNodeMoved($this->path . '/' . $key)
176.                         && ! $this->objectManager->isNodeDeleted($this->path . '/' . $key)
177.                     ) {
178.                         // otherwise we (re)load a node from backend but a child has been moved away already
179.                         $nodesInBackend[] = $key;
180.                     }
181.                 }
182.                 if ($update) {
183.                     unset($oldNodes[$key]);
184.                 }
185.             } else {
186.                 //property or meta information
188.                 /* Property type declarations start with :, the value then is
189.                  * the type string from the NodeType constants. We skip that and
190.                  * look at the type when we encounter the value of the property.
191.                  *
192.                  * If its a binary data, we only get the type declaration and
193.                  * no data. Then the $value of the type declaration is not the
194.                  * type string for binary, but the number of bytes of the
195.                  * property - resp. array of number of bytes.
196.                  *
197.                  * The magic property ::NodeIteratorSize tells this node has no
198.                  * children. Ignore that info for now. We might optimize with
199.                  * this info once we do prefetch nodes.
200.                  */
201.                 if (0 === strpos($key, ':')) {
202.                     if ((is_int($value) || is_array($value))
203.                          && $key != '::NodeIteratorSize'
204.                     ) {
205.                         // This is a binary property and we just got its length with no data
206.                         $key = substr($key, 1);
207.                         if (!isset($rawData->$key)) {
208.                             $binaries[$key] = $value;
209.                             if ($update) {
210.                                 unset($oldProperties[$key]);
211.                             }
212.                             if (isset($this->properties[$key])) {
213.                                 // refresh existing binary, this will only happen in update
214.                                 // only update length
215.                                 if (! ($keepChanges && $this->properties[$key]->isModified())) {
216.                                     $this->properties[$key]->_setLength($value);
217.                                     if ($this->properties[$key]->isDirty()) {
218.                                         $this->properties[$key]->setClean();
219.                                     }
220.                                 }
221.                             } else {
222.                                 // this will always fall into the creation mode
223.                                 $this->_setProperty($key, $value, PropertyType::BINARY, true);
224.                             }
225.                         }
226.                     } //else this is a type declaration
228.                     //skip this entry (if its binary, its already processed
229.                     continue;
230.                 }
232.                 if ($update && array_key_exists($key, $this->properties)) {
233.                     unset($oldProperties[$key]);
234.                     $prop = $this->properties[$key];
235.                     if ($keepChanges && $prop->isModified()) {
236.                         continue;
237.                     }
238.                 } elseif ($update && array_key_exists($key, $this->deletedProperties)) {
239.                     if ($keepChanges) {
240.                         // keep the delete
241.                         continue;
242.                     } else {
243.                         // restore the property
244.                         $this->properties[$key] = $this->deletedProperties[$key];
245.                         $this->properties[$key]->setClean();
246.                         // now let the loop update the value. no need to talk to ObjectManager as it
247.                         // does not store property deletions
248.                     }
249.                 }
251.                 switch ($key) {
252.                     case 'jcr:index':
253.                         $this->index = $value;
254.                         break;
255.                     case 'jcr:primaryType':
256.                         $this->primaryType = $value;
257.                         // type information is exposed as property too,
258.                         // although there exist more specific methods
259.                         $this->_setProperty('jcr:primaryType', $value, PropertyType::NAME, true);
260.                         break;
261.                     case 'jcr:mixinTypes':
262.                         // type information is exposed as property too,
263.                         // although there exist more specific methods
264.                         $this->_setProperty($key, $value, PropertyType::NAME, true);
265.                         break;
267.                     // OPTIMIZE: do not instantiate properties until needed
268.                     default:
269.                         if (isset($rawData->{':' . $key})) {
270.                             /*
271.                              * this is an inconsistency between jackrabbit and
272.                              * dbal transport: jackrabbit has type name, dbal
273.                              * delivers numeric type.
274.                              * we should eventually fix the format returned by
275.                              * transport and either have jackrabbit transport
276.                              * do the conversion or let dbal store a string
277.                              * value instead of numerical.
278.                              */
279.                             $type = is_numeric($rawData->{':' . $key})
280.                                     ? $rawData->{':' . $key}
281.                                     : PropertyType::valueFromName($rawData->{':' . $key});
282.                         } else {
283.                             $type = $this->valueConverter->determineType($value);
284.                         }
285.                         $this->_setProperty($key, $value, $type, true);
286.                         break;
287.                 }
288.             }
289.         }
291.         if ($update) {
292.             if ($keepChanges) {
293.                 // we keep changes. merge new nodes to the right place
294.                 $previous = null;
295.                 $newFromBackend = array_diff($nodesInBackend, array_intersect($this->nodes, $nodesInBackend));
297.                 foreach ($newFromBackend as $name) {
298.                     $pos = array_search($name, $nodesInBackend);
299.                     if (is_array($this->originalNodesOrder)) {
300.                         // update original order to send the correct reorderings
301.                         array_splice($this->originalNodesOrder, $pos, 0, $name);
302.                     }
303.                     if ($pos === 0) {
304.                         array_unshift($this->nodes, $name);
305.                     } else {
306.                         // do we find the predecessor of the new node in the list?
307.                         $insert = array_search($nodesInBackend[$pos-1], $this->nodes);
308.                         if (false !== $insert) {
309.                             array_splice($this->nodes, $insert + 1, 0, $name);
310.                         } else {
311.                             // failed to find predecessor, add to the end
312.                             $this->nodes[] = $name;
313.                         }
314.                     }
315.                 }
316.             } else {
317.                 // discard changes, just overwrite node list
318.                 $this->nodes = $nodesInBackend;
319.                 $this->originalNodesOrder = null;
320.             }
321.             foreach ($oldProperties as $name => $property) {
322.                 if (! ($keepChanges && ($property->isNew()))) {
323.                     // may not call remove(), we don't want another delete with
324.                     // the backend to be attempted
325.                     $this->properties[$name]->setDeleted();
326.                     unset($this->properties[$name]);
327.                 }
328.             }
330.             // notify nodes that where not received again that they disappeared
331.             foreach ($oldNodes as $name => $index) {
332.                 if ($this->objectManager->purgeDisappearedNode($this->path . '/' . $name, $keepChanges)) {
333.                     // drop, it was not a new child
334.                     if ($keepChanges) { // otherwise we overwrote $this->nodes with the backend
335.                         $id = array_search($name, $this->nodes);
336.                         if (false !== $id) {
337.                             unset($this->nodes[$id]);
338.                         }
339.                     }
340.                 }
341.             }
342.         } else {
343.             // new node loaded from backend
344.             $this->nodes = $nodesInBackend;
345.         }
346.     }
348.     /**
349.      * Creates a new node at the specified $relPath
350.      *
351.      * {@inheritDoc}
352.      *
353.      * In Jackalope, the child node type definition is immediately applied if no
354.      * primaryNodeTypeName is specified.
355.      *
356.      * The PathNotFoundException and ConstraintViolationException are thrown
357.      * immediately.
358.      * Version and Lock related exceptions are delayed until save.
359.      *
360.      * @api
361.      */
362.     public function addNode($relPath, $primaryNodeTypeName = null)
363.     {
364.         $relPath = (string)$relPath;
366.         $this->checkState();
368.         $ntm = $this->session->getWorkspace()->getNodeTypeManager();
370.         // are we not the immediate parent?
371.         if (strpos($relPath, '/') !== false) {
372.             // forward to real parent
374.             $relPath = PathHelper::absolutizePath($relPath, $this->getPath(), true);
375.             $parentPath = PathHelper::getParentPath($relPath);
376.             $newName = PathHelper::getNodeName($relPath);
378.             try {
379.                 $parentNode = $this->objectManager->getNodeByPath($parentPath);
380.             } catch (ItemNotFoundException $e) {
381.                 //we have to throw a different exception if there is a property
382.                 // with that name than if there is nothing at the path at all.
383.                 // lets see if the property exists
384.                 if ($this->session->propertyExists($parentPath)) {
385.                     throw new ConstraintViolationException("Node '{$this->path}': Not allowed to add a node below property at $parentPath");
386.                 }
388.                 throw new PathNotFoundException($e->getMessage(), $e->getCode(), $e);
389.             }
391.             return $parentNode->addNode($newName, $primaryNodeTypeName);
392.         }
394.         if (null === $primaryNodeTypeName) {
395.             if ($this->primaryType === 'rep:root') {
396.                 $primaryNodeTypeName = 'nt:unstructured';
397.             } else {
398.                 $type = $ntm->getNodeType($this->primaryType);
399.                 $nodeDefinitions = $type->getChildNodeDefinitions();
400.                 foreach ($nodeDefinitions as $def) {
401.                     if (!is_null($def->getDefaultPrimaryType())) {
402.                         $primaryNodeTypeName = $def->getDefaultPrimaryTypeName();
403.                         break;
404.                     }
405.                 }
406.             }
408.             if (is_null($primaryNodeTypeName)) {
409.                 throw new ConstraintViolationException("No matching child node definition found for `$relPath' in type `{$this->primaryType}' for node '{$this->path}'. Please specify the type explicitly.");
410.             }
411.         }
413.         // create child node
414.         //sanity check: no index allowed. TODO: we should verify this is a valid node name
415.         if (false !== strpos($relPath, ']')) {
416.             throw new RepositoryException("The node '{$this->path}' does not allow an index in name of newly created node: $relPath");
417.         }
418.         if (in_array($relPath, $this->nodes, true)) {
419.             throw new ItemExistsException("The node '{$this->path}' already has a child named '$relPath''."); //TODO: same-name siblings if nodetype allows for them
420.         }
422.         $data = ['jcr:primaryType' => $primaryNodeTypeName];
423.         $path = $this->getChildPath($relPath);
424.         $node = $this->factory->get(Node::class, [$data, $path, $this->session, $this->objectManager, true]);
426.         $this->addChildNode($node, false); // no need to check the state, we just checked when entering this method
427.         $this->objectManager->addNode($path, $node);
429.         if (is_array($this->originalNodesOrder)) {
430.             // new nodes are added at the end
431.             $this->originalNodesOrder[] = $relPath;
432.         }
433.         //by definition, adding a node sets the parent to modified
434.         $this->setModified();
436.         return $node;
437.     }
439.     /**
440.      * {@inheritDoc}
441.      *
442.      * @api
443.      * @throws InvalidArgumentException
444.      * @throws ItemExistsException
445.      * @throws PathNotFoundException
446.      * @throws RepositoryException
447.      */
448.     public function addNodeAutoNamed($nameHint = null, $primaryNodeTypeName = null)
449.     {
450.         $name = NodeHelper::generateAutoNodeName(
451.             $this->nodes,
452.             $this->session->getWorkspace()->getNamespaceRegistry()->getNamespaces(),
453.             'jcr',
454.             $nameHint
455.         );
457.         return $this->addNode($name, $primaryNodeTypeName);
458.     }
460.     /**
461.      * Jackalope implements this feature and updates the position of the
462.      * existing child at srcChildRelPath to be in the list immediately before
463.      * destChildRelPath.
464.      *
465.      * {@inheritDoc}
466.      *
467.      * Jackalope has no implementation-specific ordering restriction so no
468.      * \PHPCR\ConstraintViolationException is expected. VersionException and
469.      * LockException are not tested immediately but thrown on save.
470.      *
471.      * @api
472.      */
473.     public function orderBefore($srcChildRelPath, $destChildRelPath)
474.     {
475.         if ($srcChildRelPath === $destChildRelPath) {
476.             //nothing to move
477.             return;
478.         }
480.         if (null === $this->originalNodesOrder) {
481.             $this->originalNodesOrder = $this->nodes;
482.         }
484.         $this->nodes = NodeHelper::orderBeforeArray($srcChildRelPath, $destChildRelPath, $this->nodes);
485.         $this->setModified();
486.     }
488.     /**
489.      * {@inheritDoc}
490.      *
491.      * @throws PathNotFoundException
492.      *
493.      * @api
494.      * @throws AccessDeniedException
495.      * @throws ItemNotFoundException
496.      * @throws \InvalidArgumentException
497.      */
498.     public function rename($newName)
499.     {
500.         $names = (array) $this->getParent()->getNodeNames();
501.         $pos = array_search($this->name, $names);
502.         $next = isset($names[$pos + 1]) ? $names[$pos + 1] : null;
504.         $newPath = $this->parentPath . '/' . $newName;
506.         if (substr($newPath, 0, 2) === '//') {
507.             $newPath = substr($newPath, 1);
508.         }
510.         $this->session->move($this->path, $newPath);
511.         if ($next) {
512.             $this->getParent()->orderBefore($newName, $next);
513.         }
514.     }
516.     /**
517.      * Determine whether the children of this node need to be reordered
518.      *
519.      * @return boolean
520.      *
521.      * @private
522.      */
523.     public function needsChildReordering()
524.     {
525.         return (bool) $this->originalNodesOrder;
526.     }
528.     /**
529.      * Returns the orderBefore commands to be applied to the childnodes
530.      * to get from the original order to the new one
531.      *
532.      * @return array of arrays with 2 fields: name of node to order before second name
533.      *
534.      * @throws AccessDeniedException
535.      * @throws ItemNotFoundException
536.      *
537.      * @private
538.      */
539.     public function getOrderCommands()
540.     {
541.         if (! $this->originalNodesOrder) {
542.             return [];
543.         }
545.         $reorders = NodeHelper::calculateOrderBefore($this->originalNodesOrder, $this->nodes);
546.         $this->originalNodesOrder = null;
548.         return $reorders;
549.     }
551.     /**
552.      * {@inheritDoc}
553.      *
554.      * @param boolean $validate When false, node types are not asked to validate
555.      *                          whether operation is allowed
556.      *
557.      * @throws InvalidItemStateException
558.      * @throws NamespaceException
559.      * @throws \InvalidArgumentException
560.      * @throws AccessDeniedException
561.      * @throws ItemNotFoundException
562.      *
563.      * @api
564.      */
565.     public function setProperty($name, $value, $type = PropertyType::UNDEFINED, $validate = true)
566.     {
567.         $this->checkState();
569.         // abort early when the node value is not changed
570.         // for multivalue, === is only true when array keys and values match. this is exactly what we need.
571.         try {
572.             if (array_key_exists($name, $this->properties) && $this->properties[$name]->getValue() === $value) {
573.                 return $this->properties[$name];
574.             }
575.         } catch (RepositoryException $e) {
576.             // if anything goes wrong trying to get the property value, move on and don't return early
577.         }
579.         if ($validate && 'jcr:uuid' === $name && !$this->isNodeType('mix:referenceable')) {
580.             throw new ConstraintViolationException('You can only change the uuid of newly created nodes that have "referenceable" mixin.');
581.         }
583.         if ($validate) {
584.             if (is_array($value)) {
585.                 foreach ($value as $key => $v) {
586.                     if (null === $v) {
587.                         unset($value[$key]);
588.                     }
589.                 }
590.             }
591.             $types = $this->getMixinNodeTypes();
592.             array_push($types, $this->getPrimaryNodeType());
593.             if (null !== $value) {
594.                 $exception = null;
595.                 foreach ($types as $nt) {
596.                     /** @var $nt NodeType */
597.                     try {
598.                         $nt->canSetProperty($name, $value, true);
599.                         $exception = null;
600.                         break; // exit loop, we found a valid definition
601.                     } catch (RepositoryException $e) {
602.                         if (null === $exception) {
603.                             $exception = $e;
604.                         }
605.                     }
606.                 }
607.                 if (null !== $exception) {
608.                     $types = 'Primary type '.$this->primaryType;
609.                     if (isset($this->properties['jcr:mixinTypes'])) {
610.                         $types .= ', mixins '.implode(',', $this->getPropertyValue('jcr:mixinTypes', PropertyType::STRING));
611.                     }
612.                     $msg = sprintf('Can not set property %s on node %s. Node types do not allow for this: %s', $name, $this->path, $types);
614.                     throw new ConstraintViolationException($msg, 0, $exception);
615.                 }
616.             } else {
617.                 // $value is null for property removal
618.                 // if any type forbids, throw exception
619.                 foreach ($types as $nt) {
620.                     /** @var $nt \Jackalope\NodeType\NodeType */
621.                     $nt->canRemoveProperty($name, true);
622.                 }
623.             }
624.         }
626.         //try to get a namespace for the set property
627.         if (strpos($name, ':') !== false) {
628.             list($prefix) = explode(':', $name);
629.             //Check if the namespace exists. If not, throw an NamespaceException
630.             $this->session->getNamespaceURI($prefix);
631.         }
633.         if (is_null($value)) {
634.             if (isset($this->properties[$name])) {
635.                 $this->properties[$name]->remove();
636.             }
638.             return null;
639.         }
641.         // if the property is the UUID, then register the UUID against the path
642.         // of this node.
643.         if ('jcr:uuid' === $name) {
644.             $this->objectManager->registerUuid($value, $this->getPath());
645.         }
647.         return $this->_setProperty($name, $value, $type, false);
648.     }
650.     /**
651.      * {@inheritDoc}
652.      *
653.      * @throws InvalidItemStateException
654.      *
655.      * @api
656.      */
657.     public function getNode($relPath)
658.     {
659.         $this->checkState();
661.         $relPath = (string) $relPath;
663.         if ('' === $relPath || '/' === $relPath[0]) {
664.             throw new PathNotFoundException("$relPath is not a relative path");
665.         }
667.         try {
668.             $node = $this->objectManager->getNodeByPath(PathHelper::absolutizePath($relPath, $this->path));
669.         } catch (ItemNotFoundException $e) {
670.             throw new PathNotFoundException($e->getMessage(), $e->getCode(), $e);
671.         }
673.         return $node;
674.     }
676.     /**
677.      * {@inheritDoc}
678.      *
679.      * @api
680.      */
681.     public function getNodes($nameFilter = null, $typeFilter = null)
682.     {
683.         $this->checkState();
685.         $names = self::filterNames($nameFilter, $this->nodes);
686.         $result = [];
688.         if (count($names)) {
689.             $paths = [];
690.             foreach ($names as $name) {
691.                 $paths[] = PathHelper::absolutizePath($name, $this->path);
692.             }
693.             $nodes = $this->objectManager->getNodesByPath($paths, Node::class, $typeFilter);
695.             // OPTIMIZE if we lazy-load in ObjectManager we should not do this loop
696.             foreach ($nodes as $node) {
697.                 $result[$node->getName()] = $node;
698.             }
699.         }
701.         return new ArrayIterator($result);
702.     }
704.     /**
705.      * {@inheritDoc}
706.      *
707.      * @api
708.      */
709.     public function getNodeNames($nameFilter = null, $typeFilter = null)
710.     {
711.         $this->checkState();
713.         if (null !== $typeFilter) {
714.             return $this->objectManager->filterChildNodeNamesByType($this, $nameFilter, $typeFilter);
715.         }
717.         $names = self::filterNames($nameFilter, $this->nodes);
719.         return new ArrayIterator($names);
720.     }
722.     /**
723.      * {@inheritDoc}
724.      *
725.      * @throws InvalidItemStateException
726.      *
727.      * @api
728.      */
729.     public function getProperty($relPath)
730.     {
731.         $this->checkState();
733.         if (false === strpos($relPath, '/')) {
734.             if (!isset($this->properties[$relPath])) {
735.                 throw new PathNotFoundException("Property $relPath in ".$this->path);
736.             }
737.             if ($this->properties[$relPath]->isDeleted()) {
738.                 throw new PathNotFoundException("Property '$relPath' of " . $this->path . ' is deleted');
739.             }
741.             return $this->properties[$relPath];
742.         }
744.         return $this->session->getProperty($this->getChildPath($relPath));
745.     }
747.     /**
748.      * This method is only meant for the transport to be able to still build a
749.      * store request for afterwards deleted nodes to support the operationslog.
750.      *
751.      * @return Property[] with just the jcr:primaryType property in it
752.      *
753.      * @see \Jackalope\Transport\WritingInterface::storeNodes
754.      *
755.      * @throws InvalidItemStateException
756.      * @throws RepositoryException
757.      *
758.      * @private
759.      */
760.     public function getPropertiesForStoreDeletedNode()
761.     {
762.         if (! $this->isDeleted()) {
763.             throw new InvalidItemStateException('You are not supposed to call this on a not deleted node');
764.         }
765.         $myProperty = $this->properties['jcr:primaryType'];
766.         $myProperty->setClean();
767.         $path = $this->getChildPath('jcr:primaryType');
768.         $property = $this->factory->get(
769.             'Property',
770.             [['type' => $myProperty->getType(), 'value' => $myProperty->getValue()],
771.                 $path,
772.                 $this->session,
773.                 $this->objectManager
774.             ]
775.         );
776.         $myProperty->setDeleted();
778.         return ['jcr:primaryType' => $property];
779.     }
781.     /**
782.      * {@inheritDoc}
783.      *
784.      * @throws InvalidItemStateException
785.      * @throws \InvalidArgumentException
786.      *
787.      * @api
788.      */
789.     public function getPropertyValue($name, $type = null)
790.     {
791.         $this->checkState();
793.         $val = $this->getProperty($name)->getValue();
794.         if (null !== $type) {
795.             $val = $this->valueConverter->convertType($val, $type);
796.         }
798.         return $val;
799.     }
801.     /**
802.      * {@inheritDoc}
803.      *
804.      * @throws \InvalidArgumentException
805.      *
806.      * @throws InvalidItemStateException
807.      * @throws PathNotFoundException
808.      * @throws ValueFormatException
809.      *
810.      * @api
811.      */
812.     public function getPropertyValueWithDefault($relPath, $defaultValue)
813.     {
814.         if ($this->hasProperty($relPath)) {
815.             return $this->getPropertyValue($relPath);
816.         }
818.         return $defaultValue;
819.     }
821.     /**
822.      * {@inheritDoc}
823.      *
824.      * @api
825.      */
826.     public function getProperties($nameFilter = null)
827.     {
828.         $this->checkState();
830.         //OPTIMIZE: lazy iterator?
831.         $names = self::filterNames($nameFilter, array_keys($this->properties));
832.         $result = [];
834.         foreach ($names as $name) {
835.             //we know for sure the properties exist, as they come from the
836.             // array keys of the array we are accessing
837.             $result[$name] = $this->properties[$name];
838.         }
840.         return new ArrayIterator($result);
841.     }
843.     /**
844.      * {@inheritDoc}
845.      *
846.      * @throws \InvalidArgumentException
847.      * @throws InvalidItemStateException
848.      * @throws ValueFormatException
849.      * @throws ItemNotFoundException
850.      *
851.      * @api
852.      */
853.     public function getPropertiesValues($nameFilter = null, $dereference = true)
854.     {
855.         $this->checkState();
857.         // OPTIMIZE: do not create properties in constructor, go over array here
858.         $names = self::filterNames($nameFilter, array_keys($this->properties));
859.         $result = [];
861.         foreach ($names as $name) {
862.             //we know for sure the properties exist, as they come from the
863.             // array keys of the array we are accessing
864.             $type = $this->properties[$name]->getType();
865.             if (! $dereference &&
866.                     (PropertyType::REFERENCE === $type
867.                     || PropertyType::WEAKREFERENCE === $type
868.                     || PropertyType::PATH === $type)
869.             ) {
870.                 $result[$name] = $this->properties[$name]->getString();
871.             } else {
872.                 // OPTIMIZE: collect the paths and call objectmanager->getNodesByPath once
873.                 $result[$name] = $this->properties[$name]->getValue();
874.             }
875.         }
877.         return $result;
878.     }
880.     /**
881.      * {@inheritDoc}
882.      *
883.      * @api
884.      */
885.     public function getPrimaryItem()
886.     {
887.         try {
888.             $primary_item = null;
889.             $item_name = $this->getPrimaryNodeType()->getPrimaryItemName();
891.             if ($item_name !== null) {
892.                 $primary_item = $this->session->getItem($this->path . '/' . $item_name);
893.             }
894.         } catch (Exception $ex) {
895.             throw new RepositoryException("An error occured while reading the primary item of the node '{$this->path}': " . $ex->getMessage());
896.         }
898.         if ($primary_item === null) {
899.             throw new ItemNotFoundException("No primary item found for node '{$this->path}'");
900.         }
902.         return $primary_item;
903.     }
905.     /**
906.      * @return string a universally unique id.
907.      */
908.     protected function generateUuid()
909.     {
910.         return UUIDHelper::generateUUID();
911.     }
913.     /**
914.      * {@inheritDoc}
915.      *
916.      * @throws \InvalidArgumentException
917.      *
918.      * @throws AccessDeniedException
919.      * @throws InvalidItemStateException
920.      * @throws ItemNotFoundException
921.      * @throws LockException
922.      * @throws NamespaceException
923.      * @throws ConstraintViolationException
924.      * @throws ValueFormatException
925.      * @throws VersionException
926.      * @throws PathNotFoundException
927.      *
928.      * @api
929.      */
930.     public function getIdentifier()
931.     {
932.         $this->checkState();
934.         if ($this->isNodeType('mix:referenceable')) {
935.             if (empty($this->properties['jcr:uuid'])) {
936.                 $this->setProperty('jcr:uuid', $this->generateUuid());
937.             }
939.             return $this->getPropertyValue('jcr:uuid');
940.         }
942.         return $this->getPath();
943.     }
945.     /**
946.      * {@inheritDoc}
947.      *
948.      * @api
949.      */
950.     public function getIndex()
951.     {
952.         $this->checkState();
954.         return $this->index;
955.     }
957.     /**
958.      * {@inheritDoc}
959.      *
960.      * @api
961.      */
962.     public function getReferences($name = null)
963.     {
964.         $this->checkState();
966.         return $this->objectManager->getReferences($this->path, $name);
967.     }
969.     /**
970.      * {@inheritDoc}
971.      *
972.      * @api
973.      */
974.     public function getWeakReferences($name = null)
975.     {
976.         $this->checkState();
978.         return $this->objectManager->getWeakReferences($this->path, $name);
979.     }
981.     /**
982.      * {@inheritDoc}
983.      *
984.      * @api
985.      */
986.     public function hasNode($relPath)
987.     {
988.         $this->checkState();
990.         if (false === strpos($relPath, '/')) {
991.             return array_search($relPath, $this->nodes) !== false;
992.         }
994.         if (! strlen($relPath) || $relPath[0] === '/') {
995.             throw new InvalidArgumentException("'$relPath' is not a relative path");
996.         }
998.         return $this->session->nodeExists($this->getChildPath($relPath));
999.     }
1001.     /**
1002.      * {@inheritDoc}
1003.      *
1004.      * @api
1005.      */
1006.     public function hasProperty($relPath)
1007.     {
1008.         $this->checkState();
1010.         if (false === strpos($relPath, '/')) {
1011.             return isset($this->properties[$relPath]);
1012.         }
1013.         if (! strlen($relPath) || $relPath[0] === '/') {
1014.             throw new InvalidArgumentException("'$relPath' is not a relative path");
1015.         }
1017.         return $this->session->propertyExists($this->getChildPath($relPath));
1018.     }
1020.     /**
1021.      * {@inheritDoc}
1022.      *
1023.      * @api
1024.      */
1025.     public function hasNodes()
1026.     {
1027.         $this->checkState();
1029.         return count($this->nodes) !== 0;
1030.     }
1032.     /**
1033.      * {@inheritDoc}
1034.      *
1035.      * @api
1036.      */
1037.     public function hasProperties()
1038.     {
1039.         $this->checkState();
1041.         return count($this->properties) !== 0;
1042.     }
1044.     /**
1045.      * {@inheritDoc}
1046.      *
1047.      * @api
1048.      */
1049.     public function getPrimaryNodeType()
1050.     {
1051.         $this->checkState();
1053.         $ntm = $this->session->getWorkspace()->getNodeTypeManager();
1055.         return $ntm->getNodeType($this->primaryType);
1056.     }
1058.     /**
1059.      * {@inheritDoc}
1060.      *
1061.      * @api
1062.      */
1063.     public function getMixinNodeTypes()
1064.     {
1065.         $this->checkState();
1067.         if (!isset($this->properties['jcr:mixinTypes'])) {
1068.             return [];
1069.         }
1071.         $res = [];
1072.         $ntm = $this->session->getWorkspace()->getNodeTypeManager();
1074.         foreach ($this->properties['jcr:mixinTypes']->getValue() as $type) {
1075.             $res[] = $ntm->getNodeType($type);
1076.         }
1078.         return $res;
1079.     }
1081.     /**
1082.      * {@inheritDoc}
1083.      *
1084.      * @api
1085.      */
1086.     public function isNodeType($nodeTypeName)
1087.     {
1088.         $this->checkState();
1090.         // is it the primary type?
1091.         if ($this->primaryType === $nodeTypeName) {
1092.             return true;
1093.         }
1094.         // is it one of the mixin types?
1095.         if (isset($this->properties['jcr:mixinTypes'])) {
1096.             if (in_array($nodeTypeName, $this->properties["jcr:mixinTypes"]->getValue())) {
1097.                 return true;
1098.             }
1099.         }
1100.         $ntm = $this->session->getWorkspace()->getNodeTypeManager();
1101.         // is the primary type a subtype of the type?
1102.         if ($ntm->getNodeType($this->primaryType)->isNodeType($nodeTypeName)) {
1103.             return true;
1104.         }
1105.         // if there are no mixin types, then we now know this node is not of that type
1106.         if (! isset($this->properties["jcr:mixinTypes"])) {
1107.             return false;
1108.         }
1109.         // is it an ancestor of any of the mixin types?
1110.         foreach ($this->properties['jcr:mixinTypes'] as $mixin) {
1111.             if ($ntm->getNodeType($mixin)->isNodeType($nodeTypeName)) {
1112.                 return true;
1113.             }
1114.         }
1116.         return false;
1117.     }
1119.     /**
1120.      * Changes the primary node type of this node to nodeTypeName.
1121.      *
1122.      * {@inheritDoc}
1123.      *
1124.      * Jackalope only validates type conflicts on save.
1125.      *
1126.      * @throws InvalidItemStateException
1127.      *
1128.      * @api
1129.      */
1130.     public function setPrimaryType($nodeTypeName)
1131.     {
1132.         $this->checkState();
1134.         throw new NotImplementedException('Write');
1135.     }
1137.     /**
1138.      * {@inheritDoc}
1139.      *
1140.      * Jackalope validates type conflicts only on save, not immediately.
1141.      * It is possible to add mixin types after the first save.
1142.      *
1143.      * @api
1144.      */
1145.     public function addMixin($mixinName)
1146.     {
1147.         // Check if mixinName exists as a mixin type
1148.         $typemgr = $this->session->getWorkspace()->getNodeTypeManager();
1149.         $nodeType = $typemgr->getNodeType($mixinName);
1150.         if (! $nodeType->isMixin()) {
1151.             throw new ConstraintViolationException("Trying to add a mixin '$mixinName' that is a primary type");
1152.         }
1154.         $this->checkState();
1156.         // TODO handle LockException & VersionException cases
1157.         if ($this->hasProperty('jcr:mixinTypes')) {
1158.             if (!in_array($mixinName, $this->properties['jcr:mixinTypes']->getValue())) {
1159.                 $this->properties['jcr:mixinTypes']->addValue($mixinName);
1160.                 $this->setModified();
1161.             }
1162.         } else {
1163.             $this->setProperty('jcr:mixinTypes', [$mixinName], PropertyType::NAME);
1164.             $this->setModified();
1165.         }
1166.     }
1168.     /**
1169.      * {@inheritDoc}
1170.      *
1171.      * @throws InvalidItemStateException
1172.      *
1173.      * @throws \InvalidArgumentException
1174.      * @throws AccessDeniedException
1175.      * @throws ItemNotFoundException
1176.      * @throws PathNotFoundException
1177.      * @throws NamespaceException
1178.      * @throws ValueFormatException
1179.      *
1180.      * @api
1181.      */
1182.     public function removeMixin($mixinName)
1183.     {
1184.         $this->checkState();
1186.         // check if node type is assigned
1187.         if (! $this->hasProperty('jcr:mixinTypes')) {
1188.             throw new NoSuchNodeTypeException("Node does not have type $mixinName");
1189.         }
1191.         $mixins = $this->getPropertyValue('jcr:mixinTypes');
1192.         $key = array_search($mixinName, $mixins);
1193.         if (false === $key) {
1194.             throw new NoSuchNodeTypeException("Node does not have type $mixinName");
1195.         }
1197.         unset($mixins[$key]);
1198.         $this->setProperty('jcr:mixinTypes', $mixins); // might be empty array which is fine
1199.     }
1201.     /**
1202.      * {@inheritDoc}
1203.      *
1204.      * @throws \InvalidArgumentException
1205.      * @throws AccessDeniedException
1206.      * @throws InvalidItemStateException
1207.      * @throws ItemNotFoundException
1208.      * @throws NamespaceException
1209.      * @throws PathNotFoundException
1210.      * @throws ValueFormatException
1211.      *
1212.      * @api
1213.      */
1214.     public function setMixins(array $mixinNames)
1215.     {
1216.         $toRemove = [];
1217.         if ($this->hasProperty('jcr:mixinTypes')) {
1218.             foreach ($this->getPropertyValue('jcr:mixinTypes') as $mixin) {
1219.                 if (false !== $key = array_search($mixin, $mixinNames)) {
1220.                     unset($mixinNames[$key]);
1221.                 } else {
1222.                     $toRemove[] = $mixin;
1223.                 }
1224.             }
1225.         }
1226.         if (! (count($toRemove) || count($mixinNames))) {
1227.             return; // nothing to do
1228.         }
1230.         // make sure the new types actually exist before we add anything
1231.         $ntm = $this->session->getWorkspace()->getNodeTypeManager();
1232.         foreach ($mixinNames as $mixinName) {
1233.             $nodeType = $ntm->getNodeType($mixinName);
1234.             if (! $nodeType->isMixin()) {
1235.                 throw new ConstraintViolationException("Trying to add a mixin '$mixinName' that is a primary type");
1236.             }
1237.         }
1239.         foreach ($mixinNames as $type) {
1240.             $this->addMixin($type);
1241.         }
1243.         foreach ($toRemove as $type) {
1244.             $this->removeMixin($type);
1245.         }
1246.     }
1248.     /**
1249.      * {@inheritDoc}
1250.      *
1251.      * @throws InvalidItemStateException
1252.      *
1253.      * @api
1254.      */
1255.     public function canAddMixin($mixinName)
1256.     {
1257.         $this->checkState();
1259.         throw new NotImplementedException('Write');
1260.     }
1262.     /**
1263.      * {@inheritDoc}
1264.      *
1265.      * @api
1266.      */
1267.     public function getDefinition()
1268.     {
1269.         $this->checkState();
1271.         if ('rep:root' === $this->primaryType) {
1272.             throw new NotImplementedException('what is the definition of the root node?');
1273.         }
1275.         if (empty($this->definition)) {
1276.             $this->definition = $this->findItemDefinition(function (NodeTypeInterface $nt) {
1277.                 return $nt->getChildNodeDefinitions();
1278.             });
1279.         }
1281.         return $this->definition;
1282.     }
1284.     /**
1285.      * {@inheritDoc}
1286.      *
1287.      * @api
1288.      */
1289.     public function update($srcWorkspace)
1290.     {
1291.         $this->checkState();
1293.         if ($this->isNew()) {
1294.             //no node in workspace
1295.             return;
1296.         }
1298.         $this->getSession()->getTransport()->updateNode($this, $srcWorkspace);
1299.         $this->setDirty();
1300.         $this->setChildrenDirty();
1301.     }
1303.     /**
1304.      * {@inheritDoc}
1305.      *
1306.      * @throws InvalidItemStateException
1307.      *
1308.      * @api
1309.      */
1310.     public function getCorrespondingNodePath($workspaceName)
1311.     {
1312.         $this->checkState();
1314.         return $this->getSession()
1315.             ->getTransport()
1316.             ->getNodePathForIdentifier($this->getIdentifier(), $workspaceName);
1317.     }
1319.     /**
1320.      * {@inheritDoc}
1321.      *
1322.      * @api
1323.      */
1324.     public function getSharedSet()
1325.     {
1326.         $this->checkState();
1328.         throw new NotImplementedException();
1329.     }
1331.     /**
1332.      * {@inheritDoc}
1333.      *
1334.      * @throws InvalidItemStateException
1335.      *
1336.      * @api
1337.      */
1338.     public function removeSharedSet()
1339.     {
1340.         $this->checkState();
1341.         $this->setModified();
1343.         throw new NotImplementedException('Write');
1344.     }
1346.     /**
1347.      * {@inheritDoc}
1348.      *
1349.      * @throws InvalidItemStateException
1350.      *
1351.      * @api
1352.      */
1353.     public function removeShare()
1354.     {
1355.         $this->checkState();
1356.         $this->setModified();
1358.         throw new NotImplementedException('Write');
1359.     }
1361.     /**
1362.      * {@inheritDoc}
1363.      *
1364.      * @api
1365.      */
1366.     public function isCheckedOut()
1367.     {
1368.         $this->checkState();
1370.         $workspace = $this->session->getWorkspace();
1371.         $versionManager = $workspace->getVersionManager();
1373.         return $versionManager->isCheckedOut($this->getPath());
1374.     }
1376.     /**
1377.      * {@inheritDoc}
1378.      *
1379.      * @api
1380.      */
1381.     public function isLocked()
1382.     {
1383.         $this->checkState();
1385.         throw new NotImplementedException();
1386.     }
1388.     /**
1389.      * {@inheritDoc}
1390.      *
1391.      * @throws InvalidItemStateException
1392.      *
1393.      * @api
1394.      */
1395.     public function followLifecycleTransition($transition)
1396.     {
1397.         $this->checkState();
1398.         $this->setModified();
1400.         throw new NotImplementedException('Write');
1401.     }
1403.     /**
1404.      * {@inheritDoc}
1405.      *
1406.      * @throws InvalidItemStateException
1407.      *
1408.      * @api
1409.      */
1410.     public function getAllowedLifecycleTransitions()
1411.     {
1412.         $this->checkState();
1414.         throw new NotImplementedException('Write');
1415.     }
1417.     /**
1418.      * Refresh this node
1419.      *
1420.      * {@inheritDoc}
1421.      *
1422.      * This is also called internally to refresh when the node is accessed in
1423.      * state DIRTY.
1424.      *
1425.      * @see Item::checkState
1426.      */
1427.     protected function refresh($keepChanges, $internal = false)
1428.     {
1429.         if (! $internal && $this->isDeleted()) {
1430.             throw new InvalidItemStateException('This item has been removed and can not be refreshed');
1431.         }
1432.         $deleted = false;
1434.         // Get properties and children from backend
1435.         try {
1436.             $json = $this->objectManager->getTransport()->getNode(
1437.                 is_null($this->oldPath)
1438.                     ? $this->path
1439.                     : $this->oldPath
1440.             );
1441.         } catch (ItemNotFoundException $ex) {
1443.             // The node was deleted in another session
1444.             if (! $this->objectManager->purgeDisappearedNode($this->path, $keepChanges)) {
1445.                 throw new LogicException($this->path . " should be purged and not kept");
1446.             }
1447.             $keepChanges = false; // delete never keeps changes
1448.             if (! $internal) {
1449.                 // this is not an internal update
1450.                 $deleted = true;
1451.             }
1453.             // continue with empty data, parseData will notify all cached
1454.             // children and all properties that we are removed
1455.             $json = [];
1456.         }
1458.         $this->parseData($json, true, $keepChanges);
1460.         if ($deleted) {
1461.             $this->setDeleted();
1462.         }
1463.     }
1465.     /**
1466.      * Remove this node
1467.      *
1468.      * {@inheritDoc}
1469.      *
1470.      * A jackalope node needs to notify the parent node about this if it is
1471.      * cached, in addition to \PHPCR\ItemInterface::remove()
1472.      *
1473.      * @uses Node::unsetChildNode()
1474.      *
1475.      * @api
1476.      */
1477.     public function remove()
1478.     {
1479.         $this->checkState();
1480.         $parent = $this->getParent();
1482.         $parentNodeType = $parent->getPrimaryNodeType();
1483.         //will throw a ConstraintViolationException if this node can't be removed
1484.         $parentNodeType->canRemoveNode($this->getName(), true);
1486.         if ($parent) {
1487.             $parent->unsetChildNode($this->name, true);
1488.         }
1489.         // once we removed ourselves, $this->getParent() won't work anymore. do this last
1490.         parent::remove();
1491.     }
1493.     /**
1494.      * Removes the reference in the internal node storage
1495.      *
1496.      * @param string $name  the name of the child node to unset
1497.      * @param bool   $check whether a state check should be done - set to false
1498.      *      during internal update operations
1499.      *
1500.      * @throws ItemNotFoundException If there is no child with $name
1501.      * @throws InvalidItemStateException
1502.      *
1503.      * @private
1504.      */
1505.     public function unsetChildNode($name, $check)
1506.     {
1507.         if ($check) {
1508.             $this->checkState();
1509.         }
1511.         $key = array_search($name, $this->nodes);
1512.         if ($key === false) {
1513.             if (! $check) {
1514.                 // inside a refresh operation
1515.                 return;
1516.             }
1517.             throw new ItemNotFoundException("Could not remove child node because it's already gone");
1518.         }
1520.         unset($this->nodes[$key]);
1522.         if (null !== $this->originalNodesOrder) {
1523.             $this->originalNodesOrder = array_flip($this->originalNodesOrder);
1524.             unset($this->originalNodesOrder[$name]);
1525.             $this->originalNodesOrder = array_flip($this->originalNodesOrder);
1526.         }
1527.     }
1529.     /**
1530.      * Adds child node to this node for internal reference
1531.      *
1532.      * @param NodeInterface $node  The name of the child node
1533.      * @param boolean $check whether to check state
1534.      * @param string  $name  is used in cases where $node->getName would not return the correct name (during move operation)
1535.      *
1536.      * @throws InvalidItemStateException
1537.      * @throws RepositoryException
1538.      *
1539.      * @private
1540.      */
1541.     public function addChildNode(NodeInterface $node, $check, $name = null)
1542.     {
1543.         if ($check) {
1544.             $this->checkState();
1545.         }
1547.         if (is_null($name)) {
1548.             $name = $node->getName();
1549.         }
1551.         $nt = $this->getPrimaryNodeType();
1552.         //will throw a ConstraintViolationException if this node can't be added
1553.         $nt->canAddChildNode($name, $node->getPrimaryNodeType()->getName(), true);
1555.         // TODO: same name siblings
1557.         $this->nodes[] = $name;
1559.         if (null !== $this->originalNodesOrder) {
1560.             $this->originalNodesOrder[] = $name;
1561.         }
1562.     }
1564.     /**
1565.      * Removes the reference in the internal node storage
1566.      *
1567.      * @param string $name the name of the property to unset.
1568.      *
1569.      * @throws ItemNotFoundException If this node has no property with name $name
1570.      * @throws InvalidItemStateException
1571.      * @throws RepositoryException
1572.      *
1573.      * @private
1574.      */
1575.     public function unsetProperty($name)
1576.     {
1577.         $this->checkState();
1578.         $this->setModified();
1580.         if (!array_key_exists($name, $this->properties)) {
1581.             throw new ItemNotFoundException('Implementation Error: Could not remove property from node because it is already gone');
1582.         }
1583.         $this->deletedProperties[$name] = $this->properties[$name];
1584.         unset($this->properties[$name]);
1585.     }
1587.     /**
1588.      * In addition to calling parent method, tell all properties and clean deletedProperties
1589.      */
1590.     public function confirmSaved()
1591.     {
1592.         foreach ($this->properties as $property) {
1593.             if ($property->isModified() || $property->isNew()) {
1594.                 $property->confirmSaved();
1595.             }
1596.         }
1597.         $this->deletedProperties = [];
1598.         parent::confirmSaved();
1599.     }
1601.     /**
1602.      * In addition to calling parent method, tell all properties
1603.      */
1604.     public function setPath($path, $move = false)
1605.     {
1606.         parent::setPath($path, $move);
1607.         foreach ($this->properties as $property) {
1608.             $property->setPath($path.'/'.$property->getName(), $move);
1609.         }
1610.     }
1612.     /**
1613.      * Make sure $p is an absolute path
1614.      *
1615.      * If its a relative path, prepend the path to this node, otherwise return as is
1616.      *
1617.      * @param string $p the relative or absolute property or node path
1618.      *
1619.      * @return string the absolute path to this item, with relative paths resolved against the current node
1620.      */
1621.     protected function getChildPath($p)
1622.     {
1623.         if ('' == $p) {
1624.             throw new InvalidArgumentException("Name can not be empty");
1625.         }
1626.         if ($p[0] == '/') {
1627.             return $p;
1628.         }
1629.         //relative path, combine with base path for this node
1630.         $path = $this->path === '/' ? '/' : $this->path.'/';
1632.         return $path . $p;
1633.     }
1635.     /**
1636.      * Filter the list of names according to the filter expression / array
1637.      *
1638.      * @param string|array $filter according to getNodes|getProperties
1639.      * @param array        $names  list of names to filter
1640.      *
1641.      * @return array the names in $names that match the filter
1642.      */
1643.     protected static function filterNames($filter, $names)
1644.     {
1645.         if ($filter !== null) {
1646.             $filtered = [];
1647.             $filter = (array) $filter;
1648.             foreach ($filter as $k => $f) {
1649.                 $f = trim($f);
1650.                 $filter[$k] = strtr($f, [
1651.                     '*'=>'.*', //wildcard
1652.                     '.'  => '\\.', //escape regexp
1653.                     '\\' => '\\\\',
1654.                     '{'  => '\\{',
1655.                     '}'  => '\\}',
1656.                     '('  => '\\(',
1657.                     ')'  => '\\)',
1658.                     '+'  => '\\+',
1659.                     '^'  => '\\^',
1660.                     '$'  => '\\$'
1661.                 ]);
1662.             }
1663.             foreach ($names as $name) {
1664.                 foreach ($filter as $f) {
1665.                     if (preg_match('/^'.$f.'$/', $name)) {
1666.                         $filtered[] = $name;
1667.                     }
1668.                 }
1669.             }
1670.         } else {
1671.             $filtered = $names;
1672.         }
1674.         return $filtered;
1675.     }
1677.     /**
1678.      * Provide Traversable interface: redirect to getNodes with no filter
1679.      *
1680.      * @return Iterator over all child nodes
1681.      * @throws RepositoryException
1682.      */
1683.     #[\ReturnTypeWillChange]
1684.     public function getIterator()
1685.     {
1686.         $this->checkState();
1688.         return $this->getNodes();
1689.     }
1691.     /**
1692.      * Implement really setting the property without any notification.
1693.      *
1694.      * Implement the setProperty, but also used from constructor or in refresh,
1695.      * when the backend has a new property that is not yet loaded in memory.
1696.      *
1697.      * @param string  $name
1698.      * @param mixed   $value
1699.      * @param string  $type
1700.      * @param boolean $internal whether we are setting this node through api or internally
1701.      *
1702.      * @return Property
1703.      *
1704.      * @throws InvalidArgumentException
1705.      * @throws LockException
1706.      * @throws ConstraintViolationException
1707.      * @throws RepositoryException
1708.      * @throws UnsupportedRepositoryOperationException
1709.      * @throws ValueFormatException
1710.      * @throws VersionException
1711.      *
1712.      * @see Node::setProperty
1713.      * @see Node::refresh
1714.      * @see Node::__construct
1715.      */
1716.     protected function _setProperty($name, $value, $type, $internal)
1717.     {
1718.         if ($name === '' || false !== strpos($name, '/')) {
1719.             throw new InvalidArgumentException("The name '$name' is no valid property name");
1720.         }
1722.         if (!isset($this->properties[$name])) {
1723.             $path = $this->getChildPath($name);
1724.             $property = $this->factory->get(
1725.                 Property::class,
1726.                 [
1727.                     ['type' => $type, 'value' => $value],
1728.                     $path,
1729.                     $this->session,
1730.                     $this->objectManager,
1731.                     ! $internal
1732.                 ]
1733.             );
1734.             $this->properties[$name] = $property;
1735.             if (! $internal) {
1736.                 $this->setModified();
1737.             }
1738.         } else {
1739.             if ($internal) {
1740.                 $this->properties[$name]->_setValue($value, $type);
1741.                 if ($this->properties[$name]->isDirty()) {
1742.                     $this->properties[$name]->setClean();
1743.                 }
1744.             } else {
1745.                 $this->properties[$name]->setValue($value, $type);
1746.             }
1747.         }
1749.         return $this->properties[$name];
1750.     }
1752.     /**
1753.      * Overwrite to set the properties dirty as well.
1754.      *
1755.      * @private
1756.      */
1757.     public function setDirty($keepChanges = false, $targetState = false)
1758.     {
1759.         parent::setDirty($keepChanges, $targetState);
1761.         foreach ($this->properties as $property) {
1762.             if ($keepChanges && self::STATE_NEW !== $property->getState()) {
1763.                 // if we want to keep changes, we do not want to set new properties dirty.
1764.                 $property->setDirty($keepChanges, $targetState);
1765.             }
1766.         }
1767.     }
1769.     /**
1770.      * Mark all cached children as dirty.
1771.      *
1772.      * @private
1773.      */
1774.     public function setChildrenDirty()
1775.     {
1776.         foreach ($this->objectManager->getCachedDescendants($this->getPath()) as $childNode) {
1777.             $childNode->setDirty();
1778.         }
1779.     }
1781.     /**
1782.      * In addition to set this item deleted, set all properties to deleted.
1783.      *
1784.      * They will be automatically deleted by the backend, but the user might
1785.      * still have a reference to one of the property objects.
1786.      *
1787.      * @private
1788.      */
1789.     public function setDeleted()
1790.     {
1791.         parent::setDeleted();
1792.         foreach ($this->properties as $property) {
1793.             $property->setDeleted(); // not all properties are tracked in objectmanager
1794.         }
1795.     }
1797.     /**
1798.      * {@inheritDoc}
1799.      *
1800.      * Additionally, notifies all properties of this node. Child nodes are not
1801.      * notified, it is the job of the ObjectManager to know which nodes are
1802.      * cached and notify them.
1803.      */
1804.     public function beginTransaction()
1805.     {
1806.         parent::beginTransaction();
1808.         // Notify the children properties
1809.         foreach ($this->properties as $prop) {
1810.             $prop->beginTransaction();
1811.         }
1812.     }
1814.     /**
1815.      * {@inheritDoc}
1816.      *
1817.      * Additionally, notifies all properties of this node. Child nodes are not
1818.      * notified, it is the job of the ObjectManager to know which nodes are
1819.      * cached and notify them.
1820.      */
1821.     public function commitTransaction()
1822.     {
1823.         parent::commitTransaction();
1825.         foreach ($this->properties as $prop) {
1826.             $prop->commitTransaction();
1827.         }
1828.     }
1830.     /**
1831.      * {@inheritDoc}
1832.      *
1833.      * Additionally, notifies all properties of this node. Child nodes are not
1834.      * notified, it is the job of the ObjectManager to know which nodes are
1835.      * cached and notify them.
1836.      */
1837.     public function rollbackTransaction()
1838.     {
1839.         parent::rollbackTransaction();
1841.         foreach ($this->properties as $prop) {
1842.             $prop->rollbackTransaction();
1843.         }
1844.     }
1845. }