StaticReflectionClass::isInternal() - Code Metrics - Inspection of "Merge pull request #6 from doctrine/test-coverage" - doctrine/reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fb964a...b7229e )

by Jonathan

created 2018-06-13 23:16 UTC

StaticReflectionClass::isInternal() A

↳ Parent: StaticReflectionClass

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

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

<?php

namespace Doctrine\Common\Reflection;

use ReflectionClass;
use ReflectionException;

class StaticReflectionClass extends ReflectionClass
{
    /**
     * The static reflection parser object.
     *
     * @var StaticReflectionParser
     */
    private $staticReflectionParser;

    public function __construct(StaticReflectionParser $staticReflectionParser)
    {
        $this->staticReflectionParser = $staticReflectionParser;
    }

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

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

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

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

    /**
     * {@inheritDoc}
     */
    public function getMethod($name)
    {
        return $this->staticReflectionParser->getReflectionMethod($name);
    }

    /**
     * {@inheritDoc}
     */
    public function getProperty($name)
    {
        return $this->staticReflectionParser->getReflectionProperty($name);
    }

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

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

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

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

    /**
     * {@inheritDoc}
     */
    public function getDefaultProperties()
    {
        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 getInterfaceNames()
    {
        throw new ReflectionException('Method not implemented');
    }

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

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

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

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

    /**
     * {@inheritDoc}
     */
    public function getProperties($filter = null)
    {
        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 getStaticProperties()
    {
        throw new ReflectionException('Method not implemented');
    }

    /**
     * {@inheritDoc}
     */
    public function getStaticPropertyValue($name, $default = '')
    {
        throw new ReflectionException('Method not implemented');
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritDoc}
     */
    public function newInstanceArgs(array $args = [])
    {
        throw new ReflectionException('Method not implemented');
    }

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

    /**
     * {@inheritDoc}
     */
    public function setStaticPropertyValue($name, $value)
    {
        throw new ReflectionException('Method not implemented');
    }

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


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

doctrine / reflection

Push — master ( fb964a...b7229e )

StaticReflectionClass::isInternal() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like