Returns the parameter class

@return ClassReflection The parameter class
760448
public function getClass()
    {
        try {
            $class = parent::getClass();
        } catch (\Exception $exception) {
            return null;
        }

        return is_object($class) ? new ClassReflection($class->getName()) : null;
    }
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);
        }
    }
771879
public function getReflectionClass()
    {
        if (!$this->refClass) {
            $this->refClass = new \ReflectionClass($this->getName());
        }

        return $this->refClass;
    }
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];
    }
674952
public function getInflector()
    {
        if (!isset($this->inflector)) {
            $this->inflector = new ClassNameInflector($this->getNamespace());
        }

        return $this->inflector;
    }
188236
protected static function getReflectionClassWithProperty($class, $propertyName)
    {
        Assert::string($class, 'First argument to Reflection::getReflectionClassWithProperty must be string. Variable of type "%s" was given.');
        Assert::classExists($class, 'Could not find class "%s"');

        $refl = new \ReflectionClass($class);
        if ($refl->hasProperty($propertyName)) {
            return $refl;
        }

        if (false === $parent = get_parent_class($class)) {
            // No more parents
            return;
        }

        return self::getReflectionClassWithProperty($parent, $propertyName);
    }
389231
private function ClassFile()
    {
        if (!$this->classFile)
        {
            
            $class = new \ReflectionClass($this);
            $this->classFile = $class->getFileName();
        }
        return $this->classFile;
    }
232736
public function getDeclaringClass()
    {
        if (is_array($this->routineName) === false) {
            return null;
        }
        
        $refClass     = parent::getDeclaringClass();
        $moufRefClass = new MoufReflectionClass($refClass->getName());
        return $moufRefClass;
    }
1171331
final protected function getModularReflection() : ReflectionClass
    {
        if (! $this->privateModularReflectionClass instanceof ReflectionClass) {
            $this->privateModularReflectionClass = new ReflectionClass($this);
        }

        return $this->privateModularReflectionClass;
    }
666155
public function getReflectionClass()
    {
        if ( ! $this->reflClass) {
            $this->reflClass = new \ReflectionClass($this->name);
        }
        return $this->reflClass;
    }
1002371
protected static function getReflection($callable)
    {

        if (is_array($callable)) {
            return new ReflectionMethod($callable[0], $callable[1]);
        }

        if ($callable instanceof \Closure) {
            return new ReflectionFunction($callable);
        }

        if (is_object($callable)) {
            return new ReflectionMethod($callable, '__invoke');
        }

        // Should be a string until here
        if (strpos($callable, '::')) {
            list($class, $method) = explode('::', $callable);
            return new ReflectionMethod($class, $method);
        }

        return new ReflectionFunction($callable);
    }
424044
public function getReflectionParam($dependency)
    {
        $resolveClass = null;
        //Get constructor class name
        $resolveClass = $dependency->getClass()->name;

        return [$resolveClass, new \ReflectionClass($resolveClass)];
    }
542276
private function getEntityClass()
    {
        /** @var ClassMetadata $metaData */
        foreach ($this->getDoctrineManager()->getMetadataFactory()->getAllMetadata() as $metaData) {
            if ($metaData->getName() === Config::class) {
                continue;
            }

            $reflectionClass = new \ReflectionClass($metaData->getName());
            if (true === in_array(Config::class, $this->getParentClassNames($reflectionClass))) {
                return $metaData->getName();
            }
        }

        throw new \RuntimeException('Missing config entity!');
    }
542890
public function getParentClass()
    {
        $parentClass = $this->getBehaviorContent('parentClass');
        return null === $parentClass ? ($this->getTable()->getBaseQueryClass() != "" ? $this->getTable()->getBaseQueryClass() : 'ModelCriteria') : $parentClass;
    }
396839
public function getDeclaringClass()
    {
        $parent = $this->class;

        // Since we don't have real reflection constants, we can't see where
        // it's actually defined. Let's check for a constant that is also
        // available on the parent class which has exactly the same value.
        //
        // While this isn't _technically_ correct, it's prolly close enough.
        do {
            $class  = $parent;
            $parent = $class->getParentClass();
        } while ($parent && $parent->hasConstant($this->name) && $parent->getConstant($this->name) === $this->value);

        return $class;
    }
370915
public function getClass()
    {
        if ($this->class === null) {
            $this->setClass($this->groupClassRepository->getByParameter($this));
        }
        return $this->class;
    }
760744
public function class()
    {
        /** @var \Yajra\CMS\Repositories\Extension\Repository $repository */
        $repository = app('extensions');
        $extension  = $repository->findOrFail($this->entity->extension_id);

        return $extension->param('class');
    }