ElggBatch.php

Go to the documentation of this file.

<?php
class ElggBatch
    implements \Iterator {
 
    private $results = array();
 
    private $getter = null;
 
    private $chunkSize = 25;
 
    private $callback = null;
 
    private $offset = 0;
 
    private $limit = 0;
 
    private $retrievedResults = 0;
 
    private $resultIndex = 0;
 
    private $chunkIndex = 0;
 
    private $processedResults = 0;
 
    private $validGetter = null;
 
    public $callbackResult = null;
 
    private $incrementOffset = true;
 
    private $incompleteEntities = array();
 
    private $totalIncompletes = 0;
 
    public function __construct($getter, $options, $callback = null, $chunk_size = 25,
            $inc_offset = true) {
        
        $this->getter = $getter;
        $this->options = $options;
        $this->callback = $callback;
        $this->chunkSize = $chunk_size;
        $this->setIncrementOffset($inc_offset);
 
        if ($this->chunkSize <= 0) {
            $this->chunkSize = 25;
        }
 
        // store these so we can compare later
        $this->offset = elgg_extract('offset', $options, 0);
        $this->limit = elgg_extract('limit', $options, elgg_get_config('default_limit'));
 
        // if passed a callback, create a new \ElggBatch with the same options
        // and pass each to the callback.
        if ($callback && is_callable($callback)) {
            $batch = new \ElggBatch($getter, $options, null, $chunk_size, $inc_offset);
 
            $all_results = null;
 
            foreach ($batch as $result) {
                $result = call_user_func($callback, $result, $getter, $options);
 
                if (!isset($all_results)) {
                    if ($result === true || $result === false || $result === null) {
                        $all_results = $result;
                    } else {
                        $all_results = array();
                    }
                }
 
                if (($result === true || $result === false || $result === null) && !is_array($all_results)) {
                    $all_results = $result && $all_results;
                } else {
                    $all_results[] = $result;
                }
            }
 
            $this->callbackResult = $all_results;
        }
    }
 
    public function reportIncompleteEntity(\stdClass $row) {
        $this->incompleteEntities[] = $row;
    }
 
    private function getNextResultsChunk() {
 
        // always reset results.
        $this->results = array();
 
        if (!isset($this->validGetter)) {
            $this->validGetter = is_callable($this->getter);
        }
 
        if (!$this->validGetter) {
            return false;
        }
 
        $limit = $this->chunkSize;
 
        // if someone passed limit = 0 they want everything.
        if ($this->limit != 0) {
            if ($this->retrievedResults >= $this->limit) {
                return false;
            }
 
            // if original limit < chunk size, set limit to original limit
            // else if the number of results we'll fetch if greater than the original limit
            if ($this->limit < $this->chunkSize) {
                $limit = $this->limit;
            } elseif ($this->retrievedResults + $this->chunkSize > $this->limit) {
                // set the limit to the number of results remaining in the original limit
                $limit = $this->limit - $this->retrievedResults;
            }
        }
 
        if ($this->incrementOffset) {
            $offset = $this->offset + $this->retrievedResults;
        } else {
            $offset = $this->offset + $this->totalIncompletes;
        }
 
        $current_options = array(
            'limit' => $limit,
            'offset' => $offset,
            '__ElggBatch' => $this,
        );
 
        $options = array_merge($this->options, $current_options);
 
        $this->incompleteEntities = array();
        $this->results = call_user_func($this->getter, $options);
 
        // batch result sets tend to be large; we don't want to cache these.
        _elgg_services()->db->disableQueryCache();
 
        $num_results = count($this->results);
        $num_incomplete = count($this->incompleteEntities);
 
        $this->totalIncompletes += $num_incomplete;
 
        if ($this->incompleteEntities) {
            // pad the front of the results with nulls representing the incompletes
            array_splice($this->results, 0, 0, array_pad(array(), $num_incomplete, null));
            // ...and skip past them
            reset($this->results);
            for ($i = 0; $i < $num_incomplete; $i++) {
                next($this->results);
            }
        }
 
        if ($this->results) {
            $this->chunkIndex++;
 
            // let the system know we've jumped past the nulls
            $this->resultIndex = $num_incomplete;
 
            $this->retrievedResults += ($num_results + $num_incomplete);
            if ($num_results == 0) {
                // This fetch was *all* incompletes! We need to fetch until we can either
                // offer at least one row to iterate over, or give up.
                return $this->getNextResultsChunk();
            }
            _elgg_services()->db->enableQueryCache();
            return true;
        } else {
            _elgg_services()->db->enableQueryCache();
            return false;
        }
    }
 
    public function setIncrementOffset($increment = true) {
        $this->incrementOffset = (bool) $increment;
    }
 
    public function rewind() {
        $this->resultIndex = 0;
        $this->retrievedResults = 0;
        $this->processedResults = 0;
 
        // only grab results if we haven't yet or we're crossing chunks
        if ($this->chunkIndex == 0 || $this->limit > $this->chunkSize) {
            $this->chunkIndex = 0;
            $this->getNextResultsChunk();
        }
    }
 
    public function current() {
        return current($this->results);
    }
 
    public function key() {
        return $this->processedResults;
    }
 
    public function next() {
        // if we'll be at the end.
        if (($this->processedResults + 1) >= $this->limit && $this->limit > 0) {
            $this->results = array();
            return false;
        }
 
        // if we'll need new results.
        if (($this->resultIndex + 1) >= $this->chunkSize) {
            if (!$this->getNextResultsChunk()) {
                $this->results = array();
                return false;
            }
 
            $result = current($this->results);
        } else {
            // the function above resets the indexes, so only inc if not
            // getting new set
            $this->resultIndex++;
            $result = next($this->results);
        }
 
        $this->processedResults++;
        return $result;
    }
 
    public function valid() {
        if (!is_array($this->results)) {
            return false;
        }
        $key = key($this->results);
        return ($key !== null && $key !== false);
    }
}