Mirror::getMethodsFromReflection() - Code Metrics - Inspection of "Daily Inspection: Use getType() in place of getCla..." - eventespresso/event-espresso-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (8a6854)

unknown

created 2021-06-17 21:35 UTC

Mirror::getMethodsFromReflection() A

↳ Parent: Mirror

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace EventEspresso\core\services\container;

use EventEspresso\core\exceptions\InvalidDataTypeException;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use ReflectionParameter;
use ReflectionProperty;

/**
 * Class Mirror
 * Utility class for obtaining details about classes using PHP Reflection.
 * To prevent extra processing, all generated reflectors are cached for reuse.
 *
 * @package EventEspresso\core\services\container
 * @author  Brent Christensen
 * @since   4.9.62.p
 */
class Mirror
{

    /**
     * @var ReflectionClass[] $classes
     */
    private $classes = array();

    /**
     * @var ReflectionMethod[] $constructors
     */
    private $constructors = array();

    /**
     * @var ReflectionParameter[][] $parameters
     */
    private $parameters = array();

    /**
     * @var ReflectionParameter[][] $parameters
     */
    private $parameter_classes = array();

    /**
     * @var ReflectionProperty[][] $properties
     */
    private $properties = array();

    /**
     * @var ReflectionMethod[][] $methods
     */
    private $methods = array();


    /**
     * @param string $class_name
     * @return ReflectionClass
     * @throws ReflectionException
     * @throws InvalidDataTypeException
     */
    public function getReflectionClass($class_name)
    {
        if (! is_string($class_name)) {
            throw new InvalidDataTypeException($class_name, '$class_name', 'string (fully qualified class name)');
        }
        if (! isset($this->classes[ $class_name ])) {
            $this->classes[ $class_name ] = new ReflectionClass($class_name);
        }
        return $this->classes[ $class_name ];
    }


    /**
     * @param string $class_name
     * @return ReflectionMethod
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getConstructor($class_name)
    {
        if (! is_string($class_name)) {
            throw new InvalidDataTypeException($class_name, '$class_name', 'string (fully qualified class name)');
        }
        if (! isset($this->constructors[ $class_name ])) {
            $reflection_class                  = $this->getReflectionClass($class_name);
            $this->constructors[ $class_name ] = $reflection_class->getConstructor();
        }
        return $this->constructors[ $class_name ];
    }


    /**
     * @param ReflectionClass $reflection_class
     * @return ReflectionMethod
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getConstructorFromReflection(ReflectionClass $reflection_class)
    {
        return $this->getConstructor($reflection_class->getName());

    }


    /**
     * @param string $class_name
     * @return ReflectionParameter[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getParameters($class_name)
    {
        if (! isset($this->parameters[ $class_name ])) {
            $constructor                     = $this->getConstructor($class_name);
            $this->parameters[ $class_name ] = $constructor->getParameters();
        }
        return $this->parameters[ $class_name ];
    }


    /**
     * @param ReflectionClass $reflection_class
     * @return ReflectionParameter[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getParametersFromReflection(ReflectionClass $reflection_class)
    {
        return $this->getParameters($reflection_class->getName());

    }


    /**
     * @param ReflectionMethod $constructor
     * @return ReflectionParameter[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getParametersFromReflectionConstructor(ReflectionMethod $constructor)
    {
        return $this->getParameters($constructor->getDeclaringClass());
    }


    /**
     * @param ReflectionParameter $param
     * @param string              $class_name
     * @param string              $index
     * @return string|null
     */
    public function getParameterClassName(ReflectionParameter $param, $class_name, $index)
    {
        if (isset($this->parameter_classes[ $class_name ][ $index ]['param_class_name'])) {
            return $this->parameter_classes[ $class_name ][ $index ]['param_class_name'];
        }
        if (! isset($this->parameter_classes[ $class_name ])) {
            $this->parameter_classes[ $class_name ] = array();
        }
        if (! isset($this->parameter_classes[ $class_name ][ $index ])) {
            $this->parameter_classes[ $class_name ][ $index ] = array();
        }
        // ReflectionParameter::getClass() is deprecated in PHP 8+
        if (PHP_VERSION_ID >= 80000) {
            $this->parameter_classes[ $class_name ][ $index ]['param_class_name'] =
                $param->getType() instanceof ReflectionNamedType
                    ? $param->getType()->getName()
                    : null;
        } else {
            $this->parameter_classes[ $class_name ][ $index ]['param_class_name'] = $param->getClass()
                    ? $param->getClass()->getName()

                    : null;
        }
        return $this->parameter_classes[ $class_name ][ $index ]['param_class_name'];
    }


