(non-PHPdoc)
@see \DlcBase\Module\AbstractModule::getServiceConfig()
557743
public function getServiceConfig()
    {
        return array(
            'aliases' => array(
            ),

            'invokables' => array(
                'dlcdiagramm_yuml_generator' => 'DlcDiagramm\Generator\Yuml',
                'dlcdiagramm_yuml_proxy' => 'DlcDiagramm\Proxy\Yuml',
                'dlcdiagramm_diagramm_service' => 'DlcDiagramm\Service\Diagramm',
            ),

            'factories' => array(
                'dlcdiagramm_yuml_filter' => function ($sm) {
                    $filter = new \Zend\Filter\FilterChain();
                    $filter->attach(new \Zend\Filter\Word\SeparatorToCamelCase(' '))
                           ->attach(new \Zend\Filter\Word\DashToUnderscore());
                    return $filter;
                },
                'dlcdiagramm_yuml_httpclient' => function ($sm) {
                    $url = $sm->get('dlcdiagramm_module_options')->getYumlUrl();
                    $httpClient = new \Zend\Http\Client($url, array('timeout' => 30));
                    $httpClient->setMethod(\Zend\Http\Request::METHOD_POST);
                    return $httpClient;
                },
                'dlcdiagramm_module_options' => function ($sm) {
                    $config = $sm->get('Config');
                    return new Options\ModuleOptions(isset($config['dlcdiagramm']) ? $config['dlcdiagramm'] : array());
                },
            ),
        );
    }
911815
public function getConfigServiceId()
    {
        return strtolower(str_replace(
            '%bundle_service_id%',
            str_replace('%bundle_name%', $this->id, BundleInterface::BUNDLE_SERVICE_ID_PATTERN),
            BundleInterface::CONFIG_SERVICE_ID_PATTERN
        ));
    }
1000233
public function getConfiguration(){
        $rest = $this->getService( self::API_FTP_CONFIG);
        $rest->GET();

        return $rest->getResult( models\FtpConfig::class);
    }
554651
private function getConfigObject()
    {
        if (!isset($this->config)) {
            $config = [];
            $file = $this->appRoot . '/' . $this->cliConfig->get('service.app_config_file');
            if (file_exists($file)) {
                $config = (array) (new YamlParser())->parseFile($file);
            }
            $this->config = new AppConfig($config);
        }

        return $this->config;
    }
712649
public function getOptions()
    {
        if (null === $this->options) {
            $serviceKey = strtolower($this->getModuleNamespace()) . '_module_options';
            $this->setOptions($this->getServiceLocator()->get($serviceKey));
        }
        return $this->options;
    }
837154
public function getConfiguration(){
        $rest = $this->getService( self::API_DOWNLOAD_CONFIG);
        $rest->GET();

        return $rest->getResult( models\Download\Config\DownloadConfig::class);
    }
1030399
public function getServiceClass(string $serviceName, bool $forced = true): ?string {
        if(!isset($this->serviceClassNames[$serviceName])) {
            if($this->serviceExists($serviceName)) {
                /** @var ContainerInterface $container */
                $container = $this->serviceData[$serviceName];
                if($container->isInstanceLoaded()) {
                    $this->serviceClassNames[$serviceName] = get_class( $container->getInstance() );
                    goto finish;
                }

                if($container instanceof ServiceAwareContainerInterface) {
                    $this->serviceClassNames[$serviceName] = $container->getServiceClass();
                    goto finish;
                } elseif($container instanceof ConfiguredServiceContainer) {
                    $cfg = $container->getConfiguration();
                    // In case of a direct instance fonciguration, get this classname
                    if($cn = $cfg[AbstractFileConfiguration::SERVICE_CLASS] ?? NULL) {
                        $this->serviceClassNames[$serviceName] = $cn;
                        goto finish;

                    } elseif($cn = $cfg[AbstractFileConfiguration::CONFIG_SERVICE_TYPE_KEY] ?? NULL) {
                        // If the developer defined the class by configuration in case of container or file initialisation, use this.
                        $this->serviceClassNames[$serviceName] = $cn;
                        goto finish;
                    }
                }

                // If nothing worked before, finally load the instance
                if($forced)
                    $this->serviceClassNames[$serviceName] = get_class( $container->getInstance() );
            } else {
                // Mark as not existing
                $this->serviceClassNames[$serviceName] = false;
            }
        }

        finish:

        return $this->serviceClassNames[$serviceName] ?: NULL;
    }
