Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

353 lines (317 sloc) 10.3 kb
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @link http://github.com/zendframework/zf2 for the canonical source repository
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
namespace Zend\Di;
use SplDoublyLinkedList;
use Zend\Di\Definition\RuntimeDefinition;
/**
* Class definition based on multiple definitions
*/
class DefinitionList extends SplDoublyLinkedList implements Definition\DefinitionInterface
{
protected $classes = array();
protected $runtimeDefinitions;
/**
* @param Definition\DefinitionInterface|Definition\DefinitionInterface[] $definitions
*/
public function __construct($definitions)
{
$this->runtimeDefinitions = new SplDoublyLinkedList();
if (!is_array($definitions)) {
$definitions = array($definitions);
}
foreach ($definitions as $definition) {
$this->addDefinition($definition, true);
}
}
/**
* Add definitions
*
* @param Definition\DefinitionInterface $definition
* @param bool $addToBackOfList
* @return void
*/
public function addDefinition(Definition\DefinitionInterface $definition, $addToBackOfList = true)
{
if ($addToBackOfList) {
$this->push($definition);
} else {
$this->unshift($definition);
}
}
protected function getDefinitionClassMap(Definition\DefinitionInterface $definition)
{
$definitionClasses = $definition->getClasses();
if (empty($definitionClasses)) {
return array();
}
return array_combine(array_values($definitionClasses), array_fill(0, count($definitionClasses), $definition));
}
public function unshift($definition)
{
$result = parent::unshift($definition);
if ($definition instanceof RuntimeDefinition) {
$this->runtimeDefinitions->unshift($definition);
}
$this->classes = array_merge($this->classes, $this->getDefinitionClassMap($definition));
return $result;
}
public function push($definition)
{
$result = parent::push($definition);
if ($definition instanceof RuntimeDefinition) {
$this->runtimeDefinitions->push($definition);
}
$this->classes = array_merge($this->getDefinitionClassMap($definition), $this->classes);
return $result;
}
/**
* @param string $type
* @return Definition\DefinitionInterface[]
*/
public function getDefinitionsByType($type)
{
$definitions = array();
foreach ($this as $definition) {
if ($definition instanceof $type) {
$definitions[] = $definition;
}
}
return $definitions;
}
/**
* Get definition by type
*
* @param string $type
* @return Definition\DefinitionInterface
*/
public function getDefinitionByType($type)
{
foreach ($this as $definition) {
if ($definition instanceof $type) {
return $definition;
}
}
return false;
}
/**
* @param string $class
* @return bool|Definition\DefinitionInterface
*/
public function getDefinitionForClass($class)
{
if (array_key_exists($class, $this->classes)) {
return $this->classes[$class];
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this->runtimeDefinitions as $definition) {
if ($definition->hasClass($class)) {
return $definition;
}
}
return false;
}
/**
* @param string $class
* @return bool|Definition\DefinitionInterface
*/
public function forClass($class)
{
return $this->getDefinitionForClass($class);
}
/**
* {@inheritDoc}
*/
public function getClasses()
{
return array_keys($this->classes);
}
/**
* {@inheritDoc}
*/
public function hasClass($class)
{
if (array_key_exists($class, $this->classes)) {
return true;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this->runtimeDefinitions as $definition) {
if ($definition->hasClass($class)) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public function getClassSupertypes($class)
{
if (false === ($classDefinition = $this->getDefinitionForClass($class))) {
return array();
}
$supertypes = $classDefinition->getClassSupertypes($class);
if (! $classDefinition instanceof Definition\PartialMarker) {
return $supertypes;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class)) {
$supertypes = array_merge($supertypes, $definition->getClassSupertypes($class));
if ($definition instanceof Definition\PartialMarker) {
continue;
}
return $supertypes;
}
}
return $supertypes;
}
/**
* {@inheritDoc}
*/
public function getInstantiator($class)
{
if (! $classDefinition = $this->getDefinitionForClass($class)) {
return false;
}
$value = $classDefinition->getInstantiator($class);
if (!is_null($value)) {
return $value;
}
if (! $classDefinition instanceof Definition\PartialMarker) {
return false;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class)) {
$value = $definition->getInstantiator($class);
if ($value === null && $definition instanceof Definition\PartialMarker) {
continue;
}
return $value;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public function hasMethods($class)
{
if (! $classDefinition = $this->getDefinitionForClass($class)) {
return false;
}
if (false !== ($methods = $classDefinition->hasMethods($class))) {
return $methods;
}
if (! $classDefinition instanceof Definition\PartialMarker) {
return false;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class)) {
if ($definition->hasMethods($class) === false && $definition instanceof Definition\PartialMarker) {
continue;
}
return $definition->hasMethods($class);
}
}
return false;
}
/**
* {@inheritDoc}
*/
public function hasMethod($class, $method)
{
if (!$this->hasMethods($class)) {
return false;
}
$classDefinition = $this->getDefinitionForClass($class);
if ($classDefinition->hasMethod($class, $method)) {
return true;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this->runtimeDefinitions as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class) && $definition->hasMethod($class, $method)) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public function getMethods($class)
{
if (false === ($classDefinition = $this->getDefinitionForClass($class))) {
return array();
}
$methods = $classDefinition->getMethods($class);
if (! $classDefinition instanceof Definition\PartialMarker) {
return $methods;
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class)) {
if (!$definition instanceof Definition\PartialMarker) {
return array_merge($definition->getMethods($class), $methods);
}
$methods = array_merge($definition->getMethods($class), $methods);
}
}
return $methods;
}
/**
* {@inheritDoc}
*/
public function hasMethodParameters($class, $method)
{
$methodParameters = $this->getMethodParameters($class, $method);
return ($methodParameters !== array());
}
/**
* {@inheritDoc}
*/
public function getMethodParameters($class, $method)
{
if (false === ($classDefinition = $this->getDefinitionForClass($class))) {
return array();
}
if ($classDefinition->hasMethod($class, $method) && $classDefinition->hasMethodParameters($class, $method)) {
return $classDefinition->getMethodParameters($class, $method);
}
/** @var $definition Definition\DefinitionInterface */
foreach ($this as $definition) {
if ($definition === $classDefinition) {
continue;
}
if ($definition->hasClass($class)
&& $definition->hasMethod($class, $method)
&& $definition->hasMethodParameters($class, $method)
) {
return $definition->getMethodParameters($class, $method);
}
}
return array();
}
}
Jump to Line
Something went wrong with that request. Please try again.