This method is used get the instanciated version of a class that has been
registered in a module.
@param $className string The class you would like to instanciate
@return object The instanciated object based on the $className
499177
public function get($className) {
        if (!$this->has($className)) {
            $errorMsg = sprintf(self::ERROR_SERVICE_NOT_FOUND, $className);
            throw new ulfberhtException($errorMsg);
        }
        //return service from service cache if it is there
        if (isset($this->_serviceCache[$className])) {
            return $this->_serviceCache[$className];
        }

        return $this->_resolveService($className);
    }
8678
public function getInstance($className)
    {
        switch ($className) {
            case '\\Zepi\\Web\\General\\Manager\\AssetManager':
                if ($this->assetManager === null) {
                    $this->assetManager = new $className(
                        $this->getDataObjectBackend('assets.data'),
                        $this->framework->getRootDirectory()
                    );
                    $this->assetManager->initializeAssetManager();
                }
                
                return $this->assetManager;
            break;
            
            case '\\Zepi\\Web\\General\\Manager\\AssetCacheManager':
                if ($this->assetCacheManager === null) {
                    // Get the cache backends
                    $path = $this->framework->getRootDirectory() . '/cache/';
                    $fileObjectBackend = new \Zepi\Turbo\Backend\FileObjectBackend($path . 'cachedFiles.data');
                    $fileBackend = new \Zepi\Turbo\Backend\FileBackend($path);
            
                    // CSS helper
                    $cssHelper = new \Zepi\Web\General\Helper\CssHelper($fileBackend);
            
                    // Load the configuration
                    $configurationManager = $this->framework->getInstance('\\Zepi\\Core\\Utils\\Manager\\ConfigurationManager');
                    $minifyAssets = $configurationManager->getSetting('assets.minifyAssets');
                    $combineAssetGroups = $configurationManager->getSetting('assets.combineAssetGroups');
            
                    $this->assetCacheManager = new $className(
                        $this->framework,
                        $this->getInstance('\\Zepi\\Web\\General\\Manager\\AssetManager'),
                        $fileObjectBackend,
                        $fileBackend,
                        $cssHelper,
                        $minifyAssets,
                        $combineAssetGroups
                    );
                    $this->assetCacheManager->initializeAssetCacheManager();
                }
            
                return $this->assetCacheManager;
            break;
            
            case '\\Zepi\\Web\\General\\Manager\\TemplatesManager':
                if ($this->templatesManager === null) {
                    $this->templatesManager = new $className(
                        $this->framework, 
                        $this->getDataObjectBackend('templates.data')
                    );
                    $this->templatesManager->initializeTemplatesManager();
                    
                    // Execute the register renderer event
                    $runtimeManager = $this->framework->getRuntimeManager();
                    $runtimeManager->executeEvent('\\Zepi\\Web\\General\\Event\\RegisterRenderers');
                }
                
                return $this->templatesManager;
            break;
            
            case '\\Zepi\\Web\\General\\Manager\\MenuManager':
            case '\\Zepi\\Web\\General\\Manager\\MetaInformationManager':
                return $this->framework->initiateObject($className, array(), true);
            break;
            
            default: 
                return $this->framework->initiateObject($className);
            break;
        }
    }
1187599
public static function instance($className = __CLASS__)
    {
        if (!isset(self::$instances[$className])) {
            self::$instances[$className] = new $className;
        }

        return self::$instances[$className];
    }
95893
public static function getClassAnnotations($className)
    {
        if (!isset(self::$annotationCache[$className])) {
            $class = new \ReflectionClass($className);
            self::$annotationCache[$className] = self::parseAnnotations($class->getDocComment());
        }

        return self::$annotationCache[$className];
    }
140345
public function lookupSingletonSessionBean($className)
    {
        if ($this->getSingletonSessionBeans()->has($className) === true) {
            return $this->getSingletonSessionBeans()->get($className);
        }
    }
675584
public static function getParent($className) {
		$reflection = ClassType::from($className);
		$parent = $reflection->getParentClass();
		return $parent ? $parent->getName() : $parent;
	}
511190
public static function getUserClassName($className)
    {
        if (null === self::$inflector) {
            static::$inflector = new ProxyManagerClassNameInflector('');
        }

        return static::$inflector->getUserClassName($className);
    }
