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

  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.     public function __construct(
  42.         ObjectManager $objectManager,
  43.         $paths,
  44.         $class = Node::class,
  45.         $typeFilter = [],
  46.         $batchSize = 50
  47.     ) {
  48.         $this->objectManager = $objectManager;
  49.         $this->paths = array_values((array) $paths); // ensure paths are indexed numerically
  50.         $this->batchSize = $batchSize;
  51.         $this->typeFilter = $typeFilter;
  52.         $this->class = $class;
  54.         $this->loadBatch();
  55.     }
  57.     /**
  58.      * Return the batchSize
  59.      *
  60.      * @return integer
  61.      */
  62.     public function getBatchSize()
  63.     {
  64.         return $this->batchSize;
  65.     }
  67.     /**
  68.      * Return the type filter
  69.      *
  70.      * @return string
  71.      */
  72.     public function getTypeFilter()
  73.     {
  74.         return $this->typeFilter;
  75.     }
  77.     /**
  78.      * {@inheritDoc}
  79.      */
  80.     #[\ReturnTypeWillChange]
  81.     public function current()
  82.     {
  83.         return $this->nodes[$this->paths[$this->position]];
  84.     }
  86.     /**
  87.      * {@inheritDoc}
  88.      */
  89.     #[\ReturnTypeWillChange]
  90.     public function next()
  91.     {
  92.         $this->position++;
  93.     }
  95.     /**
  96.      * {@inheritDoc}
  97.      */
  98.     #[\ReturnTypeWillChange]
  99.     public function rewind()
  100.     {
  101.         $this->position = 0;
  102.     }
  104.     /**
  105.      * {@inheritDoc}
  106.      */
  107.     #[\ReturnTypeWillChange]
  108.     public function valid()
  109.     {
  110.         if (!isset($this->paths[$this->position])) {
  111.             return false;
  112.         }
  114.         $path = $this->paths[$this->position];
  116.         // skip any paths which have been filtered in userland
  117.         // and move on
  118.         if ($path === null) {
  119.             $this->position++;
  121.             return $this->valid();
  122.         }
  124.         if (!array_key_exists($path, $this->nodes)) {
  125.             $this->loadBatch();
  126.         }
  128.         if (empty($this->nodes[$path])) {
  129.             $this->position++;
  131.             return $this->valid();
  132.         }
  134.         return true;
  135.     }
  137.     /**
  138.      * {@inheritDoc}
  139.      */
  140.     #[\ReturnTypeWillChange]
  141.     public function key()
  142.     {
  143.         return $this->paths[$this->position];
  144.     }
  146.     /**
  147.      * Load a batch of records according to the
  148.      * batch size.
  149.      *
  150.      * @param integer $position - Optional position to start from
  151.      */
  152.     protected function loadBatch($position = null)
  153.     {
  154.         if (0 === count($this->paths)) {
  155.             return;
  156.         }
  158.         $paths = array_slice(
  159.             $this->paths,
  160.             $position ? $position : $this->position,
  161.             $this->batchSize
  162.         );
  164.         $nodes = $this->objectManager->getNodesByPathAsArray(
  165.             $paths,
  166.             $this->class,
  167.             $this->typeFilter
  168.         );
  170.         foreach ($paths as $path) {
  171.             if (isset($nodes[$path]) && $nodes[$path] !== '') {
  172.                 $this->nodes[$path] =  $nodes[$path];
  173.                 $this->count++;
  174.             } else {
  175.                 $this->nodes[$path] =  null;
  176.             }
  177.         }
  178.     }
  180.     /**
  181.      * Ensure that the given path is loaded from the database.
  182.      * We will iterate over the batches until we either get to
  183.      * the end or we find the node we are looking for.
  184.      *
  185.      * Subsequent calls will start loading from the first path
  186.      * which does not have a corresponding array key in the nodes array
  187.      * - if the node is indeed not already loaded.
  188.      *
  189.      * @param integer $offset
  190.      */
  191.     protected function ensurePathLoaded($offset)
  192.     {
  193.         if (count($this->paths) > 0) {
  194.             if (!array_key_exists($offset, $this->nodes)) {
  195.                 // start loading batches from the position of the first
  196.                 // "missing" node
  197.                 $position = null;
  198.                 foreach ($this->paths as $position => $path) {
  199.                     if (!array_key_exists($path, $this->nodes)) {
  200.                         break;
  201.                     }
  202.                 }
  204.                 while (isset($this->paths[$position])) {
  205.                     // keep loading batches until we get to the end of the paths
  206.                     // or we find the one we want.
  207.                     $this->loadBatch($position);
  208.                     $position += $this->batchSize;
  209.                     if (array_key_exists($offset, $this->nodes)) {
  210.                         break;
  211.                     }
  212.                 }
  213.             }
  214.         }
  216.         // if it wasn't found, it doesn't exist, set it to null
  217.         if (!array_key_exists($offset, $this->nodes)) {
  218.             $this->nodes[$offset] = null;
  219.         }
  220.     }
  222.     /**
  223.      * {@inheritDoc}
  224.      */
  225.     #[\ReturnTypeWillChange]
  226.     public function offsetExists($offset)
  227.     {
  228.         $this->ensurePathLoaded($offset);
  230.         return $this->nodes[$offset] === null ? false : true;
  231.     }
  233.     /**
  234.      * {@inheritDoc}
  235.      */
  236.     #[\ReturnTypeWillChange]
  237.     public function offsetGet($offset)
  238.     {
  239.         $this->ensurePathLoaded($offset);
  241.         return $this->nodes[$offset];
  242.     }
  244.     /**
  245.      * {@inheritDoc}
  246.      */
  247.     #[\ReturnTypeWillChange]
  248.     public function offsetSet($offset, $value)
  249.     {
  250.         throw new InvalidArgumentException('Node path collection is read only');
  251.     }
  253.     /**
  254.      * {@inheritDoc}
  255.      */
  256.     #[\ReturnTypeWillChange]
  257.     public function offsetUnset($offset)
  258.     {
  259.         throw new InvalidArgumentException('Node path collection is read only');
  260.     }
  262.     /**
  263.      * {@inheritDoc}
  264.      */
  265.     #[\ReturnTypeWillChange]
  266.     public function seek($position)
  267.     {
  268.         $this->position = $position;
  269.     }
  271.     /**
  272.      * {@inheritDoc}
  273.      */
  274.     #[\ReturnTypeWillChange]
  275.     public function count()
  276.     {
  277.         $this->ensurePathLoaded(count($this->paths));
  278.         return $this->count;
  279.     }
  280. }