interface/modules/zend_modules/library/Zend/Di/Definition/BuilderDefinition.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Di\Definition;
  11
  12 use Zend\Di\Exception;
  13
  14 /**
  15  * Class definitions based on a configuration array
  16  */
  17 class BuilderDefinition implements DefinitionInterface
  18 {
  19     /**
  20      * @var string
  21      */
  22     protected $defaultClassBuilder = 'Zend\Di\Definition\Builder\PhpClass';
  23
  24     /**
  25      * @var Builder\PhpClass[]
  26      */
  27     protected $classes = array();
  28
  29     /**
  30      * Create classes from array
  31      *
  32      * @param  array $builderData
  33      * @return void
  34      */
  35     public function createClassesFromArray(array $builderData)
  36     {
  37         foreach ($builderData as $className => $classInfo) {
  38             $class = new Builder\PhpClass();
  39             $class->setName($className);
  40             foreach ($classInfo as $type => $typeData) {
  41                 switch (strtolower($type)) {
  42                     case 'supertypes':
  43                         foreach ($typeData as $superType) {
  44                             $class->addSuperType($superType);
  45                         }
  46                         break;
  47                     case 'instantiator':
  48                         $class->setInstantiator($typeData);
  49                         break;
  50                     case 'methods':
  51                     case 'method':
  52                         foreach ($typeData as $injectionMethodName => $injectionMethodData) {
  53                             $injectionMethod = new Builder\InjectionMethod();
  54                             $injectionMethod->setName($injectionMethodName);
  55                             foreach ($injectionMethodData as $parameterName => $parameterType) {
  56                                 $parameterType = ($parameterType) ?: null; // force empty string to null
  57                                 $injectionMethod->addParameter($parameterName, $parameterType);
  58                             }
  59                             $class->addInjectionMethod($injectionMethod);
  60                         }
  61                         break;
  62
  63                 }
  64             }
  65             $this->addClass($class);
  66         }
  67     }
  68
  69     /**
  70      * Add class
  71      *
  72      * @param  Builder\PhpClass  $phpClass
  73      * @return BuilderDefinition
  74      */
  75     public function addClass(Builder\PhpClass $phpClass)
  76     {
  77         $this->classes[] = $phpClass;
  78
  79         return $this;
  80     }
  81
  82     /**
  83      * Create a class builder object using default class builder class
  84      *
  85      * This method is a factory that can be used in place of addClass().
  86      *
  87      * @param  null|string      $name Optional name of class to assign
  88      * @return Builder\PhpClass
  89      */
  90     public function createClass($name = null)
  91     {
  92         $builderClass = $this->defaultClassBuilder;
  93         /* @var $class Builder\PhpClass */
  94         $class = new $builderClass();
  95
  96         if (null !== $name) {
  97             $class->setName($name);
  98         }
  99
 100         $this->addClass($class);
 101
 102         return $class;
 103     }
 104
 105     /**
 106      * Set the class to use with {@link createClass()}
 107      *
 108      * @param  string            $class
 109      * @return BuilderDefinition
 110      */
 111     public function setClassBuilder($class)
 112     {
 113         $this->defaultClassBuilder = $class;
 114
 115         return $this;
 116     }
 117
 118     /**
 119      * Get the class used for {@link createClass()}
 120      *
 121      * This is primarily to allow developers to temporarily override
 122      * the builder strategy.
 123      *
 124      * @return string
 125      */
 126     public function getClassBuilder()
 127     {
 128         return $this->defaultClassBuilder;
 129     }
 130
 131     /**
 132      * {@inheritDoc}
 133      */
 134     public function getClasses()
 135     {
 136         $classNames = array();
 137
 138         /* @var $class Builder\PhpClass */
 139         foreach ($this->classes as $class) {
 140             $classNames[] = $class->getName();
 141         }
 142
 143         return $classNames;
 144     }
 145
 146     /**
 147      * {@inheritDoc}
 148      */
 149     public function hasClass($class)
 150     {
 151         foreach ($this->classes as $classObj) {
 152             if ($classObj->getName() === $class) {
 153                 return true;
 154             }
 155         }
 156
 157         return false;
 158     }
 159
 160     /**
 161      * @param  string                $name
 162      * @return bool|Builder\PhpClass
 163      */
 164     protected function getClass($name)
 165     {
 166         foreach ($this->classes as $classObj) {
 167             if ($classObj->getName() === $name) {
 168                 return $classObj;
 169             }
 170         }
 171
 172         return false;
 173     }
 174
 175     /**
 176      * {@inheritDoc}
 177      * @throws \Zend\Di\Exception\RuntimeException
 178      */
 179     public function getClassSupertypes($class)
 180     {
 181         $class = $this->getClass($class);
 182
 183         if ($class === false) {
 184             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 185         }
 186
 187         return $class->getSuperTypes();
 188     }
 189
 190     /**
 191      * {@inheritDoc}
 192      * @throws \Zend\Di\Exception\RuntimeException
 193      */
 194     public function getInstantiator($class)
 195     {
 196         $class = $this->getClass($class);
 197         if ($class === false) {
 198             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 199         }
 200
 201         return $class->getInstantiator();
 202     }
 203
 204     /**
 205      * {@inheritDoc}
 206      * @throws \Zend\Di\Exception\RuntimeException
 207      */
 208     public function hasMethods($class)
 209     {
 210         /* @var $class \Zend\Di\Definition\Builder\PhpClass */
 211         $class = $this->getClass($class);
 212         if ($class === false) {
 213             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 214         }
 215
 216         return (count($class->getInjectionMethods()) > 0);
 217     }
 218
 219     /**
 220      * {@inheritDoc}
 221      * @throws \Zend\Di\Exception\RuntimeException
 222      */
 223     public function getMethods($class)
 224     {
 225         $class = $this->getClass($class);
 226         if ($class === false) {
 227             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 228         }
 229         $methods = $class->getInjectionMethods();
 230         $methodNames = array();
 231
 232         /* @var $methodObj Builder\InjectionMethod */
 233         foreach ($methods as $methodObj) {
 234             $methodNames[] = $methodObj->getName();
 235         }
 236
 237         return $methodNames;
 238     }
 239
 240     /**
 241      * {@inheritDoc}
 242      * @throws \Zend\Di\Exception\RuntimeException
 243      */
 244     public function hasMethod($class, $method)
 245     {
 246         $class = $this->getClass($class);
 247         if ($class === false) {
 248             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 249         }
 250         $methods = $class->getInjectionMethods();
 251
 252         /* @var $methodObj Builder\InjectionMethod */
 253         foreach ($methods as $methodObj) {
 254             if ($methodObj->getName() === $method) {
 255                 return true;
 256             }
 257         }
 258
 259         return false;
 260     }
 261
 262     /**
 263      * {@inheritDoc}
 264      */
 265     public function hasMethodParameters($class, $method)
 266     {
 267         $class = $this->getClass($class);
 268         if ($class === false) {
 269             return false;
 270         }
 271         $methods = $class->getInjectionMethods();
 272         /* @var $methodObj Builder\InjectionMethod */
 273         foreach ($methods as $methodObj) {
 274             if ($methodObj->getName() === $method) {
 275                 $method = $methodObj;
 276             }
 277         }
 278         if (!$method instanceof Builder\InjectionMethod) {
 279             return false;
 280         }
 281
 282         /* @var $method Builder\InjectionMethod */
 283
 284         return (count($method->getParameters()) > 0);
 285     }
 286
 287     /**
 288      * {@inheritDoc}
 289      * @throws \Zend\Di\Exception\RuntimeException
 290      */
 291     public function getMethodParameters($class, $method)
 292     {
 293         $class = $this->getClass($class);
 294
 295         if ($class === false) {
 296             throw new Exception\RuntimeException('Cannot find class object in this builder definition.');
 297         }
 298
 299         $methods = $class->getInjectionMethods();
 300
 301         /* @var $methodObj Builder\InjectionMethod */
 302         foreach ($methods as $methodObj) {
 303             if ($methodObj->getName() === $method) {
 304                 $method = $methodObj;
 305             }
 306         }
 307
 308         if (!$method instanceof Builder\InjectionMethod) {
 309             throw new Exception\RuntimeException('Cannot find method object for method ' . $method . ' in this builder definition.');
 310         }
 311
 312         $methodParameters = array();
 313
 314         /* @var $method Builder\InjectionMethod */
 315         foreach ($method->getParameters() as $name => $info) {
 316             $methodParameters[$class->getName() . '::' . $method->getName() . ':' . $name] = $info;
 317         }
 318
 319         return $methodParameters;
 320     }
 321 }