SilverStripe\ORM\Map_Iterator

Complexity

Total Complexity

36

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	current()	0	10	4
B	next()	0	32	9
A	extractValue()	0	10	5
A	key()	0	9	4
A	__construct()	0	18	5
A	rewind()	0	17	5
A	valid()	0	6	4

<?php

namespace SilverStripe\ORM;

use Iterator;

/**
 * Builds a map iterator around an Iterator.  Called by Map
 */
class Map_Iterator implements Iterator
{

    /**
     * @var Iterator
     **/
    protected $items;

    protected $keyField, $titleField;

It is generally advisable to only define one property per statement.

    protected $firstItemIdx = 0;

    protected $endItemIdx;

    protected $firstItems = array();
    protected $lastItems = array();

    protected $excludedItems = array();

    /**
     * @param Iterator $items The iterator to build this map from
     * @param string $keyField The field to use for the keys
     * @param string $titleField The field to use for the values
     * @param array $firstItems An optional map of items to show first
     * @param array $lastItems An optional map of items to show last
     */
    public function __construct(Iterator $items, $keyField, $titleField, $firstItems = null, $lastItems = null)
    {
        $this->items = $items;
        $this->keyField = $keyField;
        $this->titleField = $titleField;
        $this->endItemIdx = null;

        if ($firstItems) {
            foreach ($firstItems as $k => $v) {
                $this->firstItems[] = array($k, $v);
                $this->excludedItems[] = $k;
            }
        }

        if ($lastItems) {
            foreach ($lastItems as $k => $v) {
                $this->lastItems[] = array($k, $v);
                $this->excludedItems[] = $k;
            }
        }
    }

    /**
     * Rewind the Iterator to the first element.
     *
     * @return mixed
     */
    public function rewind()
    {
        $this->firstItemIdx = 0;
        $this->endItemIdx = null;

        $rewoundItem = $this->items->rewind();

Are you sure the assignment to $rewoundItem is correct as $this->items->rewind() targeting Iterator::rewind() seems to always return null.

        if (isset($this->firstItems[$this->firstItemIdx])) {
            return $this->firstItems[$this->firstItemIdx][1];
        } else {
            if ($rewoundItem) {

$rewoundItem is of type void, thus it always evaluated to false.

                return $this->extractValue($rewoundItem, $this->titleField);
            } else {
                if (!$this->items->valid() && $this->lastItems) {

The expression $this->lastItems of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    $this->endItemIdx = 0;

                    return $this->lastItems[0][1];
                }
            }
        }
    }

    /**
     * Return the current element.
     *
     * @return mixed
     */
    public function current()
    {
        if (($this->endItemIdx !== null) && isset($this->lastItems[$this->endItemIdx])) {
            return $this->lastItems[$this->endItemIdx][1];
        } else {
            if (isset($this->firstItems[$this->firstItemIdx])) {
                return $this->firstItems[$this->firstItemIdx][1];
            }
        }
        return $this->extractValue($this->items->current(), $this->titleField);
    }

    /**
     * Extracts a value from an item in the list, where the item is either an
     * object or array.
     *
     * @param  array|object $item
     * @param  string $key
     * @return mixed
     */
    protected function extractValue($item, $key)
    {
        if (is_object($item)) {
            if (method_exists($item, 'hasMethod') && $item->hasMethod($key)) {
                return $item->{$key}();
            }
            return $item->{$key};
        } else {
            if (array_key_exists($key, $item)) {
                return $item[$key];
            }
        }
    }

    /**
     * Return the key of the current element.
     *
     * @return string
     */
    public function key()
    {
        if (($this->endItemIdx !== null) && isset($this->lastItems[$this->endItemIdx])) {
            return $this->lastItems[$this->endItemIdx][0];
        } else {
            if (isset($this->firstItems[$this->firstItemIdx])) {
                return $this->firstItems[$this->firstItemIdx][0];
            } else {
                return $this->extractValue($this->items->current(), $this->keyField);
            }
        }
    }

    /**
     * Move forward to next element.
     *
     * @return mixed
     */
    public function next()
    {
        $this->firstItemIdx++;

        if (isset($this->firstItems[$this->firstItemIdx])) {
            return $this->firstItems[$this->firstItemIdx][1];
        } else {
            if (!isset($this->firstItems[$this->firstItemIdx - 1])) {
                $this->items->next();
            }

            if ($this->excludedItems) {

The expression $this->excludedItems of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                while (($c = $this->items->current()) && in_array($c->{$this->keyField}, $this->excludedItems, true)) {
                    $this->items->next();
                }
            }
        }

        if (!$this->items->valid()) {
            // iterator has passed the preface items, off the end of the items
            // list. Track through the end items to go through to the next
            if ($this->endItemIdx === null) {
                $this->endItemIdx = -1;
            }

            $this->endItemIdx++;

            if (isset($this->lastItems[$this->endItemIdx])) {
                return $this->lastItems[$this->endItemIdx];
            }

            return false;
        }
    }

    /**
     * Checks if current position is valid.
     *
     * @return boolean
     */
    public function valid()
    {
        return (
            (isset($this->firstItems[$this->firstItemIdx])) ||
            (($this->endItemIdx !== null) && isset($this->lastItems[$this->endItemIdx])) ||
            $this->items->valid()
        );
    }
}