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

Open in your IDE?
  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.     public function current()
  81.     {
  82.         return $this->nodes[$this->paths[$this->position]];
  83.     }
  85.     /**
  86.      * {@inheritDoc}
  87.      */
  88.     public function next()
  89.     {
  90.         $this->position++;
  91.     }
  93.     /**
  94.      * {@inheritDoc}
  95.      */
  96.     public function rewind()
  97.     {
  98.         $this->position = 0;
  99.     }
  101.     /**
  102.      * {@inheritDoc}
  103.      */
  104.     public function valid()
  105.     {
  106.         if (!isset($this->paths[$this->position])) {
  107.             return false;
  108.         }
  110.         $path = $this->paths[$this->position];
  112.         // skip any paths which have been filtered in userland
  113.         // and move on
  114.         if ($path === null) {
  115.             $this->position++;
  117.             return $this->valid();
  118.         }
  120.         if (!array_key_exists($path, $this->nodes)) {
  121.             $this->loadBatch();
  122.         }
  124.         if (empty($this->nodes[$path])) {
  125.             $this->position++;
  127.             return $this->valid();
  128.         }
  130.         return true;
  131.     }
  133.     /**
  134.      * {@inheritDoc}
  135.      */
  136.     public function key()
  137.     {
  138.         return $this->paths[$this->position];
  139.     }
  141.     /**
  142.      * Load a batch of records according to the
  143.      * batch size.
  144.      *
  145.      * @param integer $position - Optional position to start from
  146.      */
  147.     protected function loadBatch($position = null)
  148.     {
  149.         if (0 === count($this->paths)) {
  150.             return;
  151.         }
  153.         $paths = array_slice(
  154.             $this->paths,
  155.             $position ? $position : $this->position,
  156.             $this->batchSize
  157.         );
  159.         $nodes = $this->objectManager->getNodesByPathAsArray(
  160.             $paths,
  161.             $this->class,
  162.             $this->typeFilter
  163.         );
  165.         foreach ($paths as $path) {
  166.             if (isset($nodes[$path]) && $nodes[$path] !== '') {
  167.                 $this->nodes[$path] =  $nodes[$path];
  168.                 $this->count++;
  169.             } else {
  170.                 $this->nodes[$path] =  null;
  171.             }
  172.         }
  173.     }
  175.     /**
  176.      * Ensure that the given path is loaded from the database.
  177.      * We will iterate over the batches until we either get to
  178.      * the end or we find the node we are looking for.
  179.      *
  180.      * Subsequent calls will start loading from the first path
  181.      * which does not have a corresponding array key in the nodes array
  182.      * - if the node is indeed not already loaded.
  183.      *
  184.      * @param integer $offset
  185.      */
  186.     protected function ensurePathLoaded($offset)
  187.     {
  188.         if (count($this->paths) > 0) {
  189.             if (!array_key_exists($offset, $this->nodes)) {
  190.                 // start loading batches from the position of the first
  191.                 // "missing" node
  192.                 $position = null;
  193.                 foreach ($this->paths as $position => $path) {
  194.                     if (!array_key_exists($path, $this->nodes)) {
  195.                         break;
  196.                     }
  197.                 }
  199.                 while (isset($this->paths[$position])) {
  200.                     // keep loading batches until we get to the end of the paths
  201.                     // or we find the one we want.
  202.                     $this->loadBatch($position);
  203.                     $position += $this->batchSize;
  204.                     if (array_key_exists($offset, $this->nodes)) {
  205.                         break;
  206.                     }
  207.                 }
  208.             }
  209.         }
  211.         // if it wasn't found, it doesn't exist, set it to null
  212.         if (!array_key_exists($offset, $this->nodes)) {
  213.             $this->nodes[$offset] = null;
  214.         }
  215.     }
  217.     /**
  218.      * {@inheritDoc}
  219.      */
  220.     public function offsetExists($offset)
  221.     {
  222.         $this->ensurePathLoaded($offset);
  224.         return $this->nodes[$offset] === null ? false : true;
  225.     }
  227.     /**
  228.      * {@inheritDoc}
  229.      */
  230.     public function offsetGet($offset)
  231.     {
  232.         $this->ensurePathLoaded($offset);
  234.         return $this->nodes[$offset];
  235.     }
  237.     /**
  238.      * {@inheritDoc}
  239.      */
  240.     public function offsetSet($offset, $value)
  241.     {
  242.         throw new InvalidArgumentException('Node path collection is read only');
  243.     }
  245.     /**
  246.      * {@inheritDoc}
  247.      */
  248.     public function offsetUnset($offset)
  249.     {
  250.         throw new InvalidArgumentException('Node path collection is read only');
  251.     }
  253.     /**
  254.      * {@inheritDoc}
  255.      */
  256.     public function seek($position)
  257.     {
  258.         $this->position = $position;
  259.     }
  261.     /**
  262.      * {@inheritDoc}
  263.      */
  264.     public function count()
  265.     {
  266.         $this->ensurePathLoaded(count($this->paths));
  267.         return $this->count;
  268.     }
  269. }