vendor/doctrine/common/lib/Doctrine/Common/Reflection/StaticReflectionClass.php

   1 <?php
   2 /*
   3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14  *
  15  * This software consists of voluntary contributions made by many individuals
  16  * and is licensed under the MIT license. For more information, see
  17  * <http://www.doctrine-project.org>.
  18  */
  19
  20 namespace Doctrine\Common\Reflection;
  21
  22 use ReflectionClass;
  23 use ReflectionException;
  24
  25 class StaticReflectionClass extends ReflectionClass
  26 {
  27     /**
  28      * The static reflection parser object.
  29      *
  30      * @var StaticReflectionParser
  31      */
  32     private $staticReflectionParser;
  33
  34     /**
  35      * @param StaticReflectionParser $staticReflectionParser
  36      */
  37     public function __construct(StaticReflectionParser $staticReflectionParser)
  38     {
  39         $this->staticReflectionParser = $staticReflectionParser;
  40     }
  41
  42     /**
  43      * {@inheritDoc}
  44      */
  45     public function getName()
  46     {
  47         return $this->staticReflectionParser->getClassName();
  48     }
  49
  50     /**
  51      * {@inheritDoc}
  52      */
  53     public function getDocComment()
  54     {
  55         return $this->staticReflectionParser->getDocComment();
  56     }
  57
  58     /**
  59      * {@inheritDoc}
  60      */
  61     public function getNamespaceName()
  62     {
  63         return $this->staticReflectionParser->getNamespaceName();
  64     }
  65
  66     /**
  67      * @return array
  68      */
  69     public function getUseStatements()
  70     {
  71         return $this->staticReflectionParser->getUseStatements();
  72     }
  73
  74     /**
  75      * {@inheritDoc}
  76      */
  77     public function getMethod($name)
  78     {
  79         return $this->staticReflectionParser->getReflectionMethod($name);
  80     }
  81
  82     /**
  83      * {@inheritDoc}
  84      */
  85     public function getProperty($name)
  86     {
  87         return $this->staticReflectionParser->getReflectionProperty($name);
  88     }
  89
  90     /**
  91      * {@inheritDoc}
  92      */
  93     public static function export($argument, $return = false)
  94     {
  95         throw new ReflectionException('Method not implemented');
  96     }
  97
  98     /**
  99      * {@inheritDoc}
 100      */
 101     public function getConstant($name)
 102     {
 103         throw new ReflectionException('Method not implemented');
 104     }
 105
 106     /**
 107      * {@inheritDoc}
 108      */
 109     public function getConstants()
 110     {
 111         throw new ReflectionException('Method not implemented');
 112     }
 113
 114     /**
 115      * {@inheritDoc}
 116      */
 117     public function getConstructor()
 118     {
 119         throw new ReflectionException('Method not implemented');
 120     }
 121
 122     /**
 123      * {@inheritDoc}
 124      */
 125     public function getDefaultProperties()
 126     {
 127         throw new ReflectionException('Method not implemented');
 128     }
 129
 130     /**
 131      * {@inheritDoc}
 132      */
 133     public function getEndLine()
 134     {
 135         throw new ReflectionException('Method not implemented');
 136     }
 137
 138     /**
 139      * {@inheritDoc}
 140      */
 141     public function getExtension()
 142     {
 143         throw new ReflectionException('Method not implemented');
 144     }
 145
 146     /**
 147      * {@inheritDoc}
 148      */
 149     public function getExtensionName()
 150     {
 151         throw new ReflectionException('Method not implemented');
 152     }
 153
 154     /**
 155      * {@inheritDoc}
 156      */
 157     public function getFileName()
 158     {
 159         throw new ReflectionException('Method not implemented');
 160     }
 161
 162     /**
 163      * {@inheritDoc}
 164      */
 165     public function getInterfaceNames()
 166     {
 167         throw new ReflectionException('Method not implemented');
 168     }
 169
 170     /**
 171      * {@inheritDoc}
 172      */
 173     public function getInterfaces()
 174     {
 175         throw new ReflectionException('Method not implemented');
 176     }
 177
 178     /**
 179      * {@inheritDoc}
 180      */
 181     public function getMethods($filter = null)
 182     {
 183         throw new ReflectionException('Method not implemented');
 184     }
 185
 186     /**
 187      * {@inheritDoc}
 188      */
 189     public function getModifiers()
 190     {
 191         throw new ReflectionException('Method not implemented');
 192     }
 193
 194     /**
 195      * {@inheritDoc}
 196      */
 197     public function getParentClass()
 198     {
 199         throw new ReflectionException('Method not implemented');
 200     }
 201
 202     /**
 203      * {@inheritDoc}
 204      */
 205     public function getProperties($filter = null)
 206     {
 207         throw new ReflectionException('Method not implemented');
 208     }
 209
 210     /**
 211      * {@inheritDoc}
 212      */
 213     public function getShortName()
 214     {
 215         throw new ReflectionException('Method not implemented');
 216     }
 217
 218     /**
 219      * {@inheritDoc}
 220      */
 221     public function getStartLine()
 222     {
 223         throw new ReflectionException('Method not implemented');
 224     }
 225
 226     /**
 227      * {@inheritDoc}
 228      */
 229     public function getStaticProperties()
 230     {
 231         throw new ReflectionException('Method not implemented');
 232     }
 233
 234     /**
 235      * {@inheritDoc}
 236      */
 237     public function getStaticPropertyValue($name, $default = '')
 238     {
 239         throw new ReflectionException('Method not implemented');
 240     }
 241
 242     /**
 243      * {@inheritDoc}
 244      */
 245     public function getTraitAliases()
 246     {
 247         throw new ReflectionException('Method not implemented');
 248     }
 249
 250     /**
 251      * {@inheritDoc}
 252      */
 253     public function getTraitNames()
 254     {
 255         throw new ReflectionException('Method not implemented');
 256     }
 257
 258     /**
 259      * {@inheritDoc}
 260      */
 261     public function getTraits()
 262     {
 263         throw new ReflectionException('Method not implemented');
 264     }
 265
 266     /**
 267      * {@inheritDoc}
 268      */
 269     public function hasConstant($name)
 270     {
 271         throw new ReflectionException('Method not implemented');
 272     }
 273
 274     /**
 275      * {@inheritDoc}
 276      */
 277     public function hasMethod($name)
 278     {
 279         throw new ReflectionException('Method not implemented');
 280     }
 281
 282     /**
 283      * {@inheritDoc}
 284      */
 285     public function hasProperty($name)
 286     {
 287         throw new ReflectionException('Method not implemented');
 288     }
 289
 290     /**
 291      * {@inheritDoc}
 292      */
 293     public function implementsInterface($interface)
 294     {
 295         throw new ReflectionException('Method not implemented');
 296     }
 297
 298     /**
 299      * {@inheritDoc}
 300      */
 301     public function inNamespace()
 302     {
 303         throw new ReflectionException('Method not implemented');
 304     }
 305
 306     /**
 307      * {@inheritDoc}
 308      */
 309     public function isAbstract()
 310     {
 311         throw new ReflectionException('Method not implemented');
 312     }
 313
 314     /**
 315      * {@inheritDoc}
 316      */
 317     public function isCloneable()
 318     {
 319         throw new ReflectionException('Method not implemented');
 320     }
 321
 322     /**
 323      * {@inheritDoc}
 324      */
 325     public function isFinal()
 326     {
 327         throw new ReflectionException('Method not implemented');
 328     }
 329
 330     /**
 331      * {@inheritDoc}
 332      */
 333     public function isInstance($object)
 334     {
 335         throw new ReflectionException('Method not implemented');
 336     }
 337
 338     /**
 339      * {@inheritDoc}
 340      */
 341     public function isInstantiable()
 342     {
 343         throw new ReflectionException('Method not implemented');
 344     }
 345
 346     /**
 347      * {@inheritDoc}
 348      */
 349     public function isInterface()
 350     {
 351         throw new ReflectionException('Method not implemented');
 352     }
 353
 354     /**
 355      * {@inheritDoc}
 356      */
 357     public function isInternal()
 358     {
 359         throw new ReflectionException('Method not implemented');
 360     }
 361
 362     /**
 363      * {@inheritDoc}
 364      */
 365     public function isIterateable()
 366     {
 367         throw new ReflectionException('Method not implemented');
 368     }
 369
 370     /**
 371      * {@inheritDoc}
 372      */
 373     public function isSubclassOf($class)
 374     {
 375         throw new ReflectionException('Method not implemented');
 376     }
 377
 378     /**
 379      * {@inheritDoc}
 380      */
 381     public function isTrait()
 382     {
 383         throw new ReflectionException('Method not implemented');
 384     }
 385
 386     /**
 387      * {@inheritDoc}
 388      */
 389     public function isUserDefined()
 390     {
 391         throw new ReflectionException('Method not implemented');
 392     }
 393
 394     /**
 395      * {@inheritDoc}
 396      */
 397     public function newInstance($args)
 398     {
 399         throw new ReflectionException('Method not implemented');
 400     }
 401
 402     /**
 403      * {@inheritDoc}
 404      */
 405     public function newInstanceArgs(array $args = [])
 406     {
 407         throw new ReflectionException('Method not implemented');
 408     }
 409
 410     /**
 411      * {@inheritDoc}
 412      */
 413     public function newInstanceWithoutConstructor()
 414     {
 415         throw new ReflectionException('Method not implemented');
 416     }
 417
 418     /**
 419      * {@inheritDoc}
 420      */
 421     public function setStaticPropertyValue($name, $value)
 422     {
 423         throw new ReflectionException('Method not implemented');
 424     }
 425
 426     /**
 427      * {@inheritDoc}
 428      */
 429     public function __toString()
 430     {
 431         throw new ReflectionException('Method not implemented');
 432     }
 433 }