1 <?php

     2 /**

     3  * Zend Framework

     4  *

     5  * LICENSE

     6  *

     7  * This source file is subject to the new BSD license that is bundled

     8  * with this package in the file LICENSE.txt.

     9  * It is also available through the world-wide-web at this URL:

    10  * http://framework.zend.com/license/new-bsd

    11  * If you did not receive a copy of the license and are unable to

    12  * obtain it through the world-wide-web, please send an email

    13  * to license@zend.com so we can send you a copy immediately.

    14  *

    15  * @category   Zend

    16  * @package    Zend_Reflection

    17  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    18  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    19  * @version    $Id: Class.php 20096 2010-01-06 02:05:09Z bkarwin $

    20  */

    21 

    22 /**

    23  * @see Zend_Reflection_Property

    24  */

    25 require_once 'Zend/Reflection/Property.php';

    26 

    27 /**

    28  * @see Zend_Reflection_Method

    29  */

    30 require_once 'Zend/Reflection/Method.php';

    31 

    32 /**

    33  * Zend_Reflection_Docblock

    34  */

    35 require_once 'Zend/Reflection/Docblock.php';

    36 

    37 /**

    38  * @category   Zend

    39  * @package    Zend_Reflection

    40  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    41  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    42  */

    43 class Zend_Reflection_Class extends ReflectionClass

    44 {

    45     /**

    46      * Return the reflection file of the declaring file.

    47      *

    48      * @return Zend_Reflection_File

    49      */

    50     public function getDeclaringFile($reflectionClass = 'Zend_Reflection_File')

    51     {

    52         $instance = new $reflectionClass($this->getFileName());

    53         if (!$instance instanceof Zend_Reflection_File) {

    54             require_once 'Zend/Reflection/Exception.php';

    55             throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_File');

    56         }

    57         return $instance;

    58     }

    59 

    60     /**

    61      * Return the classes Docblock reflection object

    62      *

    63      * @param  string $reflectionClass Name of reflection class to use

    64      * @return Zend_Reflection_Docblock

    65      * @throws Zend_Reflection_Exception for missing docblock or invalid reflection class

    66      */

    67     public function getDocblock($reflectionClass = 'Zend_Reflection_Docblock')

    68     {

    69         if ('' == $this->getDocComment()) {

    70             require_once 'Zend/Reflection/Exception.php';

    71             throw new Zend_Reflection_Exception($this->getName() . ' does not have a docblock');

    72         }

    73 

    74         $instance = new $reflectionClass($this);

    75         if (!$instance instanceof Zend_Reflection_Docblock) {

    76             require_once 'Zend/Reflection/Exception.php';

    77             throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Docblock');

    78         }

    79         return $instance;

    80     }

    81 

    82     /**

    83      * Return the start line of the class

    84      *

    85      * @param bool $includeDocComment

    86      * @return int

    87      */

    88     public function getStartLine($includeDocComment = false)

    89     {

    90         if ($includeDocComment) {

    91             if ($this->getDocComment() != '') {

    92                 return $this->getDocblock()->getStartLine();

    93             }

    94         }

    95 

    96         return parent::getStartLine();

    97     }

    98 

    99     /**

   100      * Return the contents of the class

   101      *

   102      * @param bool $includeDocblock

   103      * @return string

   104      */

   105     public function getContents($includeDocblock = true)

   106     {

   107         $filename  = $this->getFileName();

   108         $filelines = file($filename);

   109         $startnum  = $this->getStartLine($includeDocblock);

   110         $endnum    = $this->getEndLine() - $this->getStartLine();

   111 

   112         return implode('', array_splice($filelines, $startnum, $endnum, true));

   113     }

   114 

   115     /**

   116      * Get all reflection objects of implemented interfaces

   117      *

   118      * @param  string $reflectionClass Name of reflection class to use

   119      * @return array Array of Zend_Reflection_Class

   120      */

   121     public function getInterfaces($reflectionClass = 'Zend_Reflection_Class')

   122     {

   123         $phpReflections  = parent::getInterfaces();

   124         $zendReflections = array();

   125         while ($phpReflections && ($phpReflection = array_shift($phpReflections))) {

   126             $instance = new $reflectionClass($phpReflection->getName());

   127             if (!$instance instanceof Zend_Reflection_Class) {

   128                 require_once 'Zend/Reflection/Exception.php';

   129                 throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Class');

   130             }

   131             $zendReflections[] = $instance;

   132             unset($phpReflection);

   133         }

   134         unset($phpReflections);

   135         return $zendReflections;

   136     }

   137 

   138     /**

   139      * Return method reflection by name

   140      *

   141      * @param  string $name

   142      * @param  string $reflectionClass Reflection class to utilize

   143      * @return Zend_Reflection_Method

   144      */

   145     public function getMethod($name, $reflectionClass = 'Zend_Reflection_Method')

   146     {

   147         $phpReflection  = parent::getMethod($name);

   148         $zendReflection = new $reflectionClass($this->getName(), $phpReflection->getName());

   149 

   150         if (!$zendReflection instanceof Zend_Reflection_Method) {

   151             require_once 'Zend/Reflection/Exception.php';

   152             throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Method');

   153         }

   154 

   155         unset($phpReflection);

   156         return $zendReflection;

   157     }

   158 

   159     /**

   160      * Get reflection objects of all methods

   161      *

   162      * @param  string $filter

   163      * @param  string $reflectionClass Reflection class to use for methods

   164      * @return array Array of Zend_Reflection_Method objects

   165      */

   166     public function getMethods($filter = -1, $reflectionClass = 'Zend_Reflection_Method')

   167     {

   168         $phpReflections  = parent::getMethods($filter);

   169         $zendReflections = array();

   170         while ($phpReflections && ($phpReflection = array_shift($phpReflections))) {

   171             $instance = new $reflectionClass($this->getName(), $phpReflection->getName());

   172             if (!$instance instanceof Zend_Reflection_Method) {

   173                 require_once 'Zend/Reflection/Exception.php';

   174                 throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Method');

   175             }

   176             $zendReflections[] = $instance;

   177             unset($phpReflection);

   178         }

   179         unset($phpReflections);

   180         return $zendReflections;

   181     }

   182 

   183     /**

   184      * Get parent reflection class of reflected class

   185      *

   186      * @param  string $reflectionClass Name of Reflection class to use

   187      * @return Zend_Reflection_Class

   188      */

   189     public function getParentClass($reflectionClass = 'Zend_Reflection_Class')

   190     {

   191         $phpReflection = parent::getParentClass();

   192         if ($phpReflection) {

   193             $zendReflection = new $reflectionClass($phpReflection->getName());

   194             if (!$zendReflection instanceof Zend_Reflection_Class) {

   195                 require_once 'Zend/Reflection/Exception.php';

   196                 throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Class');

   197             }

   198             unset($phpReflection);

   199             return $zendReflection;

   200         } else {

   201             return false;

   202         }

   203     }

   204 

   205     /**

   206      * Return reflection property of this class by name

   207      *

   208      * @param  string $name

   209      * @param  string $reflectionClass Name of reflection class to use

   210      * @return Zend_Reflection_Property

   211      */

   212     public function getProperty($name, $reflectionClass = 'Zend_Reflection_Property')

   213     {

   214         $phpReflection  = parent::getProperty($name);

   215         $zendReflection = new $reflectionClass($this->getName(), $phpReflection->getName());

   216         if (!$zendReflection instanceof Zend_Reflection_Property) {

   217             require_once 'Zend/Reflection/Exception.php';

   218             throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Property');

   219         }

   220         unset($phpReflection);

   221         return $zendReflection;

   222     }

   223 

   224     /**

   225      * Return reflection properties of this class

   226      *

   227      * @param  int $filter

   228      * @param  string $reflectionClass Name of reflection class to use

   229      * @return array Array of Zend_Reflection_Property

   230      */

   231     public function getProperties($filter = -1, $reflectionClass = 'Zend_Reflection_Property')

   232     {

   233         $phpReflections = parent::getProperties($filter);

   234         $zendReflections = array();

   235         while ($phpReflections && ($phpReflection = array_shift($phpReflections))) {

   236             $instance = new $reflectionClass($this->getName(), $phpReflection->getName());

   237             if (!$instance instanceof Zend_Reflection_Property) {

   238                 require_once 'Zend/Reflection/Exception.php';

   239                 throw new Zend_Reflection_Exception('Invalid reflection class specified; must extend Zend_Reflection_Property');

   240             }

   241             $zendReflections[] = $instance;

   242             unset($phpReflection);

   243         }

   244         unset($phpReflections);

   245         return $zendReflections;

   246     }

   247 }