    /**
     * @param ReflectionParameter $param
     * @param string              $class_name
     * @param string              $index
     * @return string|null
     */
    public function getParameterDefaultValue(ReflectionParameter $param, $class_name, $index)
    {
        if (isset($this->parameter_classes[ $class_name ][ $index ]['param_class_default'])) {
            return $this->parameter_classes[ $class_name ][ $index ]['param_class_default'];
        }
        if (! isset($this->parameter_classes[ $class_name ])) {
            $this->parameter_classes[ $class_name ] = array();
        }
        if (! isset($this->parameter_classes[ $class_name ][ $index ])) {
            $this->parameter_classes[ $class_name ][ $index ] = array();
        }
        $this->parameter_classes[ $class_name ][ $index ]['param_class_default'] = $param->isDefaultValueAvailable()
            ? $param->getDefaultValue()
            : null;
        return $this->parameter_classes[ $class_name ][ $index ]['param_class_default'];
    }


    /**
     * @param string $class_name
     * @return ReflectionProperty[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getProperties($class_name)
    {
        if (! isset($this->properties[ $class_name ])) {
            $reflection_class                = $this->getReflectionClass($class_name);
            $this->properties[ $class_name ] = $reflection_class->getProperties();
        }
        return $this->properties[ $class_name ];
    }


    /**
     * @param ReflectionClass $reflection_class
     * @return ReflectionProperty[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getPropertiesFromReflection(ReflectionClass $reflection_class)
    {
        return $this->getProperties($reflection_class->getName());

    }


    /**
     * @param string $class_name
     * @return ReflectionMethod[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getMethods($class_name)
    {
        if (! isset($this->methods[ $class_name ])) {
            $reflection_class             = $this->getReflectionClass($class_name);
            $this->methods[ $class_name ] = $reflection_class->getMethods();
        }
        return $this->methods[ $class_name ];
    }


    /**
     * @param ReflectionClass $reflection_class )
     * @return ReflectionMethod[]
     * @throws InvalidDataTypeException
     * @throws ReflectionException
     */
    public function getMethodsFromReflection(ReflectionClass $reflection_class)
    {
        return $this->getMethods($reflection_class->getName());

    }
}


