Load and cache the admin config for this module.

@return stdClass the plugin config
551147
public function get_admin_config() {
        if ($this->adminconfig) {
            return $this->adminconfig;
        }
        $this->adminconfig = get_config('assign');
        return $this->adminconfig;
    }
711068
public function loadConfig()
    {
        $fileName = $this->getPath() . DIRECTORY_SEPARATOR . 'config/config.php';
        if(is_file($fileName))
        {
            $name = '@' . $this->moduleName;
            Config::removeConfig($name);
            Config::addConfig($name, include $fileName);
        }
    }
1313221
function load() {

		if ($this->cacheConf['type'] == 'noop') {
			return null; // do nothing
		}
		else { // non-noop

			$loadedState = null;

			if ($this->cacheConf['type'] == 'file') {
				$username = \get_current_user();
				$cacheDir = realpath($this->syspath.'/'.\trim($this->cacheConf['path'], '\\/'));
				$cachePath = $cacheDir.'/freia.'.(\php_sapi_name() === 'cli' ? 'cli' : 'server').'.'.$username.'.symbols.json';
				if ($this->file_exists($cachePath)) {
					try {
						$loadedState = \json_decode($this->file_get_contents($cachePath), true);
					}
					catch (\Exception $e) {
						$this->error_log('Failed to load cache file: '.$cachePath);
						return null;
					}
				}
				else { // couldn't find cache file
					return null;
				}
			}
			else if ($this->cacheConf['type'] == 'memcached') {
				$mc = $this->memcachedInstance();
				try {
					$loadedState = $mc->get('freia-symbols');
				}
				catch (\Exception $e) {
					$loadedState = null;
				}
			}

			// Process Loaded State
			// ====================

			if ($loadedState == null) {
				return null;
			}

			if ($loadedState['version'] == $this->state['version']) {
				return $loadedState;
			}
			else { // deprecated state
				return null;
			}
		}
	}
144702
protected function loadPluginManagerConfigs()
    {
        foreach ($this->getXml()->xpath('plugins/pluginmanager[@type != ""]') as $pmConfig) {
            $key = (string)$pmConfig['type'];
            $config = $this->createServiceManagerConfig($pmConfig);

            if ($config) {
                $this->manifest['application_config'][$key] = $config;
            }
        }

        return $this;
    }
767983
protected function load_config() {
        if (!isset($this->config)) {
            $name = $this->get_name();
            $this->config = get_config("enrol_$name");
        }
    }
213453
public function getModulesAutoloadConfig()
    {
        $isCacheInstance = $this->cache instanceof CacheInterface;
        if ($isCacheInstance) {
            if (($autoloadConfig = $this->cache->getAutoloadModulesConfig()) !== false) {
                return $autoloadConfig;
            }
        }
        
        $autoloadConfig = $this->getModulesAutoloadConfigWithoutCache();
        if ($isCacheInstance) {
            $this->cache->setAutoloadModulesConfig($autoloadConfig);
        }
        return $autoloadConfig;
    }
879396
protected function load_enabled_plugins() {
        global $CFG;

        if ($this->enabledplugins) {
            return;
        }

        if (empty($CFG->version)) {
            $this->enabledplugins = array();
            return;
        }

        $cache = cache::make('core', 'plugin_manager');
        $enabled = $cache->get('enabled');

        if (is_array($enabled)) {
            $this->enabledplugins = $enabled;
            return;
        }

        $this->enabledplugins = array();

        require_once($CFG->libdir.'/adminlib.php');

        $plugintypes = core_component::get_plugin_types();
        foreach ($plugintypes as $plugintype => $fulldir) {
            $plugininfoclass = static::resolve_plugininfo_class($plugintype);
            if (class_exists($plugininfoclass)) {
                $enabled = $plugininfoclass::get_enabled_plugins();
                if (!is_array($enabled)) {
                    continue;
                }
                $this->enabledplugins[$plugintype] = $enabled;
            }
        }

        $cache->set('enabled', $this->enabledplugins);
    }
1300062
public function getAutoloaderConfig()
    {
        $autoloaderArray = array();

        // If this module has a defined classmap, add a classmap autoloader.
        $classmapPath = $this->getDir() . '/' . $this->relativeModuleDir . 'autoload_classmap.php';
        if (file_exists($classmapPath)) {
            $autoloaderArray['Zend\Loader\ClassMapAutoloader'] = array(
                $classmapPath
            );
        }

        // Fallback to a PSR-0 autoloader.
        $autoloaderArray['Zend\Loader\StandardAutoloader'] = array(
            'namespaces' => array(
                $this->getNamespace() =>
                    $this->getDir() . '/' . $this->relativeModuleDir . 'src/' . $this->getNamespace(),
            ),
        );

        return $autoloaderArray;
    }
