vendor/jackalope/jackalope/src/Jackalope/NodePathIterator.php line 154

  1. <?php
  3. namespace Jackalope;
  5. use ArrayAccess;
  6. use Countable;
  7. use InvalidArgumentException;
  8. use SeekableIterator;
  10. /**
  11.  * @license http://www.apache.org/licenses Apache License Version 2.0, January 2004
  12.  * @license http://opensource.org/licenses/MIT MIT License
  13.  */
  14. class NodePathIterator implements SeekableIterator, ArrayAccess, Countable
  15. {
  16.     /**
  17.      * @var int
  18.      */
  19.     protected $position = 0;
  21.     /**
  22.      * @var array
  23.      */
  24.     protected $nodes = [];
  26.     /**
  27.      * @var array
  28.      */
  29.     protected $paths;
  31.     protected $typeFilter;
  32.     protected $class;
  34.     /**
  35.      * @var int
  36.      */
  37.     protected $count = 0;
  39.     protected $batchSize;
  41.     protected $objectManager;
  43.     public function __construct(
  44.         ObjectManager $objectManager,
  45.         $paths,
  46.         $class = Node::class,
  47.         $typeFilter = [],
  48.         $batchSize = 50
  49.     ) {
  50.         $this->objectManager = $objectManager;
  51.         $this->paths = array_values((array) $paths); // ensure paths are indexed numerically
  52.         $this->batchSize = $batchSize;
  53.         $this->typeFilter = $typeFilter;
  54.         $this->class = $class;
  56.         $this->loadBatch();
  57.     }
  59.     /**
  60.      * Return the batchSize
  61.      *
  62.      * @return integer
  63.      */
  64.     public function getBatchSize()
  65.     {
  66.         return $this->batchSize;
  67.     }
  69.     /**
  70.      * Return the type filter
  71.      *
  72.      * @return string
  73.      */
  74.     public function getTypeFilter()
  75.     {
  76.         return $this->typeFilter;
  77.     }
  79.     /**
  80.      * {@inheritDoc}
  81.      */
  82.     #[\ReturnTypeWillChange]
  83.     public function current()
  84.     {
  85.         return $this->nodes[$this->paths[$this->position]];
  86.     }
  88.     /**
  89.      * {@inheritDoc}
  90.      */
  91.     #[\ReturnTypeWillChange]
  92.     public function next()
  93.     {
  94.         $this->position++;
  95.     }
  97.     /**
  98.      * {@inheritDoc}
  99.      */
  100.     #[\ReturnTypeWillChange]
  101.     public function rewind()
  102.     {
  103.         $this->position = 0;
  104.     }
  106.     /**
  107.      * {@inheritDoc}
  108.      */
  109.     #[\ReturnTypeWillChange]
  110.     public function valid()
  111.     {
  112.         if (!isset($this->paths[$this->position])) {
  113.             return false;
  114.         }
  116.         $path = $this->paths[$this->position];
  118.         // skip any paths which have been filtered in userland
  119.         // and move on
  120.         if ($path === null) {
  121.             $this->position++;
  123.             return $this->valid();
  124.         }
  126.         if (!array_key_exists($path, $this->nodes)) {
  127.             $this->loadBatch();
  128.         }
  130.         if (empty($this->nodes[$path])) {
  131.             $this->position++;
  133.             return $this->valid();
  134.         }
  136.         return true;
  137.     }
  139.     /**
  140.      * {@inheritDoc}
  141.      */
  142.     #[\ReturnTypeWillChange]
  143.     public function key()
  144.     {
  145.         return $this->paths[$this->position];
  146.     }
  148.     /**
  149.      * Load a batch of records according to the
  150.      * batch size.
  151.      *
  152.      * @param integer $position - Optional position to start from
  153.      */
  154.     protected function loadBatch($position = null)
  155.     {
  156.         if (0 === count($this->paths)) {
  157.             return;
  158.         }
  160.         $paths = array_slice(
  161.             $this->paths,
  162.             $position ? $position : $this->position,
  163.             $this->batchSize
  164.         );
  166.         $nodes = $this->objectManager->getNodesByPathAsArray(
  167.             $paths,
  168.             $this->class,
  169.             $this->typeFilter
  170.         );
  172.         foreach ($paths as $path) {
  173.             if (isset($nodes[$path]) && $nodes[$path] !== '') {
  174.                 $this->nodes[$path] =  $nodes[$path];
  175.                 $this->count++;
  176.             } else {
  177.                 $this->nodes[$path] =  null;
  178.             }
  179.         }
  180.     }
  182.     /**
  183.      * Ensure that the given path is loaded from the database.
  184.      * We will iterate over the batches until we either get to
  185.      * the end or we find the node we are looking for.
  186.      *
  187.      * Subsequent calls will start loading from the first path
  188.      * which does not have a corresponding array key in the nodes array
  189.      * - if the node is indeed not already loaded.
  190.      *
  191.      * @param integer $offset
  192.      */
  193.     protected function ensurePathLoaded($offset)
  194.     {
  195.         if (count($this->paths) > 0) {
  196.             if (!array_key_exists($offset, $this->nodes)) {
  197.                 // start loading batches from the position of the first
  198.                 // "missing" node
  199.                 $position = null;
  200.                 foreach ($this->paths as $position => $path) {
  201.                     if (!array_key_exists($path, $this->nodes)) {
  202.                         break;
  203.                     }
  204.                 }
  206.                 while (isset($this->paths[$position])) {
  207.                     // keep loading batches until we get to the end of the paths
  208.                     // or we find the one we want.
  209.                     $this->loadBatch($position);
  210.                     $position += $this->batchSize;
  211.                     if (array_key_exists($offset, $this->nodes)) {
  212.                         break;
  213.                     }
  214.                 }
  215.             }
  216.         }
  218.         // if it wasn't found, it doesn't exist, set it to null
  219.         if (!array_key_exists($offset, $this->nodes)) {
  220.             $this->nodes[$offset] = null;
  221.         }
  222.     }
  224.     /**
  225.      * {@inheritDoc}
  226.      */
  227.     #[\ReturnTypeWillChange]
  228.     public function offsetExists($offset)
  229.     {
  230.         $this->ensurePathLoaded($offset);
  232.         return $this->nodes[$offset] === null ? false : true;
  233.     }
  235.     /**
  236.      * {@inheritDoc}
  237.      */
  238.     #[\ReturnTypeWillChange]
  239.     public function offsetGet($offset)
  240.     {
  241.         $this->ensurePathLoaded($offset);
  243.         return $this->nodes[$offset];
  244.     }
  246.     /**
  247.      * {@inheritDoc}
  248.      */
  249.     #[\ReturnTypeWillChange]
  250.     public function offsetSet($offset, $value)
  251.     {
  252.         throw new InvalidArgumentException('Node path collection is read only');
  253.     }
  255.     /**
  256.      * {@inheritDoc}
  257.      */
  258.     #[\ReturnTypeWillChange]
  259.     public function offsetUnset($offset)
  260.     {
  261.         throw new InvalidArgumentException('Node path collection is read only');
  262.     }
  264.     /**
  265.      * {@inheritDoc}
  266.      */
  267.     #[\ReturnTypeWillChange]
  268.     public function seek($position)
  269.     {
  270.         $this->position = $position;
  271.     }
  273.     /**
  274.      * {@inheritDoc}
  275.      */
  276.     #[\ReturnTypeWillChange]
  277.     public function count()
  278.     {
  279.         $this->ensurePathLoaded(count($this->paths));
  280.         return $this->count;
  281.     }
  282. }