StaticReflectionMethod::isDestructor() - Code Metrics - doctrine/reflection - Measure and Improve Code Quality continuously with Scrutinizer

StaticReflectionMethod::isDestructor() A
last analyzed 2020-05-28 16:17 UTC

↳ Parent: StaticReflectionMethod

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
rs	10
ccs	2
cts	2
cp	1
crap	1

<?php

namespace Doctrine\Common\Reflection;

use ReflectionException;
use ReflectionMethod;

class StaticReflectionMethod extends ReflectionMethod
{
    /**
     * The PSR-0 parser object.
     *
     * @var StaticReflectionParser
     */
    protected $staticReflectionParser;

    /**
     * The name of the method.
     *
     * @var string
     */
    protected $methodName;

    /**
     * @param string $methodName
     */
    public function __construct(StaticReflectionParser $staticReflectionParser, $methodName)
    {
        $this->staticReflectionParser = $staticReflectionParser;
        $this->methodName             = $methodName;
    }

    /**
     * {@inheritDoc}
     */
    public function getName()
    {
        return $this->methodName;
    }

    /**
     * @return StaticReflectionParser
     */
    protected function getStaticReflectionParser()
    {
        return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName);
    }

    /**
     * {@inheritDoc}
     */
    public function getDeclaringClass()
    {
        return $this->getStaticReflectionParser()->getReflectionClass();
    }

    /**
     * {@inheritDoc}
     */
    public function getNamespaceName()
    {
        return $this->getStaticReflectionParser()->getNamespaceName();
    }

    /**
     * {@inheritDoc}
     */
    public function getDocComment()
    {
        return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName);
    }

    /**
     * @return string[]
     */
    public function getUseStatements()
    {
        return $this->getStaticReflectionParser()->getUseStatements();
    }

    /**
     * {@inheritDoc}
     */
    public static function export($class, $name, $return = false)
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getClosure($object = null)
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getModifiers()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getPrototype()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function invoke($object, $parameter = null)
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function invokeArgs($object, array $args)
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isAbstract()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isConstructor()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isDestructor()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isFinal()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isPrivate()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isProtected()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isPublic()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isStatic()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function setAccessible($accessible)
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function __toString()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getClosureThis()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getEndLine()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getExtension()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getExtensionName()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getFileName()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getNumberOfParameters()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getNumberOfRequiredParameters()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getParameters()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getShortName()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getStartLine()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getStaticVariables()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function inNamespace()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isClosure()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isDeprecated()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isInternal()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function isUserDefined()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function returnsReference()
    {
        throw new ReflectionException('Method not implemented');
    }
}