242337
protected function getFrameworkManager($className)
    {
        switch ($className) {
            case 'Zepi\\Turbo\\Manager\\DataSourceManager':
                return $this->framework->getDataSourceManager();
            break;
            
            case 'Zepi\\Turbo\\Manager\\DependencyInjectionManager':
                return $this->framework->getDependencyInjectionManager();
            break;
                
            case 'Zepi\\Turbo\\Manager\\ModuleManager':
                return $this->framework->getModuleManager();
            break;
                
            case 'Zepi\\Turbo\\Manager\\RequestManager':
                return $this->framework->getRequestManager();
            break;
                
            case 'Zepi\\Turbo\\Manager\\RouteManager':
                return $this->framework->getRouteManager();
            break;
            
            case 'Zepi\\Turbo\\Manager\\RuntimeManager':
                return $this->framework->getRuntimeManager();
            break;
            
            default:
                throw new Exception('Cannot find framework manager "' . $className . '".');
            break;
        }
    }
162990
protected function getCompatibleClass( $className )
  {
    if( ! $className || ! is_string( $className )){
      $className = get_class( $this );
    }
    $class = $className;

    if( ! $this->checkClassForCompability( $class )){
      $class = $this->checkClassForCompability( $class .'Exception' );
    }

    if( ! $class ) {
      if( $parent = get_parent_class( $className ) ) {
        $class = $this->getCompatibleClass( $parent );
      } else {
        $class = __NAMESPACE__ .'\DeferredExceptionsException';
      }
    }

    return $class;
  }
1275663
public function getTagByClassName($className)
    {
        if (is_object($className)) $className = get_class($className);
        if (isset($this->known[$className]['tagName'])) {
            return $this->known[$className]['tagName'];
        } else {
            return null;
        }
    }
795976
protected static function getClassProperties($className)
    {
        if (\class_exists($className, true)) {
            $reflection = new ReflectionClass($className);
            $value = $reflection->newInstanceWithoutConstructor();

            if (\is_subclass_of($value, Model::class, true)) {
                $attributes = Schema::getColumnListing($value->getTable());

                self::$eloquentClasses[$className] = $attributes;
            }
        }

        return (!empty(self::$eloquentClasses[$className])) ? self::$eloquentClasses[$className] : parent::getClassProperties($className);
    }
1371822
public function getInstance($className)
    {
        switch ($className) {
            case '\\Zepi\\Api\\AccessControl\\Manager\\TokenManager':
                if ($this->tokenManager === null) {
                    $this->tokenManager = $this->framework->initiateObject($className);
                }
                
                return $this->tokenManager;
            break;
            
            default: 
                return $this->framework->initiateObject($className);
            break;
        }
    }
655931
public final function get($className)
   {
       try {
           return $this->cache->get(... func_get_args());
       } catch (NotFoundException $e) {
           try {
               $service = $this->resolver->resolve($className, $this->cache);
           } catch (NotFoundException $e) {
               throw $e;
           } catch (ContainerException $e) {
               throw $e;
           }
       }
       $this->cache->set($className, $service);
       return $this->cache->get($className);
   }
1234532
private static function getInstance(string $className): string
    {
        $collector = EntityCollector::getCollector();
        if (!isset($collector[$className]['instance'])) {
            return Pool::INSTANCE;
        }

        return $collector[$className]['instance'];
    }
150919
protected function getRealClass($className)
    {
        if (Version::compare('2.2.0') <= 0) {
            return ClassUtils::getRealClass($className);
        }

        if (substr($className, -5) === 'Proxy') {
            return substr($className, 0, -5);
        }

        return $className;
    }
113136
public function getMetadataFor($className)
    {
        if (isset($this->transformMetadata[$className])) {
            return $this->transformMetadata[$className];
        }

        $class = $this->wrapped->getMetadataFor($className);

        if (in_array($className, $this->classNames)) {
            $class = $this->transformMetadata($class);
            $this->transformMetadata[$className] = $class;
        }

        return $class;
    }
23536
protected function getRegisteredObject($sClassName)
    {
        // Get the corresponding callable object
        $xCallableObject = $this->getCallableObject($sClassName);
        return ($xCallableObject) ? $xCallableObject->getRegisteredObject() : null;
    }