class ArrayCollection in Zircon Profile 8

An ArrayCollection is a Collection implementation that wraps a regular PHP array.

@since 2.0 @author Guilherme Blanco <[e-mail]> @author Jonathan Wage <[e-mail]> @author Roman Borschel <[e-mail]>

Hierarchy

• class \Doctrine\Common\Collections\ArrayCollection implements Collection, Selectable

4 files declare their use of ArrayCollection

ArrayCollectionTest.php in vendor/doctrine/collections/tests/Doctrine/Tests/Common/Collections/ArrayCollectionTest.php

CollectionTest.php in vendor/doctrine/collections/tests/Doctrine/Tests/Common/Collections/CollectionTest.php

LazyArrayCollection.php in vendor/doctrine/collections/tests/Doctrine/Tests/LazyArrayCollection.php

PersistentObject.php in vendor/doctrine/common/lib/Doctrine/Common/Persistence/PersistentObject.php

File

vendor/doctrine/collections/lib/Doctrine/Common/Collections/ArrayCollection.php, line 34

Namespace

Doctrine\Common\Collections

class ArrayCollection implements Collection, Selectable {

  /**
   * An array containing the entries of this collection.
   *
   * @var array
   */
  private $elements;

  /**
   * Initializes a new ArrayCollection.
   *
   * @param array $elements
   */
  public function __construct(array $elements = array()) {
    $this->elements = $elements;
  }

  /**
   * {@inheritDoc}
   */
  public function toArray() {
    return $this->elements;
  }

