NEM LEHETSÉGES

Mégis kiválóan használható!

Tételezzük fel, hogy van egy ilyesmi interface-ünk:

<?php

namespace System\Collections;

interface IEnumerable {

function Avg($callback = NULL);

function Count($callback = NULL);

function Contains($item, $comparer = NULL);

function FirstOrDefault($callback = NULL);

function GroupBy(\Closure $callback);

function OrderBy(\Closure $callback);

function Sum($callback = NULL);

function ToArray();

function ToList();

function ToLookup(\Closure $keyMaker);

function Where(\Closure $callback);

function Any($callback = NULL);

function Union($enumerable);

function UnionAll($enumerable);

function Take($take);

function SelectMany(\Closure $func);

function Zip($other, \Closure $func);
}

Interface-nek nem kicsi, sőt, az igaziban ennél több is van, .NET programozók már észlelhetik, miről van szó.

Mi a közös ezekben a metódusokban, ha implementáljuk őket? Egyiknek sincs szüksége másra, csupán egy bejárható kollekcióra, valamire, amit végig iterálva döntésre juthatnak. PHP van egy IteratorAggregate interface, ami egyetlen metódussal rendelkezik, az is a dokumentáció szerint csak egy Traversable típusú akármit ad vissza, de tételezzük fel, hogy mindenki tud olvasni, és a metódus neve alapján egy Iterator típust ad vissza minden ilyen elem.

Ami a nagy ötlet, hogy az interface (IEnumerable) megvalósíthatjuk egyetlen trait felhasználásával, nyilván, a kódba nem írhatjuk bele, hogy implements \IteratorAggregate, mert teljesen értelmetlen lenne, ezért tilva is van, de rakhatunk bele valami ilyesmit:

trait TEnumerable {

/* ... */

private function _getSource() {
if (!($this instanceof \IteratorAggregate)) {
throw new \Exception("TEnumerable user class must implement \\IteratorAggregate");
}

return $this->getIterator();
}

}

Semmi extra, csak azt írjuk elő, hogy a trait-et használó osztály implementálja már az IteratorAggregate interface-t, mert arra támaszkodunk mindvégig. Az összes IEnumerable interface által előírt metódust tudjuk implementálni a trait-ben a getSource() meghívásával legyen az a Single() vagy épp a SelectMany().

Amit nyerünk vele, az az, hogy az összes különlegesebb osztály pl. egy ObjectGroup, aminek egy szekvenciáját egy ObjectGroupContainer adja GroupBy() után implementálhatja gyorsan az IEnumerable-t a trait felhasználásával és az IteratorAggregate implementálásával.

<?php

namespace System\Collections;

class ObjectGroupContainer implements \IteratorAggregate, IEnumerable {

use TEnumerable;

protected $_container;

public function __construct(\SplFixedArray $source) {
$this->_container = $source;
}

public function Having(\Closure $callback) {
$callback = function (ObjectGroup $og) use ($callback) {
return $callback($og);
};
$tmp = array();

foreach ($this->_container as $value) {
/* @var $value ObjectGroup */
if ($callback($value)) {
$tmp[] = $value;
}
}

return new ObjectGroupContainer(\SplFixedArray::fromArray($tmp));
}

public function getIterator() {
return $this->_container;
}

}

Látható, hogy nem kellett összetörnünk magunkat az IEnumerable működés elérése miatt, szemfülesek észrevehetik, hogy a Having kódját érdemes volna valami értelmesebb osztállyal megvalósítani, de majd egyszer.

Ami nagyon klasz, hogy a trait-ben implementált metódusokat felülírhatjuk, így pl. létrehozhatunk egy WhereEnumerable : IteratorAggregate, IEnumerable típus, amiben készíthetünk olyan Where metódusimplementációt, ami egy deferred execution-t lehetővé tevő Closure-rel és más típusokkal operál, így pl. 50 egymás utána Where() hívás lemegy egyetlen iterációval. Hasonlót lehet elérni Skip-Then esetén, de ugyanez játszik az OrderBy-ThenBy esetében is.

Nagyon király.