Returns the parameter class

@return ClassReflection The parameter class
322668
public function getClass()
    {
        try {
            $class = parent::getClass();
        } catch (\Exception $e) {
            return null;
        }
        return is_object($class) ? new ClassReflection($class->getName()) : null;
    }
1180844
protected function getReflectionClass($className) {
		if (isset($this->reflectionClasses[$className])) {
			return $this->reflectionClasses[$className];
		}

		try {
			$reflectionClass = new ReflectionClass($className);
		} catch (ReflectionException $e) {
			throw new NotFoundException("Class $className is not found");
		}

		if (!$reflectionClass->isInstantiable()) {
			throw new NotInstantiableException("$className is not an instantiable class");
		}

		$this->reflectionClasses[$className] = $reflectionClass;

		return $reflectionClass;
	}
1084688
public function getParentClass()
    {
        $parentClass  = parent::getParentClass();
        if (null === $parentClass || false === $parentClass) {
            return null;
        }
        
        $moufRefClass = new self($parentClass->getName());
        return $moufRefClass;
    }
1123337
protected function getModelReflection()
    {
        $modelClassName = str_replace('/', '\\', $this->input->getArgument('model'));

        try {
            $reflection = new ReflectionClass($this->getAppNamespace() . $modelClassName);
        } catch (\ReflectionException $e) {
            $reflection = new ReflectionClass($modelClassName);
        }

        if (!$reflection->isSubclassOf(Model::class) || !$reflection->isInstantiable()) {
            throw new NotAnInstanceOfException(sprintf('The model must be an instance of [%s]', Model::class));
        }

        return $reflection;
    }
61477
protected function getClassParameter()
    {
        if (! $this->hasRequestParameter(self::CLASS_PARAMETER)) {
            throw new \common_exception_MissingParameter(self::CLASS_PARAMETER, __CLASS__);
        }

        $uri = $this->getRequestParameter(self::CLASS_PARAMETER);
        if (empty($uri) || !common_Utils::isUri($uri)) {
            throw new \common_exception_MissingParameter(self::CLASS_PARAMETER, __CLASS__);
        }

        return $this->getClass($uri);
    }
743807
protected function getReflectionMethod($class, $method)
    {
        if (!isset($this->methodReflectors[$class])) {
            $this->methodReflectors[$class] = [];
        }
        if (!isset($this->methodReflectors[$class][$method])) {
            $this->methodReflectors[$class][$method] = new \ReflectionMethod($class, $method);
        }

        return $this->methodReflectors[$class][$method];
    }
415983
private function getReflection(string $className) : \ReflectionClass
    {
        if (empty($this->reflectionContainer[$className])) {
            $this->reflectionContainer[$className] = new \ReflectionClass($className);
        }

        return $this->reflectionContainer[$className];
    }
389231
private function ClassFile()
    {
        if (!$this->classFile)
        {
            
            $class = new \ReflectionClass($this);
            $this->classFile = $class->getFileName();
        }
        return $this->classFile;
    }
226587
public static function getReflection(IMapper $mapper = null)
    {
        $class = get_called_class();
        $mapperClass = $mapper !== null ? get_class($mapper) : '';
        if (!isset(static::$reflections[$class][$mapperClass])) {
            static::$reflections[$class][$mapperClass] = new EntityReflection($class, $mapper, static::getReflectionProvider());
        }
        return static::$reflections[$class][$mapperClass];
    }
1169877
protected static function getReflection($object)
    {
        $reflectionClass = get_class($object);

        if (!isset(self::$reflections[$reflectionClass])) {
            self::$reflections[$reflectionClass]
                = new \ReflectionClass($object);
        }

        return self::$reflections[$reflectionClass];
    }
1108186
public function getParameters()
    {
        $parameters     = parent::getParameters();
        $moufParameters = array();
        foreach ($parameters as $parameter) {
            $moufParameters[] = new MoufReflectionParameter($this, $parameter->getName(), $this->refClass);
        }
        
        return $moufParameters;
    }
1287443
protected function _getReflection()
    {
        if (is_null($this->_reflection)) {
            $this->_reflection = new \ReflectionClass($this->_class);
        }
        return $this->_reflection;
    }
1113262
protected function getInstance(ReflectionClass $parameterClass)
    {
        if (!class_exists($parameterClass->name, true)) {
            return null;
        }
        
        if (strpos($parameterClass->name, 'Zepi\\Turbo\\') === 0) {
            return $this->getFrameworkInstance($parameterClass);
        }
        
        if ($parameterClass->isInstantiable()) {
            return $this->framework->getInstance($parameterClass->name);
        }
    }
651771
public function getDeclaringFunction()
    {
        if (null === $this->refRoutine) {
            if (is_array($this->routineName) === true) {
                $this->refRoutine = new MoufReflectionMethod($this->routineName[0], $this->routineName[1]);
            }
        }
        
        return $this->refRoutine;
    }
57068
private function getReflectionClass($className) : ReflectionClass
    {
        if (! class_exists($className)) {
            throw InvalidArgumentException::fromNonExistingClass($className);
        }

        $reflection = new ReflectionClass($className);

        if ($reflection->isAbstract()) {
            throw InvalidArgumentException::fromAbstractClass($reflection);
        }

        return $reflection;
    }
167733
public function getParameterClass(ReflectionParameter $parameter)
    {
        // Use reflection
        $parameterClass = $parameter->getClass();
        if ($parameterClass !== null) {
            return $parameterClass->name;
        }

        $parameterName = $parameter->name;
        // Get the content of the @param annotation
        $method = $parameter->getDeclaringFunction();
        if (preg_match('/@param\s+([^\s]+)\s+\$' . $parameterName . '/', $method->getDocComment(), $matches)) {
            list(, $type) = $matches;
        } else {
            return null;
        }

        // Ignore primitive types
        if (in_array($type, $this->ignoredTypes)) {
            return null;
        }

        // Ignore types containing special characters ([], <> ...)
        if (! preg_match('/^[a-zA-Z0-9\\\\_]+$/', $type)) {
            return null;
        }

        $class = $parameter->getDeclaringClass();

        // If the class name is not fully qualified (i.e. doesn't start with a \)
        if ($type[0] !== '\\') {
            // Try to resolve the FQN using the class context
            $resolvedType = $this->tryResolveFqn($type, $class, $parameter);
         
            if (!$resolvedType && !$this->ignorePhpDocErrors) {
                throw new AnnotationException(sprintf(
                    'The @param annotation for parameter "%s" of %s::%s contains a non existent class "%s". '
                        . 'Did you maybe forget to add a "use" statement for this annotation?',
                    $parameterName,
                    $class->name,
                    $method->name,
                    $type
                ));
            }
            
            $type = $resolvedType;
        }

        if (!$this->classExists($type) && !$this->ignorePhpDocErrors) {
            throw new AnnotationException(sprintf(
                'The @param annotation for parameter "%s" of %s::%s contains a non existent class "%s"',
                $parameterName,
                $class->name,
                $method->name,
                $type
            ));
        }

        // Remove the leading \ (FQN shouldn't contain it)
        $type = ltrim($type, '\\');

        return $type;
    }
470162
@Benchmark
	@BenchmarkMode(Mode.Throughput)
	@SuppressWarnings("removal")
	public Class<?> sunReflection() {
		return sun.reflect.Reflection.getCallerClass(1);
	}