As3\Modlr\Models\Collections\ModelCollection

Complexity

Total Complexity

11

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	allWithoutLoad()	0	4	1
	getIdentifiers()	0	1	?
A	getMetadata()	0	4	1
	getQueryField()	0	1	?
A	getSingleResult()	0	5	1
A	getType()	0	4	1
A	rewind()	0	5	1
A	loadFromStore()	0	9	2
A	validateAdd()	0	5	1
A	validateModelClass()	0	6	2

<?php

namespace As3\Modlr\Models\Collections;

use As3\Modlr\Metadata\EntityMetadata;
use As3\Modlr\Models\AbstractModel;
use As3\Modlr\Models\Model;
use As3\Modlr\Store\Store;

/**
 * Model collection that contains record representations from a persistence (database) layer.
 *
 * @author Jacob Bare <jacob.bare@gmail.com>
 */
abstract class ModelCollection extends AbstractCollection
{
    /**
     * @var EntityMetadata
     */
    protected $metadata;

    /**
     * Constructor.
     *
     * @param   EntityMetadata  $metadata
     * @param   Store           $store
     * @param   AbstractModel[] $models
     * @param   int             $totalCount
     */
    public function __construct(EntityMetadata $metadata, Store $store, array $models = [], $totalCount)
    {
        $this->metadata = $metadata;
        parent::__construct($store, $models, $totalCount);
    }

    /**
     * Returns all models in this collection without triggering auto-loading.
     *
     * @return  AbstractModel[]
     */
    public function allWithoutLoad()
    {
        return $this->models;
    }

    /**
     * Gets the identifiers for this collection.
     *
     * @param   bool    $onlyUnloaded   Whether to only include unloaded models in the results.
     * @return  array
     */
    abstract public function getIdentifiers($onlyUnloaded = true);

    /**
     * Gets the metadata for the model collection.
     *
     * @return  EntityMetadata
     */
    public function getMetadata()
    {
        return $this->metadata;
    }

    /**
     * Gets the query field for this collection.
     *
     * @return  string
     */
    abstract public function getQueryField();

    /**
     * {@inheritdoc}
     *
     * Overloaded to ensure models are loaded from the store.
     *
     */
    public function getSingleResult()
    {
        $this->loadFromStore();
        return parent::getSingleResult();
    }

    /**
     * {@inheritdoc}
     */
    public function getType()
    {
        return $this->getMetadata()->type;
    }

    /**
     * {@inheritDoc}
     */
    public function rewind()
    {
        $this->loadFromStore();
        parent::rewind();
    }

    /**
     * Loads this collection from the store.
     */
    protected function loadFromStore()
    {
        if (false === $this->isLoaded()) {
            // Loads collection from the database on iteration.
            $models = $this->store->loadCollection($this);
            $this->setModels($models);
            $this->loaded = true;
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function validateAdd(AbstractModel $model)
    {
        $this->validateModelClass($model);
        $this->store->validateRelationshipSet($this->getMetadata(), $model->getType());

It seems like you code against a specific sub-type and not the parent class As3\Modlr\Models\AbstractModel as the method getType() does only exist in the following sub-classes of As3\Modlr\Models\AbstractModel: As3\Modlr\Models\Model. Maybe you want to instanceof check for one of these explicitly?

    }

    /**
     * Validates that the model class instance is supported.
     *
     * @param   AbstractModel   $model
     * @throws  \InvalidArgumentException
     */
    protected function validateModelClass(AbstractModel $model)
    {
        if (!$model instanceof Model) {
            throw new \InvalidArgumentException('The model must be an instanceof of Model');
        }
    }
}