1		<?php
2
3		namespace EventEspresso\core\services\container;
4
5		use EventEspresso\core\exceptions\InvalidDataTypeException;
6		use ReflectionClass;
7		use ReflectionException;
8		use ReflectionMethod;
9		use ReflectionParameter;
10		use ReflectionProperty;
11
12		/**
13		* Class Mirror
14		* Utility class for obtaining details about classes using PHP Reflection.
15		* To prevent extra processing, all generated reflectors are cached for reuse.
16		*
17		* @package EventEspresso\core\services\container
18		* @author Brent Christensen
19		* @since 4.9.62.p
20		*/
21		class Mirror
22		{
23
24		/**
25		* @var ReflectionClass[] $classes
26		*/
27		private $classes = array();
28
29		/**
30		* @var ReflectionMethod[] $constructors
31		*/
32		private $constructors = array();
33
34		/**
35		* @var ReflectionParameter[][] $parameters
36		*/
37		private $parameters = array();
38
39		/**
40		* @var ReflectionParameter[][] $parameters
41		*/
42		private $parameter_classes = array();
43
44		/**
45		* @var ReflectionProperty[][] $properties
46		*/
47		private $properties = array();
48
49		/**
50		* @var ReflectionMethod[][] $methods
51		*/
52		private $methods = array();
53
54
55		/**
56		* @param string $class_name
57		* @return ReflectionClass
58		* @throws ReflectionException
59		* @throws InvalidDataTypeException
60		*/
61		public function getReflectionClass($class_name)
62		{
63		if (! is_string($class_name)) {
64		throw new InvalidDataTypeException($class_name, '$class_name', 'string (fully qualified class name)');
65		}
66		if (! isset($this->classes[ $class_name ])) {
67		$this->classes[ $class_name ] = new ReflectionClass($class_name);
68		}
69		return $this->classes[ $class_name ];
70		}
71
72
73		/**
74		* @param string $class_name
75		* @return ReflectionMethod
76		* @throws InvalidDataTypeException
77		* @throws ReflectionException
78		*/
79		public function getConstructor($class_name)
80		{
81		if (! is_string($class_name)) {
82		throw new InvalidDataTypeException($class_name, '$class_name', 'string (fully qualified class name)');
83		}
84		if (! isset($this->constructors[ $class_name ])) {
85		$reflection_class = $this->getReflectionClass($class_name);
86		$this->constructors[ $class_name ] = $reflection_class->getConstructor();
87		}
88		return $this->constructors[ $class_name ];
89		}
90
91
92		/**
93		* @param ReflectionClass $reflection_class
94		* @return ReflectionMethod
95		* @throws InvalidDataTypeException
96		* @throws ReflectionException
97		*/
98		public function getConstructorFromReflection(ReflectionClass $reflection_class)
99		{
100		return $this->getConstructor($reflection_class->getName());
		0 ignored issues – show Bug introduced 2018-05-02 21:23 UTC by Report Bug Copy Issue Report Consider using `$reflection_class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
101		}
102
103
104		/**
105		* @param string $class_name
106		* @return ReflectionParameter[]
107		* @throws InvalidDataTypeException
108		* @throws ReflectionException
109		*/
110		public function getParameters($class_name)
111		{
112		if (! isset($this->parameters[ $class_name ])) {
113		$constructor = $this->getConstructor($class_name);
114		$this->parameters[ $class_name ] = $constructor->getParameters();
115		}
116		return $this->parameters[ $class_name ];
117		}
118
119
120		/**
121		* @param ReflectionClass $reflection_class
122		* @return ReflectionParameter[]
123		* @throws InvalidDataTypeException
124		* @throws ReflectionException
125		*/
126		public function getParametersFromReflection(ReflectionClass $reflection_class)
127		{
128		return $this->getParameters($reflection_class->getName());
		0 ignored issues – show Bug introduced 2018-05-02 21:23 UTC by Report Bug Copy Issue Report Consider using `$reflection_class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
129		}
130
131
132		/**
133		* @param ReflectionMethod $constructor
134		* @return ReflectionParameter[]
135		* @throws InvalidDataTypeException
136		* @throws ReflectionException
137		*/
138		public function getParametersFromReflectionConstructor(ReflectionMethod $constructor)
139		{
140		return $this->getParameters($constructor->getDeclaringClass());
141		}
142
143
144		/**
145		* @param ReflectionParameter $param
146		* @param string $class_name
147		* @param string $index
148		* @return string\|null
149		*/
150		public function getParameterClassName(ReflectionParameter $param, $class_name, $index)
151		{
152	View Code Duplication	if (isset($this->parameter_classes[ $class_name ][ $index ]['param_class_name'])) {
153		return $this->parameter_classes[ $class_name ][ $index ]['param_class_name'];
154		}
155		if (! isset($this->parameter_classes[ $class_name ])) {
156		$this->parameter_classes[ $class_name ] = array();
157		}
158	View Code Duplication	if (! isset($this->parameter_classes[ $class_name ][ $index ])) {
159		$this->parameter_classes[ $class_name ][ $index ] = array();
160		}
161		// ReflectionParameter::getClass() is deprecated in PHP 8+
162		if (PHP_VERSION_ID >= 80000) {
163		$this->parameter_classes[ $class_name ][ $index ]['param_class_name'] =
164		$param->getType() instanceof ReflectionNamedType
165		? $param->getType()->getName()
166		: null;
167		} else {
168		$this->parameter_classes[ $class_name ][ $index ]['param_class_name'] = $param->getClass()
169		? $param->getClass()->getName()
		0 ignored issues – show Bug introduced 2021-06-12 21:50 UTC by Report Bug Copy Issue Report Consider using `$param->getClass()->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
170		: null;
171		}
172		return $this->parameter_classes[ $class_name ][ $index ]['param_class_name'];
173		}
174
175
176		/**
177		* @param ReflectionParameter $param
178		* @param string $class_name
179		* @param string $index
180		* @return string\|null
181		*/
182		public function getParameterDefaultValue(ReflectionParameter $param, $class_name, $index)
183		{
184	View Code Duplication	if (isset($this->parameter_classes[ $class_name ][ $index ]['param_class_default'])) {
185		return $this->parameter_classes[ $class_name ][ $index ]['param_class_default'];
186		}
187		if (! isset($this->parameter_classes[ $class_name ])) {
188		$this->parameter_classes[ $class_name ] = array();
189		}
190	View Code Duplication	if (! isset($this->parameter_classes[ $class_name ][ $index ])) {
191		$this->parameter_classes[ $class_name ][ $index ] = array();
192		}
193		$this->parameter_classes[ $class_name ][ $index ]['param_class_default'] = $param->isDefaultValueAvailable()
194		? $param->getDefaultValue()
195		: null;
196		return $this->parameter_classes[ $class_name ][ $index ]['param_class_default'];
197		}
198
199
200		/**
201		* @param string $class_name
202		* @return ReflectionProperty[]
203		* @throws InvalidDataTypeException
204		* @throws ReflectionException
205		*/
206	View Code Duplication	public function getProperties($class_name)
207		{
208		if (! isset($this->properties[ $class_name ])) {
209		$reflection_class = $this->getReflectionClass($class_name);
210		$this->properties[ $class_name ] = $reflection_class->getProperties();
211		}
212		return $this->properties[ $class_name ];
213		}
214
215
216		/**
217		* @param ReflectionClass $reflection_class
218		* @return ReflectionProperty[]
219		* @throws InvalidDataTypeException
220		* @throws ReflectionException
221		*/
222		public function getPropertiesFromReflection(ReflectionClass $reflection_class)
223		{
224		return $this->getProperties($reflection_class->getName());
		0 ignored issues – show Bug introduced 2018-05-02 21:23 UTC by Report Bug Copy Issue Report Consider using `$reflection_class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
225		}
226
227
228		/**
229		* @param string $class_name
230		* @return ReflectionMethod[]
231		* @throws InvalidDataTypeException
232		* @throws ReflectionException
233		*/
234	View Code Duplication	public function getMethods($class_name)
235		{
236		if (! isset($this->methods[ $class_name ])) {
237		$reflection_class = $this->getReflectionClass($class_name);
238		$this->methods[ $class_name ] = $reflection_class->getMethods();
239		}
240		return $this->methods[ $class_name ];
241		}
242
243
244		/**
245		* @param ReflectionClass $reflection_class )
246		* @return ReflectionMethod[]
247		* @throws InvalidDataTypeException
248		* @throws ReflectionException
249		*/
250		public function getMethodsFromReflection(ReflectionClass $reflection_class)
251		{
252		return $this->getMethods($reflection_class->getName());
		0 ignored issues – show Bug introduced 2018-05-02 21:23 UTC by Report Bug Copy Issue Report Consider using `$reflection_class->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
253		}
254		}
255

eventespresso / event-espresso-core

Branch — master (8a6854)

Mirror::getMethodsFromReflection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like