  /**
   * {@inheritDoc}
   */
  public function first() {
    return reset($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function last() {
    return end($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function key() {
    return key($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function next() {
    return next($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function current() {
    return current($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function remove($key) {
    if (!isset($this->elements[$key]) && !array_key_exists($key, $this->elements)) {
      return null;
    }
    $removed = $this->elements[$key];
    unset($this->elements[$key]);
    return $removed;
  }

  /**
   * {@inheritDoc}
   */
  public function removeElement($element) {
    $key = array_search($element, $this->elements, true);
    if ($key === false) {
      return false;
    }
    unset($this->elements[$key]);
    return true;
  }

  /**
   * Required by interface ArrayAccess.
   *
   * {@inheritDoc}
   */
  public function offsetExists($offset) {
    return $this
      ->containsKey($offset);
  }

  /**
   * Required by interface ArrayAccess.
   *
   * {@inheritDoc}
   */
  public function offsetGet($offset) {
    return $this
      ->get($offset);
  }

  /**
   * Required by interface ArrayAccess.
   *
   * {@inheritDoc}
   */
  public function offsetSet($offset, $value) {
    if (!isset($offset)) {
      return $this
        ->add($value);
    }
    $this
      ->set($offset, $value);
  }

  /**
   * Required by interface ArrayAccess.
   *
   * {@inheritDoc}
   */
  public function offsetUnset($offset) {
    return $this
      ->remove($offset);
  }

  /**
   * {@inheritDoc}
   */
  public function containsKey($key) {
    return isset($this->elements[$key]) || array_key_exists($key, $this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function contains($element) {
    return in_array($element, $this->elements, true);
  }

  /**
   * {@inheritDoc}
   */
  public function exists(Closure $p) {
    foreach ($this->elements as $key => $element) {
      if ($p($key, $element)) {
        return true;
      }
    }
    return false;
  }

  /**
   * {@inheritDoc}
   */
  public function indexOf($element) {
    return array_search($element, $this->elements, true);
  }

  /**
   * {@inheritDoc}
   */
  public function get($key) {
    return isset($this->elements[$key]) ? $this->elements[$key] : null;
  }

  /**
   * {@inheritDoc}
   */
  public function getKeys() {
    return array_keys($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function getValues() {
    return array_values($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function count() {
    return count($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function set($key, $value) {
    $this->elements[$key] = $value;
  }

  /**
   * {@inheritDoc}
   */
  public function add($value) {
    $this->elements[] = $value;
    return true;
  }

  /**
   * {@inheritDoc}
   */
  public function isEmpty() {
    return empty($this->elements);
  }

  /**
   * Required by interface IteratorAggregate.
   *
   * {@inheritDoc}
   */
  public function getIterator() {
    return new ArrayIterator($this->elements);
  }

  /**
   * {@inheritDoc}
   */
  public function map(Closure $func) {
    return new static(array_map($func, $this->elements));
  }

  /**
   * {@inheritDoc}
   */
  public function filter(Closure $p) {
    return new static(array_filter($this->elements, $p));
  }

  /**
   * {@inheritDoc}
   */
  public function forAll(Closure $p) {
    foreach ($this->elements as $key => $element) {
      if (!$p($key, $element)) {
        return false;
      }
    }
    return true;
  }

  /**
   * {@inheritDoc}
   */
  public function partition(Closure $p) {
    $matches = $noMatches = array();
    foreach ($this->elements as $key => $element) {
      if ($p($key, $element)) {
        $matches[$key] = $element;
      }
      else {
        $noMatches[$key] = $element;
      }
    }
    return array(
      new static($matches),
      new static($noMatches),
    );
  }

  /**
   * Returns a string representation of this object.
   *
   * @return string
   */
  public function __toString() {
    return __CLASS__ . '@' . spl_object_hash($this);
  }

  /**
   * {@inheritDoc}
   */
  public function clear() {
    $this->elements = array();
  }

  /**
   * {@inheritDoc}
   */
  public function slice($offset, $length = null) {
    return array_slice($this->elements, $offset, $length, true);
  }

  /**
   * {@inheritDoc}
   */
  public function matching(Criteria $criteria) {
    $expr = $criteria
      ->getWhereExpression();
    $filtered = $this->elements;
    if ($expr) {
      $visitor = new ClosureExpressionVisitor();
      $filter = $visitor
        ->dispatch($expr);
      $filtered = array_filter($filtered, $filter);
    }
    if ($orderings = $criteria
      ->getOrderings()) {
      foreach (array_reverse($orderings) as $field => $ordering) {
        $next = ClosureExpressionVisitor::sortByField($field, $ordering == Criteria::DESC ? -1 : 1);
      }
      uasort($filtered, $next);
    }
    $offset = $criteria
      ->getFirstResult();
    $length = $criteria
      ->getMaxResults();
    if ($offset || $length) {
      $filtered = array_slice($filtered, (int) $offset, $length);
    }
    return new static($filtered);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
ArrayCollection::$elements	private	property	An array containing the entries of this collection.
ArrayCollection::add	public	function	Adds an element at the end of the collection. Overrides Collection::add
ArrayCollection::clear	public	function	Clears the collection, removing all elements. Overrides Collection::clear
ArrayCollection::contains	public	function	Checks whether an element is contained in the collection. This is an O(n) operation, where n is the size of the collection. Overrides Collection::contains
ArrayCollection::containsKey	public	function	Checks whether the collection contains an element with the specified key/index. Overrides Collection::containsKey
ArrayCollection::count	public	function
ArrayCollection::current	public	function	Gets the element of the collection at the current iterator position. Overrides Collection::current
ArrayCollection::exists	public	function	Tests for the existence of an element that satisfies the given predicate. Overrides Collection::exists
ArrayCollection::filter	public	function	Returns all the elements of this collection that satisfy the predicate p. The order of the elements is preserved. Overrides Collection::filter
ArrayCollection::first	public	function	Sets the internal iterator to the first element in the collection and returns this element. Overrides Collection::first
ArrayCollection::forAll	public	function	Tests whether the given predicate p holds for all elements of this collection. Overrides Collection::forAll
ArrayCollection::get	public	function	Gets the element at the specified key/index. Overrides Collection::get
ArrayCollection::getIterator	public	function	Required by interface IteratorAggregate.
ArrayCollection::getKeys	public	function	Gets all keys/indices of the collection. Overrides Collection::getKeys
ArrayCollection::getValues	public	function	Gets all values of the collection. Overrides Collection::getValues
ArrayCollection::indexOf	public	function	Gets the index/key of a given element. The comparison of two elements is strict, that means not only the value but also the type must match. For objects this means reference equality. Overrides Collection::indexOf
ArrayCollection::isEmpty	public	function	Checks whether the collection is empty (contains no elements). Overrides Collection::isEmpty
ArrayCollection::key	public	function	Gets the key/index of the element at the current iterator position. Overrides Collection::key
ArrayCollection::last	public	function	Sets the internal iterator to the last element in the collection and returns this element. Overrides Collection::last
ArrayCollection::map	public	function	Applies the given function to each element in the collection and returns a new collection with the elements returned by the function. Overrides Collection::map
ArrayCollection::matching	public	function	Selects all elements from a selectable that match the expression and returns a new collection containing these elements. Overrides Selectable::matching
ArrayCollection::next	public	function	Moves the internal iterator position to the next element and returns this element. Overrides Collection::next
ArrayCollection::offsetExists	public	function	Required by interface ArrayAccess.
ArrayCollection::offsetGet	public	function	Required by interface ArrayAccess.
ArrayCollection::offsetSet	public	function	Required by interface ArrayAccess.
ArrayCollection::offsetUnset	public	function	Required by interface ArrayAccess.
ArrayCollection::partition	public	function	Partitions this collection in two collections according to a predicate. Keys are preserved in the resulting collections. Overrides Collection::partition
ArrayCollection::remove	public	function	Removes the element at the specified index from the collection. Overrides Collection::remove
ArrayCollection::removeElement	public	function	Removes the specified element from the collection, if it is found. Overrides Collection::removeElement
ArrayCollection::set	public	function	Sets an element in the collection at the specified key/index. Overrides Collection::set
ArrayCollection::slice	public	function	Extracts a slice of $length elements starting at position $offset from the Collection. Overrides Collection::slice
ArrayCollection::toArray	public	function	Gets a native PHP array representation of the collection. Overrides Collection::toArray
ArrayCollection::__construct	public	function	Initializes a new ArrayCollection.
ArrayCollection::__toString	public	function	Returns a string representation of this object.