1		<?php
2
3		namespace Doctrine\Common\Reflection;
4
5		use ReflectionException;
6		use ReflectionMethod;
7
8		class StaticReflectionMethod extends ReflectionMethod
9		{
10		/**
11		* The PSR-0 parser object.
12		*
13		* @var StaticReflectionParser
14		*/
15		protected $staticReflectionParser;
16
17		/**
18		* The name of the method.
19		*
20		* @var string
21		*/
22		protected $methodName;
23
24		/**
25		* @param string $methodName
26		*/
27	38	public function __construct(StaticReflectionParser $staticReflectionParser, $methodName)
28		{
29	38	$this->staticReflectionParser = $staticReflectionParser;
30	38	$this->methodName = $methodName;
31	38	}
32
33		/**
34		* {@inheritDoc}
35		*/
36	1	public function getName()
37		{
38	1	return $this->methodName;
39		}
40
41		/**
42		* @return StaticReflectionParser
43		*/
44	4	protected function getStaticReflectionParser()
45		{
46	4	return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName);
47		}
48
49		/**
50		* {@inheritDoc}
51		*/
52	1	public function getDeclaringClass()
53		{
54	1	return $this->getStaticReflectionParser()->getReflectionClass();
55		}
56
57		/**
58		* {@inheritDoc}
59		*/
60	1	public function getNamespaceName()
61		{
62	1	return $this->getStaticReflectionParser()->getNamespaceName();
63		}
64
65		/**
66		* {@inheritDoc}
67		*/
68	1	public function getDocComment()
69		{
70	1	return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName);
71		}
72
73		/**
74		* @return string[]
75		*/
76	1	public function getUseStatements()
77		{
78	1	return $this->getStaticReflectionParser()->getUseStatements();
79		}
80
81		/**
82		* {@inheritDoc}
83		*/
84	1	public static function export($class, $name, $return = false)
85		{
86	1	throw new ReflectionException('Method not implemented');
87		}
88
89		/**
90		* {@inheritDoc}
91		*/
92	1	public function getClosure($object = null)
93		{
94	1	throw new ReflectionException('Method not implemented');
95		}
96
97		/**
98		* {@inheritDoc}
99		*/
100	1	public function getModifiers()
101		{
102	1	throw new ReflectionException('Method not implemented');
103		}
104
105		/**
106		* {@inheritDoc}
107		*/
108	1	public function getPrototype()
109		{
110	1	throw new ReflectionException('Method not implemented');
111		}
112
113		/**
114		* {@inheritDoc}
115		*/
116	1	public function invoke($object, $parameter = null)
117		{
118	1	throw new ReflectionException('Method not implemented');
119		}
120
121		/**
122		* {@inheritDoc}
123		*/
124	1	public function invokeArgs($object, array $args)
125		{
126	1	throw new ReflectionException('Method not implemented');
127		}
128
129		/**
130		* {@inheritDoc}
131		*/
132	1	public function isAbstract()
133		{
134	1	throw new ReflectionException('Method not implemented');
135		}
136
137		/**
138		* {@inheritDoc}
139		*/
140	1	public function isConstructor()
141		{
142	1	throw new ReflectionException('Method not implemented');
143		}
144
145		/**
146		* {@inheritDoc}
147		*/
148	1	public function isDestructor()
149		{
150	1	throw new ReflectionException('Method not implemented');
151		}
152
153		/**
154		* {@inheritDoc}
155		*/
156	1	public function isFinal()
157		{
158	1	throw new ReflectionException('Method not implemented');
159		}
160
161		/**
162		* {@inheritDoc}
163		*/
164	1	public function isPrivate()
165		{
166	1	throw new ReflectionException('Method not implemented');
167		}
168
169		/**
170		* {@inheritDoc}
171		*/
172	1	public function isProtected()
173		{
174	1	throw new ReflectionException('Method not implemented');
175		}
176
177		/**
178		* {@inheritDoc}
179		*/
180	1	public function isPublic()
181		{
182	1	throw new ReflectionException('Method not implemented');
183		}
184
185		/**
186		* {@inheritDoc}
187		*/
188	1	public function isStatic()
189		{
190	1	throw new ReflectionException('Method not implemented');
191		}
192
193		/**
194		* {@inheritDoc}
195		*/
196	1	public function setAccessible($accessible)
197		{
198	1	throw new ReflectionException('Method not implemented');
199		}
200
201		/**
202		* {@inheritDoc}
203		*/
204	1	public function __toString()
205		{
206	1	throw new ReflectionException('Method not implemented');
207		}
208
209		/**
210		* {@inheritDoc}
211		*/
212	1	public function getClosureThis()
213		{
214	1	throw new ReflectionException('Method not implemented');
215		}
216
217		/**
218		* {@inheritDoc}
219		*/
220	1	public function getEndLine()
221		{
222	1	throw new ReflectionException('Method not implemented');
223		}
224
225		/**
226		* {@inheritDoc}
227		*/
228	1	public function getExtension()
229		{
230	1	throw new ReflectionException('Method not implemented');
231		}
232
233		/**
234		* {@inheritDoc}
235		*/
236	1	public function getExtensionName()
237		{
238	1	throw new ReflectionException('Method not implemented');
239		}
240
241		/**
242		* {@inheritDoc}
243		*/
244	1	public function getFileName()
245		{
246	1	throw new ReflectionException('Method not implemented');
247		}
248
249		/**
250		* {@inheritDoc}
251		*/
252	1	public function getNumberOfParameters()
253		{
254	1	throw new ReflectionException('Method not implemented');
255		}
256
257		/**
258		* {@inheritDoc}
259		*/
260	1	public function getNumberOfRequiredParameters()
261		{
262	1	throw new ReflectionException('Method not implemented');
263		}
264
265		/**
266		* {@inheritDoc}
267		*/
268	1	public function getParameters()
269		{
270	1	throw new ReflectionException('Method not implemented');
271		}
272
273		/**
274		* {@inheritDoc}
275		*/
276	1	public function getShortName()
277		{
278	1	throw new ReflectionException('Method not implemented');
279		}
280
281		/**
282		* {@inheritDoc}
283		*/
284	1	public function getStartLine()
285		{
286	1	throw new ReflectionException('Method not implemented');
287		}
288
289		/**
290		* {@inheritDoc}
291		*/
292	1	public function getStaticVariables()
293		{
294	1	throw new ReflectionException('Method not implemented');
295		}
296
297		/**
298		* {@inheritDoc}
299		*/
300	1	public function inNamespace()
301		{
302	1	throw new ReflectionException('Method not implemented');
303		}
304
305		/**
306		* {@inheritDoc}
307		*/
308	1	public function isClosure()
309		{
310	1	throw new ReflectionException('Method not implemented');
311		}
312
313		/**
314		* {@inheritDoc}
315		*/
316	1	public function isDeprecated()
317		{
318	1	throw new ReflectionException('Method not implemented');
319		}
320
321		/**
322		* {@inheritDoc}
323		*/
324	1	public function isInternal()
325		{
326	1	throw new ReflectionException('Method not implemented');
327		}
328
329		/**
330		* {@inheritDoc}
331		*/
332	1	public function isUserDefined()
333		{
334	1	throw new ReflectionException('Method not implemented');
335		}
336
337		/**
338		* {@inheritDoc}
339		*/
340	1	public function returnsReference()
341		{
342	1	throw new ReflectionException('Method not implemented');
343		}
344		}
345

doctrine / reflection

StaticReflectionMethod::isDestructor() A last analyzed 2020-05-28 16:17 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

StaticReflectionMethod::isDestructor() A
last analyzed 2020-05-28 16:17 UTC