Maslosoft\Mangan\Helpers\CompositionIterator

Complexity

Total Complexity

33

Size/Duplication

Total Lines	210
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

87.34%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	direct()	0	5	1
A	ofType()	0	11	2
A	getCurrentField()	0	8	2
A	init()	0	8	2
A	doInclude()	0	18	4
A	recurse()	0	4	1
A	current()	0	5	1
A	next()	0	5	1
A	key()	0	5	1
A	valid()	0	5	1
A	rewind()	0	5	1
A	count()	0	5	1
B	iterate()	0	47	11
A	skip()	0	14	3

<?php
/**
 * Created by PhpStorm.
 * User: peter
 * Date: 07.03.18
 * Time: 17:46
 */

namespace Maslosoft\Mangan\Helpers;


use Countable;
use Iterator;
use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
use Maslosoft\Addendum\Utilities\ClassChecker;
use Maslosoft\Mangan\Mangan;
use Maslosoft\Mangan\Meta\ManganMeta;

/**
 * Iterate over composition of documents.
 *
 * NOTE: This will include only AnnotatedInterface instances.
 *
 * @package Maslosoft\Mangan\Helpers
 */
class CompositionIterator implements Iterator, Countable
{
	private $model = null;

	private $direct = false;

	private $types = [];

	/**
	 * Models holder
	 * @var null|AnnotatedInterface[]
	 */
	private $models = null;

	private $pointer = 0;

	private $fieldNames = [];

	public function __construct(AnnotatedInterface $model)
	{
		$this->model = $model;
	}

	/**
	 * Limit results to only direct descendants.
	 * @return $this
	 */
	public function direct()
	{
		$this->direct = true;
		return $this;
	}

	/**
	 * Limit results to only to the type provided.
	 *
	 * The `$type` should be class or interface name
	 * or object instance.
	 *
	 * Repeated calls will add types uniquely.
	 *
	 * @param $type string|object
	 * @param $include boolean Whether to include this type or skip
	 * @return $this
	 */
	public function ofType($type, $include = true)
	{
		if (is_object($type))
		{
			$type = get_class($type);
		}
		assert(is_string($type));
		assert(ClassChecker::exists($type));
		$this->types[$type] = $include;
		return $this;
	}

	/**
	 * Get currently iterated over field name,
	 * which have models
	 * @return string
	 */
	public function getCurrentField()
	{
		if(isset($this->fieldNames[$this->pointer]))
		{
			return $this->fieldNames[$this->pointer];
		}
		return '';
	}

	private function init()
	{
		if (null === $this->models)
		{
			$this->models = [];
			$this->iterate($this->model);
		}
	}

	private function iterate($model)
	{
		foreach (ManganMeta::create($model)->fields() as $name => $meta)
		{
			// Not one of:
			// * Embedded(Array)
			// * DbRef(Array)
			// * Related(Array)
			if(!$meta->owned)
			{
				continue;
			}
			if (is_array($model->$name))
			{
				foreach ($model->$name as $child)
				{
					if ($this->skip($child))
					{
						continue;
					}
					if ($this->doInclude($child))
					{
						$this->fieldNames[] = $name;
						$this->models[] = $child;
					}
					if($this->recurse())
					{
						$this->iterate($child);
					}
				}
				continue;
			}
			if ($this->skip($model->$name))
			{
				continue;
			}
			if ($this->doInclude($model->$name))
			{
				$this->fieldNames[] = $name;
				$this->models[] = $model->$name;
			}
			if($this->recurse())
			{
				$this->iterate($model->$name);
			}
		}
	}

	private function skip($model)
	{
		// Non-object
		if (!is_object($model))
		{
			return true;
		}
		// Skip if not annotated
		if (!$model instanceof AnnotatedInterface)
		{
			return true;
		}
		return false;
	}

	/**
	 * Whether to include `$model` in result
	 * @param $model
	 * @return bool
	 */
	private function doInclude($model)
	{
		// Don't skip if no types
		if (empty($this->types))
		{
			return true;
		}

		// Include if is_a type
		foreach ($this->types as $type => $include)
		{
			if (is_a($model, $type))
			{
				return $include;
			}
		}
		return false;
	}

	private function recurse()
	{
		return !$this->direct;
	}

	public function current()
	{
		$this->init();
		return $this->models[$this->pointer];
	}

	public function next()
	{
		$this->init();
		++$this->pointer;
	}

	public function key()
	{
		$this->init();
		return $this->pointer;
	}

	public function valid()
	{
		$this->init();
		return isset($this->models[$this->pointer]);
	}

	public function rewind()
	{
		$this->init();
		$this->pointer = 0;
	}

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


}