829810
public function getConfig()
    {
        if ($this->cache instanceof Cache\CacheInterface && !empty($configs = $this->cache->getConfig())) {
            return $configs;
        }

        $configs = $this->moduleHandler->getModulesConfig();
        foreach ($this->files as $file) {
            $config = require $file;
            if (!is_array($config)) {
                throw new Exception\RuntimeException(sprintf('The config in "%s" file must be array data type', $file));
            }
            $configs = ArrayUtils::merge($configs, require $file);
        }

        return $this->cleanUp($configs);
    }
332471
private function getConfigService()
    {
        $className = config('hc.config_service');
        $service = app()->make($className);

        if (!$service instanceof HCConfigServiceContract) {
            throw new HCException(
                'Class ' . $className . ' must be instance of HoneyComb\\Core\\Contracts\\HCConfigServiceContract'
            );
        }

        return $service;
    }
451117
public static function get($service, $default = null) {
		if($service instanceof BaseService) {
			return $service;
		}
		$serviceInstance = ArrayHelper::getValue(\App::$domain, $service, $default);
		if(!is_object($serviceInstance)) {
			throw new InvalidConfigException("Service \"$service\" not found");
		}
		return $serviceInstance;
	}
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;
    }
358671
public function getProviderConfig()
    {

        if (empty($this->config) === false) {
            return $this->config;
        } else {

            throw new BaseException((new \ReflectionClass(get_class()))->getShortName(), 'Empty provider config', 500);
        }
    }
1079317
protected function loadServiceConfig()
    {
        $xml = $this->getNode('./servicemanager');
        $config = $this->createServiceManagerConfig($xml, true);

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

        return $this;
    }
362197
public function getModuleConfig(string $namespace) {
		if (array_key_exists($namespace, $this->moduleConfigs)) {
			return $this->moduleConfigs[$namespace];
		}
		
		$module = $this->moduleManager->getModuleByNs($namespace);
		if ($module->hasConfigDescriber()) {
			return $this->moduleConfigs[$namespace] = $module->createConfigDescriber($this)->buildCustomConfig();
		}
		
		return $this->moduleConfigs[$namespace] = null;
	}
686317
private static function getBaseFromService($service, $serviceConfig)
    {
        if (isset($serviceConfig[0]['router-base']) && strlen($serviceConfig[0]['router-base']) > 0) {
            $base = $serviceConfig[0]['router-base'] . '/';
        } else {
            $parts = explode('.', $service);

            $entity = array_pop($parts);
            $module = $parts[1];

            $base = '/' . $module . '/' . $entity . '/';
        }

        return $base;
    }
484975
public function getConfig($key)
    {
        if (! $this->getServiceLocator()->has($this->getId().'/'.$key)) {
            return false;
        }

        try{
            $config =  $this->getServiceLocator()->get($this->getId().'/'.$key);
            if ($config instanceof ConfigurationService) {
                $config = $config->getConfig();
            }
        } catch(ServiceNotFoundException $e){
            $config = false;
        }
        return $config;
    }
1314454
public static function service(string $service)
    {
        if (!array_key_exists($service, self::$available_services)) {
            throw (new ServiceNotFoundException(sprintf(
                '"%s" is not registered as a service.',
                $service
            )))->setServiceName($service);
        }

        $service_class = static::$available_services[$service];

        $config = static::$config['services'][$service] ?? null;

        if (is_null($config)) {
            throw (new ServiceConfigurationNotFoundException(sprintf(
                '"%s" configuration not found.',
                $service
            )))->setServiceName($service);
        }

        return $service_class::configure($config);
    }