Ramsey\Collection\Collection

Complexity

Total Complexity

2

Size/Duplication

Total Lines	35
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getType()	0	4	1

<?php
/**
 * This file is part of the ramsey/collection library
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
 * @license http://opensource.org/licenses/MIT MIT
 * @link https://benramsey.com/projects/ramsey-collection/ Documentation
 * @link https://packagist.org/packages/ramsey/collection Packagist
 * @link https://github.com/ramsey/collection GitHub
 */

namespace Ramsey\Collection;

/**
 * A collection represents a group of objects. Each object in the collection
 * is of a specific, defined type.
 *
 * This is a direct implementation of CollectionInterface, provided for
 * the sake of convenience.
 *
 * Example usage:
 *
 * ``` php
 * $collection = new \Ramsey\Collection\Collection('My\\Foo');
 * $collection->add(new \My\Foo());
 * $collection->add(new \My\Foo());
 *
 * foreach ($collection as $foo) {
 *     // Do something with $foo
 * }
 * ```
 *
 * It is preferable to subclass AbstractCollection to create your own typed
 * collections. For example:
 *
 * ``` php
 * namespace My\Foo;
 *
 * class FooCollection extends \Ramsey\Collection\AbstractCollection
 * {
 *     public function getType()
 *     {
 *         return 'My\\Foo';
 *     }
 * }
 * ```
 *
 * And then use it similarly to the earlier example:
 *
 * ``` php
 * $fooCollection = new \My\Foo\FooCollection();
 * $fooCollection->add(new \My\Foo());
 * $fooCollection->add(new \My\Foo());
 *
 * foreach ($fooCollection as $foo) {
 *     // Do something with $foo
 * }
 * ```
 *
 * The benefit with this approach is that you may do type-checking on the
 * collection object:
 *
 * ``` php
 * if ($collection instanceof \My\Foo\FooCollection) {
 *     // the collection is a collection of My\Foo objects
 * }
 * ```
 */
class Collection extends AbstractCollection
{
    /**
     * The type of elements stored in this collection
     *
     * A collection's type is immutable once it is set. For this reason, this
     * property is set private
     *
     * @var string
     */
    private $collectionType;

    /**
     * Constructs a collection object of the specified type,
     * optionally with the specified data
     *
     * @param string $collectionType
     * @param array $data
     */
    public function __construct($collectionType, array $data = [])
    {
        $this->collectionType = $collectionType;
        parent::__construct($data);
    }

    /**
     * Returns the type associated with this collection
     *
     * @return string
     */
    public function getType()
    {
        return $this->collectionType;
    }
}