Parses the extension settings.

@return \RGU\Dvoconnector\Domain\Model\EmConfiguration
@throws \Exception If the configuration is invalid.
490754
public static function getSettings()
    {
        $configuration = self::parseSettings();
        require_once(ExtensionManagementUtility::extPath('dvoconnector') . 'Classes/Domain/Model/EmConfiguration.php');
        $settings = new \RGU\Dvoconnector\Domain\Model\EmConfiguration($configuration);
        return $settings;
    }
1313343
private function loadSettings()
    {

        $settings = $this->manage_settings->getSetting($this);

        if (isset($settings['extensions'])) {
            //loading all extensions
            try {
                $this->loadExtensions($settings['extensions']);
            } catch (\Exception $ex) {
                throw new \OWeb\Exception('Failed to load all Extensions in' . OWEB_CONFIG, 0, $ex);
            }
        }
    }
164375
public function getConfiguration(){
        $rest = $this->getService( self::API_NAT_DMZ);
        $rest->GET();

        return $rest->getResult( models\NAT\DmzConfig::class);
    }
951023
protected function parse()
    {
        // Try to parse and fail on any exception ...
        try {
            $this->getFlags()->parse();

            // Extract parsed arguments
            $this
                ->longs($this->getFlags()->longs())
                ->shorts($this->getFlags()->shorts())
                ->arguments($this->getFlags()->args());
        } catch (InvalidFlagParamException $e) {
            $this->showHelp($e->getMessage());
        } catch (InvalidFlagTypeException $e) {
            $this->showHelp($e->getMessage());
        }

        return $this;
    }
1331415
public function get_setting() {
        $result = $this->config_read($this->name);
        if (is_null($result)) {
            return NULL;
        }
        if ($result === '') {
            return array();
        }
        return explode(',', $result);
    }
387378
private function checkConfig()
    {
        if (empty($this->config['api_key'])) {
            throw new Exception("`api_key' must be configured");
        }

        if (empty($this->config['host'])) {
            throw new Exception("`host' must be configured");
        }

        if (empty($this->config['port'])) {
            $this->config['port'] = !empty($this->config['secure']) ? 443 : 80;
        }

        if (!isset($this->config['secure'])) {
            $this->config['secure'] = ($this->config['port'] == 443);
        }

        if (empty($this->config['hostname'])) {
            $this->config['hostname'] = gethostname() ? gethostname() : '<unknown>';
        }

        if (empty($this->config['project_root'])) {
            $this->config['project_root'] = dirname(__FILE__);
        }

        if (empty($this->config['environment_name'])) {
            $this->config['environment_name'] = 'development';
        }

        if (!isset($this->config['params_filters'])) {
            $this->config['params_filters'] = array('/password/');
        }

        if (!isset($this->config['connect_timeout'])) {
            $this->config['connect_timeout'] = 3;
        }

        if (!isset($this->config['write_timeout'])) {
            $this->config['write_timeout'] = 3;
        }

        if (!isset($this->config['backtrace_filters'])) {
            $this->config['backtrace_filters'] = array(
                sprintf('/^%s/', preg_quote($this->config['project_root'], '/')) => '[PROJECT_ROOT]'
            );
        }

        if (!isset($this->config['skipped_exceptions'])) {
            $this->config['skipped_exceptions'] = array();
        }

        if (!isset($this->config['default_writer'])) {
            $this->config['default_writer'] = 'Errbit\Writer\SocketWriter';
        }

        if (!isset($this->config['agent'])) {
            $this->config['agent'] = 'errbitPHP';
        }
        if (!isset($this->config['async'])) {
            $this->config['async'] = false;
        }
        if (!isset($this->config['ignore_user_agent'])) {
            $this->config['ignore_user_agent'] = array();
        }
    }
545371
public function buildParserConfiguration()
    {
        if ($this->parserConfiguration === null) {
            $this->parserConfiguration = parent::buildParserConfiguration();
            $this->parserConfiguration->addInterceptor(new ResourceInterceptor());
        }

        return $this->parserConfiguration;
    }
113345
public function getArray()
    {
        $config = @include $this->location;
        if (!is_array($config)) {
            throw new \Exception('Config not found');
        }

        $this->config = $config;

        return $config;
    }
1135279
public function getRules()
	{
		$settings = $this->getSettings();
		if ($settings === false || !isset($settings->rules)) {
			throw new \Exception('Rule configuration not found');
		}
		return $settings->rules;
	}
1178921
public static function getConfiguration()
    {
        if (self::$configuration === null && file_exists(self::$configFilePath)) {
//            $jsonConfig = file_get_contents(self::$configFilePath_depr);
//            self::$configuration = json_decode($jsonConfig);

            $settings = include __DIR__ . '/../../config/configuration.php';

            self::$configuration = DWDUtil::array_to_object($settings);

            if (DWDConfiguration::$configuration === null)
                throw new ParseError('Error, configuration file could not be found or contains invalid lines.');
        }
        return DWDConfiguration::$configuration;

    }
337412
public function getConfiguration()
    {
        if (null === $this->configuration) {
            $errMsg = 'no attribute \'configuration\'';
            throw new Exception\InvalidConfigurationNameException($errMsg);
        }
        return $this->configuration;
    }
951927
public function getConfiguration()
    {
        foreach ($this->mappings as $env => $callable) {
            $value = getenv($env);
            if ($value !== false) {
                $func = array_slice($callable, 0, 2);
                $args = array_slice($callable, 2);
                array_unshift($args, $value);
                call_user_func_array($func, $args);
            }
        }
        return $this->config;
    }
353030
protected function getConfig()
    {
        if (!$this->table->getDataSource() instanceof Dom) {
            $this->prepareColumnsConfig();
        }
        $this->prepareExtensionsConfig();

        $config = [];
        $config += $this->table->getProperties();

        return json_encode($config);
    }
940195
public function getConfiguration(){
        $rest = $this->getService( self::API_LAN_CONFIG);
        $rest->GET();

        return $rest->getResult( models\LAN\LanConfig::class);
    }
1210821
def parse(self):
        

        self._config = _Config()

        self._setDefaults()

        for parser in self.parsers:
            for key, value in parser.parse(self, self._config).items():
                key = self._sanitizeName(key)
                if key not in self.configs:
                    raise UnknownConfigurationException(key)
                if value is not None:
                    self._setConfig(key, value)

        self._ensureRequired()
        self._cast()

        return self._config
490096
public function getConfiguration(){
        $rest = $this->getService( self::API_UPNP_AV_CONFIG);
        $rest->GET();

        return $rest->getResult( models\UPnP\UpnpAvConfig::class);
    }
192845
protected function getParser($extension)
	{
		$parser = null;

		$extension = strtolower($extension);

		foreach (Processor::all() as $fileParser)
		{
			if (in_array($extension, $fileParser->getSupportedExtensions()))
			{
				$parser = $fileParser;
				break;
			}
		}

		// If none exist, then throw an exception
		if ($parser === null)
		{
			throw new UnsupportedFormatException(sprintf('Unsupported configuration format "%s"', $extension));
		}

		return $parser;
	}