(non-PHPdoc)
@see \Zend\ModuleManager\Feature\ServiceProviderInterface::getServiceConfig()
555826
public function getServiceConfig()
    {
        return array(
            'initializers' => array(
                function ($instance, $sm) {
                    if ($instance instanceof \DlcBase\Module\ModuleNamespaceAwareInterface) {
                        $class           = get_class($instance);
                        $moduleNamespace = substr($class, 0, strpos($class, '\\'));
                        $instance->setModuleNamespace($moduleNamespace);
                    }
                }
            ),
        );
    }
5972
protected function getCommonService() {
		if ($this->service === null) {
			if ($this->arguments === null) {
				$this->service = $this->initService();
			} else {
				$args = $this->normalizeArgs($this->arguments);
				$args = $this->processArgs($args);
				
				$this->service = $this->initService($args);
			}
		}
		
		return $this->service;
	}
46572
public function getConfiguration(){
        $rest = $this->getService( self::API_PARENTAL_CONFIG);
        $rest->GET();

        return $rest->getResult( models\ParentalControl\FilterConfig::class);
    }
1374653
protected function getFormzConfiguration()
    {
        $rootConfigurationArray = $this->getFormObject()
            ->getConfiguration()
            ->getRootConfiguration()
            ->toArray();

        $cleanFormzConfigurationArray = [
            'view' => $rootConfigurationArray['view']
        ];

        return ArrayService::get()->arrayToJavaScriptJson($cleanFormzConfigurationArray);
    }
1021666
public function getServiceConfig()
    {
        return array(
            'invokables' => array(
                'dlcdoctrine_event_finishlistener' => 'DlcDoctrine\Event\FinishListener',
                'dlcdoctrine_setup_service' => 'DlcDoctrine\Service\Setup',
            ),
            'factories' => array(
                'dlcdoctrine_module_options' => function ($sm) {
                    $config = $sm->get('Config');
                    return new Options\ModuleOptions(isset($config['dlcdoctrine']) ? $config['dlcdoctrine'] : array());
                },
                'dlcdoctrine_resolvetargetentitylistener' => function ($sm) {
                    $options = $sm->get('dlcdoctrine_module_options');
                    //Create instance of ResolveTargetEntityListener
                    $resolveTargetEntityListener = new \DlcDoctrine\Event\ResolveTargetEntityListener();
                    //Add all resolve target entities
                    foreach ($options->getResolveTargetEntities() as $originalEntity => $newConfig) {
                        $resolveTargetEntityListener->addResolveTargetEntity($originalEntity, $newConfig['newEntity'], $newConfig['mapping']);
                    }
                    
                    return $resolveTargetEntityListener;
                }
            ),
            'initializers' => array(
                function ($instance, $sm) {
                    if ($instance instanceof \DoctrineModule\Persistence\ObjectManagerAwareInterface) {
                        $instance->setObjectManager($sm->get('doctrine.entitymanager.orm_default'));
                    }
                }
            ),
        );
    }
853782
public function getService()
    {
        $serviceNodes = $this->element->getElementsByTagName('service');
        if ($serviceNodes->length > 0) {
            return new ServiceNode($this->document, $serviceNodes->item(0));
        }
        return null;
    }
792233
private function getServiceConfig(string $name)
    {
        $config = $this->services()[$name] ?? null;
        if ($config === null) {
            return null;
        }

        if (\is_string($config)) {
            return [
                'class' => $config,
            ];
        }
        if (\is_array($config) && array_key_exists('class', $config)) {
            return $config;
        }

        throw new InvalidConfigException('Config must be either type of string (class name) or array (with `class` element');
    }
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;
    }
1079317
protected function loadServiceConfig()
    {
        $xml = $this->getNode('./servicemanager');
        $config = $this->createServiceManagerConfig($xml, true);

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

        return $this;
    }
1089620
private function getNettePresenterFactory(): Nette\DI\Definitions\ServiceDefinition
    {
        $applicationExtension = $this->compiler->getExtensions(Nette\Bridges\ApplicationDI\ApplicationExtension::class);
        if ($applicationExtension === []) {
            throw new \LogicException('ApplicationExtension not found, did you register it in your configuration?');
        }

        $container = $this->getContainerBuilder();
        $presenterFactory = reset($applicationExtension)->prefix('presenterFactory');
        if (!$container->hasDefinition($presenterFactory)) {
            throw new \LogicException('PresenterFactory service from ApplicationExtension not found. Make sure ApplicationExtension is loaded before PresenterMappingExtension.');
        }

        /** @var Nette\DI\Definitions\ServiceDefinition $serviceDefinition */
        $serviceDefinition = $container->getDefinition($presenterFactory);

        return $serviceDefinition;
    }
