$aDate = new \DateTime($a['date']);

$bDate = new \DateTime($b['date']);

private static $instance;

namespace DesignPatterns\Pool;

class Pool

{

private $instances = array();

private $class;

public function __construct($class)

{

$this->class = $class;

}

public function get()

{

if (count($this->instances) > 0) {

return array_pop($this->instances);

}

return new $this->class();

}

public function dispose($instance)

{

$this->instances[] = $instance;

}

}

namespace DesignPatterns\Pool;

class Processor

{

private $pool;

private $processing = 0;

private $maxProcesses = 3;

private $waitingQueue = [];

public function __construct(Pool $pool)

{

$this->pool = $pool;

}

public function process($image)

{

if ($this->processing++ < $this->maxProcesses) {

$this->createWorker($image);

} else {

$this->pushToWaitingQueue($worker);

}

}

private function createWorker($image)

{

$worker = $this->pool->get();

$worker->run($image, array($this, 'processDone'));

}

public function processDone($worker)

{

$this->processing--;

$this->pool->dispose($worker);

if (count($this->waitingQueue) > 0) {

$this->createWorker($this->popFromWaitingQueue());

}

}

private function pushToWaitingQueue($image)

{

$this->waitingQueue[] = $image;

}

private function popFromWaitingQueue()

{

return array_pop($this->waitingQueue);

}

}

Pool

The **object pool pattern** is a software creational design pattern that uses a set of initialized objects kept ready to use – a "pool" – rather than allocating and destroying them on demand. A client of the pool will request an object from the pool and perform operations on the returned object. When the client has finished, it returns the object, which is a specific type of factory object, to the pool rather than destroying it.

Object pooling can offer a significant performance boost in situations where the cost of initializing a class instance is high, the rate of instantiation of a class is high, and the number of instances in use at any one time is low. The pooled object is obtained in predictable time when creation of the new objects (especially over network) may take variable time.

However these benefits are mostly true for objects that are expensive with respect to time, such as database connections, socket connections, threads and large graphic objects like fonts or bitmaps. In certain situations, simple object pooling (that hold no external resources, but only occupy memory) may not be efficient and could decrease performance.

namespace DesignPatterns\Pool;

class Worker

{

public function __construct()

{

// let's say that constuctor does really expensive work...

// for example creates "thread"

}

public function run($image, array $callback)

{

// do something with $image...

// and when it's done, execute callback

call_user_func($callback, $this);

}

}

use DesignPatterns\Pool\Pool;

use DesignPatterns\Pool\Processor;

$pool = new Pool('DesignPatterns\Pool\Worker');

$processor = new Processor($pool);

$processor->process('image1.jpg');

$processor->process('image2.jpg');

$processor->process('image3.jpg');

$processor->process('image4.jpg');

$processor->process('image5.jpg');

$processor->process('image6.jpg');

$processor->process('image7.jpg');

$processor->process('image8.jpg');

The patterns can be structured in roughly three different categories. Please click on the [:notebook:](http://en.wikipedia.org/wiki/Software_design_pattern) for a full explanation of the pattern on Wikipedia.

* [Pool](Pool) [:notebook:](http://en.wikipedia.org/wiki/Object_pool_pattern)

To treat a group of objects the same way as a single instance of the object.

subsequently runs through all its child elements and calls `render()` on them

Configuration gets injected and `Connection` will get all that it needs from `$config`. Without DI, the configuration would be created directly in `Connection`, which is not very good for testing and extending `Connection`.

Notice we are following Inversion of control principle in `Connection` by asking `$config` to implement `Parameters` interface. This decouples our components. We don't care where the source of information comes from, we only care that `$config` has certain methods to retrieve that information. Read more about Inversion of control [here](http://en.wikipedia.org/wiki/Inversion_of_control).

* The Doctrine2 ORM uses dependency injection e.g. for configuration that is injected into a `Connection` object. For testing purposes, one can easily create a mock object of the configuration and inject that into the `Connection` object

namespace DesignPatterns\Tests\Pool;

use DesignPatterns\Pool\Pool;

class TestWorker

{

public $id = 1;

}

class PoolTest extends \PHPUnit_Framework_TestCase

{

public function testPool()

{

$pool = new Pool('DesignPatterns\Tests\Pool\TestWorker');

$worker = $pool->get();

$this->assertEquals(1, $worker->id);

$worker->id = 5;

$pool->dispose($worker);

$this->assertEquals(5, $pool->get()->id);

$this->assertEquals(1, $pool->get()->id);

}

}

namespace DesignPatterns\Tests\Strategy;

use DesignPatterns\Strategy\DateComparator;

use DesignPatterns\Strategy\IdComparator;

use DesignPatterns\Strategy\ObjectCollection;

use DesignPatterns\Strategy\Strategy;

class StrategyTest extends \PHPUnit_Framework_TestCase

{

public function getIdCollection()

{

return array(

array(

array(array('id' => 2), array('id' => 1), array('id' => 3)),

array('id' => 1)

),

array(

array(array('id' => 3), array('id' => 2), array('id' => 1)),

array('id' => 1)

),

);

}

public function getDateCollection()

{

return array(

array(

array(array('date' => '2014-03-03'), array('date' => '2015-03-02'), array('date' => '2013-03-01')),

array('date' => '2013-03-01')

),

array(

array(array('date' => '2014-02-03'), array('date' => '2013-02-01'), array('date' => '2015-02-02')),

array('date' => '2013-02-01')

),

);

}

/**

public function testIdComparator($collection, $expected)

{

$obj = new ObjectCollection($collection);

$obj->setComparator(new IdComparator());

$elements = $obj->sort();

$firstElement = array_shift($elements);

$this->assertEquals($expected, $firstElement);

}

/**

public function testDateComparator($collection, $expected)

{

$obj = new ObjectCollection($collection);

$obj->setComparator(new DateComparator());

$elements = $obj->sort();

$firstElement = array_shift($elements);

$this->assertEquals($expected, $firstElement);

}

}