interface/modules/zend_modules/library/Zend/Code/Reflection/ClassReflection.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\Code\Reflection;
  11
  12 use ReflectionClass;
  13 use Zend\Code\Annotation\AnnotationCollection;
  14 use Zend\Code\Annotation\AnnotationManager;
  15 use Zend\Code\Reflection\FileReflection;
  16 use Zend\Code\Scanner\AnnotationScanner;
  17 use Zend\Code\Scanner\FileScanner;
  18
  19 class ClassReflection extends ReflectionClass implements ReflectionInterface
  20 {
  21     /**
  22      * @var AnnotationScanner
  23      */
  24     protected $annotations = null;
  25
  26     /**
  27      * @var DocBlockReflection
  28      */
  29     protected $docBlock = null;
  30
  31     /**
  32      * Return the reflection file of the declaring file.
  33      *
  34      * @return FileReflection
  35      */
  36     public function getDeclaringFile()
  37     {
  38         $instance = new FileReflection($this->getFileName());
  39
  40         return $instance;
  41     }
  42
  43     /**
  44      * Return the classes DocBlock reflection object
  45      *
  46      * @return DocBlockReflection
  47      * @throws Exception\ExceptionInterface for missing DocBock or invalid reflection class
  48      */
  49     public function getDocBlock()
  50     {
  51         if (isset($this->docBlock)) {
  52             return $this->docBlock;
  53         }
  54
  55         if ('' == $this->getDocComment()) {
  56             return false;
  57         }
  58
  59         $this->docBlock = new DocBlockReflection($this);
  60
  61         return $this->docBlock;
  62     }
  63
  64     /**
  65      * @param  AnnotationManager $annotationManager
  66      * @return AnnotationCollection
  67      */
  68     public function getAnnotations(AnnotationManager $annotationManager)
  69     {
  70         $docComment = $this->getDocComment();
  71
  72         if ($docComment == '') {
  73             return false;
  74         }
  75
  76         if ($this->annotations) {
  77             return $this->annotations;
  78         }
  79
  80         $fileScanner       = $this->createFileScanner($this->getFileName());
  81         $nameInformation   = $fileScanner->getClassNameInformation($this->getName());
  82
  83         if (!$nameInformation) {
  84             return false;
  85         }
  86
  87         $this->annotations = new AnnotationScanner($annotationManager, $docComment, $nameInformation);
  88
  89         return $this->annotations;
  90     }
  91
  92     /**
  93      * Return the start line of the class
  94      *
  95      * @param  bool $includeDocComment
  96      * @return int
  97      */
  98     public function getStartLine($includeDocComment = false)
  99     {
 100         if ($includeDocComment && $this->getDocComment() != '') {
 101             return $this->getDocBlock()->getStartLine();
 102         }
 103
 104         return parent::getStartLine();
 105     }
 106
 107     /**
 108      * Return the contents of the class
 109      *
 110      * @param  bool $includeDocBlock
 111      * @return string
 112      */
 113     public function getContents($includeDocBlock = true)
 114     {
 115         $filename  = $this->getFileName();
 116         $filelines = file($filename);
 117         $startnum  = $this->getStartLine($includeDocBlock);
 118         $endnum    = $this->getEndLine() - $this->getStartLine();
 119
 120         // Ensure we get between the open and close braces
 121         $lines = array_slice($filelines, $startnum, $endnum);
 122         array_unshift($lines, $filelines[$startnum-1]);
 123
 124         return strstr(implode('', $lines), '{');
 125     }
 126
 127     /**
 128      * Get all reflection objects of implemented interfaces
 129      *
 130      * @return ClassReflection[]
 131      */
 132     public function getInterfaces()
 133     {
 134         $phpReflections  = parent::getInterfaces();
 135         $zendReflections = array();
 136         while ($phpReflections && ($phpReflection = array_shift($phpReflections))) {
 137             $instance          = new ClassReflection($phpReflection->getName());
 138             $zendReflections[] = $instance;
 139             unset($phpReflection);
 140         }
 141         unset($phpReflections);
 142
 143         return $zendReflections;
 144     }
 145
 146     /**
 147      * Return method reflection by name
 148      *
 149      * @param  string $name
 150      * @return MethodReflection
 151      */
 152     public function getMethod($name)
 153     {
 154         $method = new MethodReflection($this->getName(), parent::getMethod($name)->getName());
 155
 156         return $method;
 157     }
 158
 159     /**
 160      * Get reflection objects of all methods
 161      *
 162      * @param  string $filter
 163      * @return MethodReflection[]
 164      */
 165     public function getMethods($filter = -1)
 166     {
 167         $methods = array();
 168         foreach (parent::getMethods($filter) as $method) {
 169             $instance  = new MethodReflection($this->getName(), $method->getName());
 170             $methods[] = $instance;
 171         }
 172
 173         return $methods;
 174     }
 175
 176     /**
 177      * Get parent reflection class of reflected class
 178      *
 179      * @return ClassReflection|bool
 180      */
 181     public function getParentClass()
 182     {
 183         $phpReflection = parent::getParentClass();
 184         if ($phpReflection) {
 185             $zendReflection = new ClassReflection($phpReflection->getName());
 186             unset($phpReflection);
 187
 188             return $zendReflection;
 189         }
 190
 191         return false;
 192     }
 193
 194     /**
 195      * Return reflection property of this class by name
 196      *
 197      * @param  string $name
 198      * @return PropertyReflection
 199      */
 200     public function getProperty($name)
 201     {
 202         $phpReflection  = parent::getProperty($name);
 203         $zendReflection = new PropertyReflection($this->getName(), $phpReflection->getName());
 204         unset($phpReflection);
 205
 206         return $zendReflection;
 207     }
 208
 209     /**
 210      * Return reflection properties of this class
 211      *
 212      * @param  int $filter
 213      * @return PropertyReflection[]
 214      */
 215     public function getProperties($filter = -1)
 216     {
 217         $phpReflections  = parent::getProperties($filter);
 218         $zendReflections = array();
 219         while ($phpReflections && ($phpReflection = array_shift($phpReflections))) {
 220             $instance          = new PropertyReflection($this->getName(), $phpReflection->getName());
 221             $zendReflections[] = $instance;
 222             unset($phpReflection);
 223         }
 224         unset($phpReflections);
 225
 226         return $zendReflections;
 227     }
 228
 229     public function toString()
 230     {
 231         return parent::__toString();
 232     }
 233
 234     public function __toString()
 235     {
 236         return parent::__toString();
 237     }
 238
 239     /**
 240      * Creates a new FileScanner instance.
 241      *
 242      * By having this as a seperate method it allows the method to be overridden
 243      * if a different FileScanner is needed.
 244      *
 245      * @param  string $filename
 246      *
 247      * @return FileScanner
 248      */
 249     protected function createFileScanner($filename)
 250     {
 251         return new FileScanner($filename);
 252     }
 253 }