731023
protected function GetModuleConfig()
    {
        $this->oModuleConfig = TdbPkgShopRatingServiceWidgetConfig::GetNewInstance();
        if (!$this->oModuleConfig->LoadFromField('cms_tpl_module_instance_id', $this->instanceID)) {
            $this->oModuleConfig = null;
        }

        return $this->oModuleConfig;
    }
44932
protected function load_config() {
        global $DB;

        if (!$config = $DB->get_record('workshopform_rubric_config', array('workshopid' => $this->workshop->id), 'layout')) {
            $config = (object)array('layout' => 'list');
        }
        return $config;
    }
608435
public function loadConfig()
    {
        $fileName = File::path(dirname($this->getPath()), 'config/config.php');
        if(is_file($fileName))
        {
            Config::addConfig('@' . $this->moduleName, include $fileName);
        }
    }
80896
protected function &GetModuleConfig()
    {
        if (is_null($this->oModuleConfig)) {
            $this->oModuleConfig = TdbShopSystemInfoModuleConfig::GetNewInstance();
            if (!$this->oModuleConfig->LoadFromField('cms_tpl_module_instance_id', $this->instanceID)) {
                $this->oModuleConfig = null;
            }
        }

        return $this->oModuleConfig;
    }
675275
protected static function _getConfig() {
        if (null === self::$_classConfigCacheEnabled) {
            self::$_classConfigCacheEnabled = CM_Config::get()->classConfigCacheEnabled;
        }

        $calledClass = get_called_class();
        $cacheKey = CM_CacheConst::ClassConfig . '_className:' . $calledClass;
        $cache = new CM_Cache_Storage_Apc();
        if (!self::$_classConfigCacheEnabled || !isset(self::$_classConfigList[$calledClass])) {
            if (!self::$_classConfigCacheEnabled || false === ($result = $cache->get($cacheKey))) {
                $result = self::_getConfigRaw();
                if (self::$_classConfigCacheEnabled) {
                    $cache->set($cacheKey, $result);
                }
            }
            self::$_classConfigList[$calledClass] = $result;
        }

        return self::$_classConfigList[$calledClass];
    }
1237630
public function load(AdminInterface $admin)
    {
        $filename = $this->cacheFolder.'/route_'.md5($admin->getCode());

        $cache = new ConfigCache($filename, $this->debug);
        if (!$cache->isFresh()) {
            $resources = [];
            $routes = [];

            $reflection = new \ReflectionObject($admin);
            if (file_exists($reflection->getFileName())) {
                $resources[] = new FileResource($reflection->getFileName());
            }

            if (!$admin->getRoutes()) {
                throw new \RuntimeException('Invalid data type, AdminInterface::getRoutes must return a RouteCollection');
            }

            foreach ($admin->getRoutes()->getElements() as $code => $route) {
                $routes[$code] = $route->getDefault('_sonata_name');
            }

            if (!\is_array($admin->getExtensions())) {
                throw new \RuntimeException('extensions must be an array');
            }

            foreach ($admin->getExtensions() as $extension) {
                $reflection = new \ReflectionObject($extension);
                $resources[] = new FileResource($reflection->getFileName());
            }

            $cache->write(serialize($routes), $resources);
        }

        return unserialize(file_get_contents($filename));
    }
730147
public function getConfig() {
		if(!$this->config) {
			$this->config = $config = new \Asgard\Config\Config($this->getCache());
			if(file_exists($this->params['root'].'/config'))
				$config->loadDir($this->params['root'].'/config', $this->getEnv());
		}
		return $this->config;
	}
400235
protected static function fill_classmap_cache() {
        global $CFG;

        self::$classmap = array();

        self::load_classes('core', "$CFG->dirroot/lib/classes");

        foreach (self::$subsystems as $subsystem => $fulldir) {
            if (!$fulldir) {
                continue;
            }
            self::load_classes('core_'.$subsystem, "$fulldir/classes");
        }

        foreach (self::$plugins as $plugintype => $plugins) {
            foreach ($plugins as $pluginname => $fulldir) {
                self::load_classes($plugintype.'_'.$pluginname, "$fulldir/classes");
            }
        }
        ksort(self::$classmap);
    }
362855
protected function getConfigs()
    {
        if ($this->hasCache()) {
            return $this->getCache();
        }

        $pluginConfigs = $this->pluginConfig;

        $configs = [];

        foreach ($pluginConfigs as $name => $pluginConfig) {
            $config = $this->configFields->convertBc(
                $name,
                $pluginConfig
            );

            $configs[] = new ConfigBasic($config);
        }

        $newConfigs = $this->configRepositoryJson->find();

        $configs = array_merge($configs, $newConfigs);

        $this->setCache($configs);

        return $configs;
    }