Returns the asset manager instance.
@throws Exception on invalid configuration.
@return AssetManager asset manager instance.
195328
public function getAssetManager()
    {
        if (!is_object($this->_assetManager)) {
            $options = $this->_assetManager;
            if (empty($options['__class'])) {
                $options['__class'] = AssetManager::class;
            }
            if (!isset($options['basePath'])) {
                throw new Exception("Please specify 'basePath' for the 'assetManager' option.");
            }
            if (!isset($options['baseUrl'])) {
                throw new Exception("Please specify 'baseUrl' for the 'assetManager' option.");
            }

            if (!isset($options['forceCopy'])) {
                $options['forceCopy'] = true;
            }

            $this->_assetManager = $this->app->createObject($options);
        }

        return $this->_assetManager;
    }
361129
public ContentPropertyManager getContentPropertyManager() {
        if (contentPropertyManager != null) {
            return contentPropertyManager;
        }
        contentPropertyManager = (ContentPropertyManager) ContainerManager.getComponent("contentPropertyManager");
        return contentPropertyManager;
    }
1291490
public function manager()
    {
        if (!isset($this->manager)) {
            $this->manager = new Manager($this->client);
        }

        return $this->manager;
    }
1374897
public function getObjectManager(): ObjectManagerInterface
    {
        if (!isset($this->earlyInstances[ObjectManagerInterface::class])) {
            debug_print_backtrace();
            throw new FlowException('The Object Manager is not available at this stage of the bootstrap run.', 1301120788);
        }
        return $this->earlyInstances[ObjectManagerInterface::class];
    }
1019442
protected Object getCacheManager() {
        CacheManager cacheManager = CacheManager.getInstance();
        if (cacheManager != null)
            return cacheManager;
        return CacheManager.newInstance();
    }
209031
public function getType()
    {
        $type = $this->getArgument('type');
        $allowed = $this->getAllowedTypes();

        if ($type) {
            if (! $this->isAllowedType($type)) {
                throw new AssetException('Illegal Asset Type: Assets types can be only '.implode(', ', $allowed));
            }

            return $type;
        }

        $ext = pathinfo($this->getArgument('path'), PATHINFO_EXTENSION);

        return ($ext && $ext === 'js') ? $allowed[0] : $allowed[1];
    }
1195005
public static BeanManager getBeanManager() {
        BeanManager mgr = getBeanManagerFromJndi();
        if (mgr == null) {
            ServiceLoader<BeanManagerProvider> loader = ServiceLoader
                .load(BeanManagerProvider.class);
            Iterator<BeanManagerProvider> it = loader.iterator();

            while (mgr == null && it.hasNext()) {
                BeanManagerProvider provider = it.next();
                mgr = provider.getBeanManager();
            }
        }

        return mgr;
    }
352828
protected function getAssetFolder()
    {
        $folders = $this->owner->config()->asset_folders;
        
        if (is_array($folders) && isset($folders[static::class])) {
            return $folders[static::class];
        }
    }
741869
public function getConfigFileManager()
    {
        if (!$this->started) {
            throw new LogicException('Puli was not started');
        }

        if (!$this->configFileManager && $this->context->getHomeDirectory()) {
            $this->configFileManager = new ConfigFileManagerImpl(
                $this->context,
                $this->getJsonStorage()
            );
        }

        return $this->configFileManager;
    }
1356429
private function initAssetManager()
    {
        $this->di->mapService('core.asset', '\Core\Asset\AssetManager');

        $this->assetmanager = $this->di->get('core.asset');

        // Create default js asset handler
        $ah = $this->assetmanager->createAssetHandler('js', 'js');
        $ah->setBasedir($this->basedir);
        $ah->setBaseurl(BASEURL);

        $this->di->mapValue('core.asset.js', $ah);

        // Add minify processor on config demand
        if ($this->config->get('Core', 'asset.general.minify_js')) {
            $ah->addProcessor(new \Core\Asset\Processor\JSMinProcessor());
        }

        // Create default css asset handler
        $ah = $this->assetmanager->createAssetHandler('css', 'css');
        $ah->setBasedir($this->basedir);
        $ah->setBaseurl(BASEURL);

        $this->di->mapValue('core.asset.css', $ah);

        // Add minify processor on config demand
        if ($this->config->get('Core', 'asset.general.minify_css')) {
            $ah->addProcessor(new \Core\Asset\Processor\CssMinProcessor());
            $ah->addProcessor(new \Core\Asset\Processor\ReplaceProcessor('../fonts/', '../Themes/Core/fonts/'));
            $ah->addProcessor(new \Core\Asset\Processor\ReplaceProcessor('../img/', '../Themes/Core/img/'));
        }
    }
1144199
public function getArea()
    {
        $area = $this->getArgument('area');
        $allowed = $this->getAllowedAreas();

        if ($area) {
            if (! $this->isAllowedArea($area)) {
                throw new AssetException('Illegal Asset Area: Assets can be only assigned to '.implode(', ', $allowed));
            }

            return $area;
        }

        return reset($allowed);
    }
800023
public function getAssetFilesConfiguration()
    {
        if (!$this->assetFilesConfiguration instanceof \AssetsBundle\AssetFile\AssetFilesConfiguration) {
            $this->setAssetFilesConfiguration(new \AssetsBundle\AssetFile\AssetFilesConfiguration());
        }
        return $this->assetFilesConfiguration;
    }
324983
public function getAssetFilesCacheManager()
    {
        if (!$this->assetFilesCacheManager instanceof \AssetsBundle\AssetFile\AssetFilesCacheManager) {
            $this->setAssetFilesCacheManager(new \AssetsBundle\AssetFile\AssetFilesCacheManager());
        }
        return $this->assetFilesCacheManager;
    }
99044
public AssetInfo getImplAsset(String className) throws ServiceException {
        int lastDot = className.lastIndexOf('.');
        if (lastDot > 0 && lastDot < className.length() - 1) {
            String assetRoot = className.substring(0, lastDot) + "/" + className.substring(lastDot + 1);
                AssetInfo implAsset = getAsset(assetRoot + ".java");
                if (implAsset == null)
                    return getAsset(assetRoot + ".kt");
        }
        return null;
    }
598576
public function getFileManager()
    {
        if ($this->file_manager_instance === null) {
            $this->file_manager_instance = new FileManager($this);
        }

        return $this->file_manager_instance;
    }
1369641
static public function getInstance(){
		if (!isset(self::$_instance)) {
			if (!sfConfig::get('app_amg_sentry_dsn')) {
				throw new Exception('Please configure amgSentryPlugin in your app.yml (use model in "amgSentryPlugin/config/app.yml")');
			}
			self::$_instance = new amgSentry(sfConfig::get('app_amg_sentry_dsn'), array('release' => sfConfig::get('app_amg_sentry_release')));
		}
		return self::$_instance;
	}
113862
public function load()
    {
        if (empty($this->storage)) {
            throw new Exception('Empty config storage');
        }
        $storage = $this->getStorage();
        $storage->load();
        return $this->fromArray($storage->get());
    }