230495
public function getServiceConfig()
    {
        return array(
            'aliases' => array(
                'dlccategory_doctrine_em' => 'doctrine.entitymanager.orm_default',
            ),
            
            'invokables' => array(
                'dlccategory_category_mapper'   => 'DlcCategory\Mapper\Category',
                'dlccategory_category_service'  => 'DlcCategory\Service\Category',
                'dlccategory_setup_service'     => 'DlcCategory\Service\Setup',
            ),
            
            'factories' => array(
                
                'dlccategory_category_hydrator' => function ($sm) {
                    $objectManager = $sm->get('dlccategory_doctrine_em');
                    $options       = $sm->get('dlccategory_module_options');
                    $hydrator      = new \DoctrineModule\Stdlib\Hydrator\DoctrineObject(
                            $objectManager,
                            $options->getCategoryEntityClass()
                    );
                    
                    return $hydrator;
                },
                
                'dlccategory_addcategory_form' => function ($sm) {
                    $form = new \DlcCategory\Form\AddCategory();
                    $form->setServiceLocator($sm);
                    $form->init();
                    return $form;
                },
                
                'dlccategory_editcategory_form' => function ($sm) {
                    $form = new \DlcCategory\Form\EditCategory();
                    $form->setServiceLocator($sm);
                    $form->init();
                    return $form;
                },
            
                'dlccategory_module_options' => function ($sm) {
                    $config = $sm->get('Config');
                    return new Options\ModuleOptions(isset($config['dlccategory_module_options']) ? $config['dlccategory_module_options'] : array());
                },
                
                'dlccategory_nestedset_config' => function ($sm) {
                    $em = $sm->get('dlccategory_doctrine_em');
                    $options = $sm->get('dlccategory_module_options');
                    
                    $config = new \DoctrineExtensions\NestedSet\Config($em, $options->getCategoryEntityClass());
                    return $config;
                },
                
                'dlccategory_nestedset_manager' => function ($sm) {
                    $manager = new \DoctrineExtensions\NestedSet\Manager($sm->get('dlccategory_nestedset_config'));
                    return $manager;
                },
            ),
        );
    }
677578
public function getService()
    {
        if (null === $this->service) {
            $class = explode('\\', get_class($this));
            $class = substr(end($class), 0, -10);
            $serviceKey = strtolower($this->getModuleNamespace() . '_' . $class . '_service');
            $this->setService($this->getServiceLocator()->get($serviceKey));
        }
        return $this->service;
    }
1000233
public function getConfiguration(){
        $rest = $this->getService( self::API_FTP_CONFIG);
        $rest->GET();

        return $rest->getResult( models\FtpConfig::class);
    }
489876
public function getServices(): ServiceContainer
    {
        if (is_null($this->services)) {
            $this->services = new ServiceContainer();
            $this->services->setConstraints(['caching'    => '\Psr\SimpleCache\CacheInterface',
                                             'events'     => '\Psr\EventManager\EventManagerInterface',
                                             'flashbag'   => '\Berlioz\Core\Services\FlashBag',
                                             'logging'    => '\Psr\Log\LoggerInterface',
                                             'routing'    => '\Berlioz\Core\Services\Routing\RouterInterface',
                                             'templating' => '\Berlioz\Core\Services\Template\TemplateInterface']);
            $this->services->registerServices(['events'     => ['class' => '\Berlioz\Core\Services\Events\EventManager'],
                                               'flashbag'   => ['class' => '\Berlioz\Core\Services\FlashBag'],
                                               'logging'    => ['class' => '\Berlioz\Core\Services\Logger'],
                                               'routing'    => ['class' => '\Berlioz\Core\Services\Routing\Router'],
                                               'templating' => ['class' => '\Berlioz\Core\Services\Template\DefaultEngine']]);
            $this->services->registerServices($this->getConfig()->get('app.services'));
            $this->services->register('app', $this);
        }

        return $this->services;
    }
487041
public function getConfiguration(){
        $rest = $this->getService( self::API_CONNECTION_CONFIG);
        $rest->GET();

        return $rest->getResult( models\Connection\Config::class);
    }
6530
public function getServiceConfig()
    {
        return [
            'factories' => [
                'doctrine.entitymanager.orm_sro_account' => new Service\EntityManagerFactory('orm_sro_account'),
                'doctrine.connection.orm_sro_account' => new Service\DBALConnectionFactory('orm_sro_account'),
                'doctrine.configuration.orm_sro_account' => new Service\ConfigurationFactory('orm_sro_account'),
                'doctrine.entitymanager.orm_sro_shard' => new Service\EntityManagerFactory('orm_sro_shard'),
                'doctrine.connection.orm_sro_shard' => new Service\DBALConnectionFactory('orm_sro_shard'),
                'doctrine.configuration.orm_sro_shard' => new Service\ConfigurationFactory('orm_sro_shard'),
                'doctrine.entitymanager.orm_sro_log' => new Service\EntityManagerFactory('orm_sro_log'),
                'doctrine.connection.orm_sro_log' => new Service\DBALConnectionFactory('orm_sro_log'),
                'doctrine.configuration.orm_sro_log' => new Service\ConfigurationFactory('orm_sro_log'),
            ]
        ];
    }
887661
public function getConfig($service)
    {
        $baseConfig = array(
            'credentials' => $this->config['credentials'],
            'region' => $this->config['region'],
            'profile' => $this->config['profile'],
            'version' => 'latest',
        );

        if (!isset($this->config['services'][$service])) {
            return $baseConfig;
        }

        return array_merge($baseConfig, $this->config['services'][$service]);
    }