Get the project's full configuration, including those for the project and included addons.

@return array The project's full configuration
773907
public static function getConfiguration(): array
    {
        // first check if there is a project specific configuration
        $projectConfig = (array)self::getProjectConfigurationValues();
        $addonConfig = self::getAddonConfigurationValues();
        
        return array_merge($projectConfig, $addonConfig);
    }
1201502
public function getModulesConfig()
    {
        $result = [];
        foreach ($this->modules as $moduleName => $moduleConfig) {
            $className = $moduleConfig['className'];
            $module    = new $className;
            if (!$module instanceof AbstractModule) {
                $errMsg = sprintf('Class "%s" must be extended from %s', $className, AbstractModule::class);
                throw new Exception\RuntimeException($errMsg);
            }
            $config = $module->getConfig();
            $result = ArrayUtils::merge($result, $this->filterModuleConfig($config, $moduleName));
        }
        return $result;
    }
812198
public function getServiceConfig()
    {
        $configFiles = glob(
                $this->getDir() . '/' . $this->relativeModuleDir . 'config/service/service.config{,.*}.php',
                GLOB_BRACE
        );

        // glob() returns false on error. On some systems, glob() will return false (instead of an empty array) if no
        // files are found. Treat both in the same way - no config will be loaded.
        $configFiles = $configFiles ?: array();

        $config = array();
        foreach ($configFiles as $configFile) {
            $config = ArrayUtils::merge($config, include $configFile);
        }
        return $config;
    }
1290886
protected function getConfig(): array
    {
        $loader = null;
        if ($this->isCacheEnabled() === true) {
            $loader = $this->getLoader();
            $cached = $loader->load();
            if (empty($cached) === false) {
                return $cached;
            }
        }

        if ($this->isFrameworkEnabled() === true) {
            $this->addFrameworkConfigs();
        }

        $merged = [];
        $merger = $this->getMerger();
        foreach ($this->getConfigs() as $config) {
            $merged = $merger->merge(
                $merged,
                $config->load()
            );
        }

        foreach ($this->getGlobalConfig() as $global) {
            $merged = $merger->merge($merged, $global);
        }

        foreach ($this->getModuleConfig() as $module) {
            $merged = $merger->merge($merged, $module);
        }

        if ($this->isCacheEnabled() === true) {
            if ($loader instanceof CacheLoader) {
                $loader->save($merged);
            }
        }

        return $merged;
    }
1049516
public function getConfig()
    {
        $conf = [];
        foreach (glob(__DIR__.'/../../config/*.config.php') as $conFile) {
            $conFile = include_once $conFile;
            if (is_array($conFile))
                $conf = \Poirot\Core\array_merge($conf, $conFile);
        }

        // usually return like this
        return $conf;
    }
1355489
protected function getFreshConfiguration()
    {
        $app = require $this->laravel->bootstrapPath('app.php');

        $app->make(Kernel::class)->bootstrap();
        $config = $app->make('config');

        $files = \array_merge(
            $this->configToCache(), $this->getConfigurationFiles()
        );

        foreach ($files as $file) {
            $config[$file];
        }

        return $config->all();
    }
67243
public function getConfigPath()
    {
        if (null == $this->configPath) {
            $this->configPath = getcwd().'/Configuration';
            Configuration::addPath($this->configPath);
        }
        return $this->configPath;
    }
130868
protected function getFreshConfiguration()
    {
        $app = require $this->laravel->bootstrapPath().'/app.php';

        $app->useStoragePath($this->laravel->storagePath());

        $app->make(ConsoleKernelContract::class)->bootstrap();

        return $app['config']->all();
    }
1237431
public function getConfiguration(){
        $rest = $this->getService( self::API_SYSTEM);
        $rest->GET();

        return $rest->getResult( models\SystemConfig::class);
    }
902485
protected function getModulesAutoloadConfigWithoutCache()
    {
        $result = [];
        foreach ($this->modules as $moduleName => $moduleConfig) {
            $className = $moduleConfig['className'];
            $module    = new $className;
            if (!$module instanceof AbstractModule) {
                $errMsg = sprintf('Class "%s" must be extended from %s', $className, AbstractModule::class);
                throw new Exception\RuntimeException($errMsg);
            }
            $autoloadConfig = $module->getAutoloaderConfig();
            if (!ArrayUtils::isHashTable($autoloadConfig)) {
                $errMsg = sprintf('The autoloader configuration for module "%s" is invalid', $moduleName);
                throw new Exception\RuntimeException($errMsg);
            }
            $result = ArrayUtils::merge($result, $autoloadConfig);
        }
        
        foreach ($result as $moduleName => $configAutoload) {
            foreach ($configAutoload as $key => $value) {
                $result[$moduleName][$key] = realpath($value);
            }
        }
        
        return $result;
    }
930858
protected function getModuleConfig(): array
    {
        $merged = [];
        $merger = $this->getMerger();
        foreach ($this->getModules() as $module) {
            if ($module instanceof ConditionProviderInterface && $module->isConditioned() === true) {
                continue;
            }

            if ($module instanceof ConfigProviderInterface) {
                $merged = $merger->merge(
                    $merged,
                    $module->getConfig()->load()
                );
            }
        }

        return $merged;
    }
743802
private function getAllConfigNames()
    {
        if ($this->allConfig) {
            return $this->allConfig;
        }

        foreach ($this->configFactory->listAll() as $name) {
            $this->allConfig[] = $name;
        }

        return $this->allConfig;
    }
364640
public function getConfigurationOverrides()
	{
		if ($this->overrides) {
			return $this->overrides;
		}

		return $this->overrides = $this->container['config.universal_loader']->load($this->getSupraRoot().'/config.yml'); //@todo: resolve config per environment

	}
27032
protected function getConfig()
    {
        if ($this->config !== null) {
            return $this->config;
        }

        $this->config = $this->getDefaultConfig();

        $app = $this->getContainer();

        $file = $app['filesystem']->getFile(strtolower("extensions_config://{$this->getName()}.{$this->getVendor()}.yml"));

        if (!$file->exists()) {
            try {
                $this->copyDistFile($file);
            } catch (RuntimeException $e) {
                return $this->config;
            }
        }

        $this->addConfig($file);

        $localFile = $file->getParent()->getFile($file->getFilename('.yml') . '_local.yml');
        if ($localFile->exists()) {
            $this->addConfig($localFile);
        }

        return $this->config;
    }
1078071
protected function get_full_component_list() {
        global $CFG;

        $list = \core_component::get_component_list();
        $list['core']['core'] = "{$CFG->dirroot}/lib";
        $formattedlist = [];
        foreach ($list as $plugintype => $plugin) {
            $formattedlist[] = ['plugin_type' => $plugintype, 'plugins' => array_keys($plugin)];
        }

        return $formattedlist;
    }
1330405
public function getExtendedConfig() {
        $config = array();
        foreach ($this->getOption(self::OPTION_CONFIG_SOURCES) as $key => $source) {
            $config[$key] = $source->getConfig();
        }
        return $config;
    }
1310428
public function getConfig()
    {
        $config = false;
        if (file_exists(realpath(__DIR__ . "/../ExactTargetLaravelConfig.php"))) {
            $config = include __DIR__ . "/../ExactTargetLaravelConfig.php";
            return $config;
        }
        return $config;
    }