Gets the reflection class for this object type.

@return ReflectionClass
974489
public function getReflectionClass()
    {
        if ($this->reflectionClass === null)
        {
            $this->reflectionClass = new ReflectionClass($this->getName());
        }
        return $this->reflectionClass;
    }
391837
private function get_class($mixed=null)
	{
		if (is_object($mixed))
			return get_class($mixed);

		if (!is_null($mixed))
			return $mixed;

		return $this->get_called_class();
	}
1076642
private function getUserEntityClass()
    {
        /** @var ClassMetadata $meta */
        foreach ($this->getDoctrine()->getManager()->getMetadataFactory()->getAllMetadata() as $meta) {
            $reflectionClass = $meta->getReflectionClass();

            if (true === $this->hasAbstractParent($reflectionClass, User::class)) {
                return $meta->getName();
            }
        }

        return null;
    }
1232083
public function getNamespace()
    {
        if (null === $this->reflected) {
            $this->reflected = new \ReflectionObject($this);
        }

        return $this->reflected->getNamespaceName();
    }
852730
public static function getInstance()
    {
        $sClass = get_called_class();

        if (!isset(self::$_aInstances[$sClass])) {
            self::$_aInstances[$sClass] = new $sClass();
        }

        return self::$_aInstances[$sClass];
    }
1324746
public function getName()
    {
        if (!$this->name) {
            if ($this->config['name']) {
                return $this->name = $this->config['name'];
            }

            $ref = new \ReflectionClass(static::class);

            $name = substr($ref->getShortName(), 0, -10);

            return $this->name = strtolower($name);
        }

        return $this->name;
    }
760448
public function getClass()
    {
        try {
            $class = parent::getClass();
        } catch (\Exception $exception) {
            return null;
        }

        return is_object($class) ? new ClassReflection($class->getName()) : null;
    }
793180
protected static function getInstance()
    {
        $class = get_called_class();

        if (!isset(self::$instance[$class]) || !self::$instance[$class] instanceof $class) {
            self::$instance[$class] = new static();
        }

        return static::$instance[$class];
    }
695899
public function reflection_file()
	{	
		if ( is_null( $this->reflection_file ) )
		{
			if ( is_null( $reflection = $this->reflection() ) )
			{
				return null;
			}
			
			$this->reflection_file = file( $reflection->getFileName() );
		}
		
		return $this->reflection_file;
	}
463168
public function getMorphClass()
	{
		$morphMap = Relation::morphMap();

		$class = static::class;

		if ( !empty( $morphMap ) && in_array( $class, $morphMap ) )
		{
			return array_search( $class, $morphMap, true );
		}

		return $this->morphClass ?: $class;
	}
91800
public function getReflection()
	{
		if($this->reflection === NULL)
		{
			if(is_array($this->callback))
			{
				$this->reflection = (new \ReflectionClass($this->callback[0]))->getMethod($this->callback[1]);
			}
			elseif(is_object($this->callback) && !$this->callback instanceof \Closure)
			{
				$this->reflection = (new \ReflectionClass($this->callback))->getMethod('__invoke');
			}
			else
			{
				$this->reflection = new \ReflectionFunction($this->callback);
			}
		}
		
		return $this->reflection;
	}
336602
public function getRegisteredObject()
    {
        if($this->registeredObject == null)
        {
            $di = jaxon()->di();
            // Use the Reflection class to get the parameters of the constructor
            if(($constructor = $this->reflectionClass->getConstructor()) != null)
            {
                $parameters = $constructor->getParameters();
                $parameterInstances = [];
                foreach($parameters as $parameter)
                {
                    // Get the parameter instance from the DI
                    $parameterInstances[] = $di->get($parameter->getClass()->getName());
                }
                $this->registeredObject = $this->reflectionClass->newInstanceArgs($parameterInstances);
            }
            else
            {
                $this->registeredObject = $this->reflectionClass->newInstance();
            }
        }
        return $this->registeredObject;
    }
1140838
public function getParameters()
    {
        $function = array($this->getDeclaringClass()->getName(), $this->getName());
        $res = parent::getParameters();

        foreach ($res as $key => $val) {
            $res[$key] = new ReflectionParameter($function, $val->getName());
        }

        return $res;
    }
1442
public function getName()
    {
        if ($this->_name === null) {
            $this->_name = ((new \ReflectionClass($this))->getShortName());
        }
        
        return $this->_name;
    }
1270593
private function getType()
    {
        if ($class = $this->reflection->getClass()) {
            return $class->name;
        }
        if ($this->reflection->isArray()) {
            return 'array';
        }
        if (version_compare(phpversion(), '7.0', '>=')
            and $type = $this->reflection->getType()
        ) {
            return $type;
        }
        return '';
    }
771879
public function getReflectionClass()
    {
        if (!$this->refClass) {
            $this->refClass = new \ReflectionClass($this->getName());
        }

        return $this->refClass;
    }
373266
public function getModelClass()
    {
        if (isset($this->parent)) {
            return $this->parent->getModelClass();
        }

        if (isset($this->getCollection()->first)) {
            return $this->getCollection()->first->class;
        }

        return get_class($this->getCollection()->getModel());
    }