ElggPriorityList.php

Go to the documentation of this file.

<?php
class ElggPriorityList
    implements \Iterator, \Countable {

    private $elements = [];
    
    private $sorted = false;

    public function __construct(array $elements = []) {
        foreach ($elements as $priority => $element) {
            $this->add($element, $priority);
        }
    }

    public function add($element, $priority = null, $exact = false) {
        if ($priority !== null && !is_numeric($priority)) {
            return false;
        } else {
            $priority = $this->getNextPriority($priority);
        }

        $this->elements[$priority] = $element;
        $this->sorted = false;
        
        return $priority;
    }

    public function remove($element, $strict = false) {
        $index = array_search($element, $this->elements, $strict);
        if ($index === false) {
            return false;
        }
        
        unset($this->elements[$index]);
        return true;
    }

    public function move($element, $new_priority, $strict = false) {
        $new_priority = (int) $new_priority;
        
        $current_priority = $this->getPriority($element, $strict);
        if ($current_priority === false) {
            return false;
        }

        if ($current_priority == $new_priority) {
            return true;
        }

        // move the actual element so strict operations still work
        $element = $this->getElement($current_priority);
        unset($this->elements[$current_priority]);
        return ($this->add($element, $new_priority) !== false);
    }

    public function getElements() {
        $this->sortIfUnsorted();
        return $this->elements;
    }

    public function sort($callback = null) {
        if (!$callback) {
            ksort($this->elements, SORT_NUMERIC);
        } else {
            $sorted = call_user_func($callback, $this->elements);

            if (!$sorted) {
                return false;
            }

            $this->elements = $sorted;
        }
        
        $this->sorted = true;
        return true;
    }

    private function sortIfUnsorted() {
        if (!$this->sorted) {
            $this->sort();
        }
    }

    public function getNextPriority($near = 0) {
        $near = (int) $near;
        
        while (array_key_exists($near, $this->elements)) {
            $near++;
        }

        return $near;
    }

    public function getPriority($element, $strict = false) {
        $prio = array_search($element, $this->elements, $strict);
        
        return ($prio === false) ? false : (int) $prio;
    }

    public function getElement($priority) {
        return (isset($this->elements[$priority])) ? $this->elements[$priority] : false;
    }

    public function contains($element, $strict = false) {
        return $this->getPriority($element, $strict) !== false;
    }

    
    /**********************
     * Interface methods *
     **********************/

    public function rewind() {
        $this->sortIfUnsorted();
        return reset($this->elements);
    }

    public function current() {
        $this->sortIfUnsorted();
        return current($this->elements);
    }

    public function key() {
        $this->sortIfUnsorted();
        return key($this->elements);
    }

    public function next() {
        $this->sortIfUnsorted();
        return next($this->elements);
    }

    public function valid() {
        $this->sortIfUnsorted();
        $key = key($this->elements);
        return ($key !== null && $key !== false);
    }

    public function count() {
        return count($this->elements);
    }
}