Get the services provided by the provider.

@return array
162405
public function provides()
    {
        $provides = $this->provides;

        $this->fireCallbacks('provides', null, function (Closure $callback) use (&$provides) {
            $result = $callback->call($this, $this->app, $provides);
            if (is_array($result)) {
                $provides = array_merge($provides, $result);
            }
        });

//        foreach ( $this->providers as $provider ) {
//            $instance = $this->app->resolveProviderClass($provider);

//            $provides = array_merge($provides, $instance->provides());
//        }

//        $commands = [ ];
//        foreach ( $this->commands as $k => $v ) {
//            if ( is_string($k) ) {
//                $commands[] = $k;
//            }
//        }

//        return array_merge(
//            $provides,
//            array_keys($this->aliases),
//            array_keys($this->bindings),
//            array_keys($this->share),
//            array_keys($this->shared),
//            array_keys($this->singletons),
//            array_keys($this->weaklings),
//            $commands
//        );
        return $provides;
    }
996280
public function getService()
    {
        $service = $this->getOption('service');

        return \Owl\Service\Container::getInstance()->get($service);
    }
759050
public function getInformations()
    {
        $informations = [];

        foreach ($this->providers as $provider) {
            if (false === $provider->isApplicable()) {
                continue;
            }

            $informations[] = $provider->getInformation();
        }

        return $informations;
    }
1065032
public static function getConfigurationObjectServices()
    {
        return ServiceFactory::getInstance()
            ->attach(ServiceInterface::SERVICE_CACHE)
            ->with(ServiceInterface::SERVICE_CACHE)
            ->setOption(CacheService::OPTION_CACHE_NAME, InternalCacheService::CONFIGURATION_OBJECT_CACHE_IDENTIFIER)
            ->setOption(CacheService::OPTION_CACHE_BACKEND, InternalCacheService::get()->getBackendCache())
            ->attach(ServiceInterface::SERVICE_PARENTS)
            ->attach(ServiceInterface::SERVICE_DATA_PRE_PROCESSOR)
            ->attach(ServiceInterface::SERVICE_MIXED_TYPES);
    }
1062371
public function providers()
    {
        return collect($this->getManifest())->flatMap(function ($configuration) {
            return (array) ($configuration['providers'] ? $configuration['providers'] : []);
        })->filter()->all();
    }
1024610
public function getServices()
	{
		$this->_zendAmfServer = ZendAmfServiceBrowser::$ZEND_AMF_SERVER;
		
		$methods = $this->_zendAmfServer->getFunctions();

		$methodsTable = '<methods>';
		foreach ($methods as $method => $value)
		{
			
			$functionReflection = $methods[ $method ];
			
			$parameters = $functionReflection->getParameters();
			
			$methodsTable = $methodsTable . "<method name='$method'>";
			
			foreach ($parameters as $param)
			{
				$methodsTable = $methodsTable . "<param name='$param->name'/>";
			}
			
			$methodsTable = $methodsTable . "</method>";
		}
		
		$methodsTable = $methodsTable . '</methods>';
		
		unset( $methods );
		return $methodsTable;
	}
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;
    }
258136
public function getProviders() {
		$hybridAuthProviders = $this->hybridAuth->getProviders();
		$providerList = [];
		foreach($hybridAuthProviders as $providerName => $config)
			$providerList[] = $providerName;

		$providers = $this->makeProviders($providerList);

		return $providers;
	}
891331
protected function _getServices($services)
    {
        if ($services) {
            foreach ($services as $index => $service) {
                if (!$this->_di->has($service)) {
                    if ($this->_di->has($service . 'Mongodb')) {
                        $services[$index] = $service . 'Mongodb';
                    } elseif ($this->_di->has($service . '_mongodb')) {
                        $services[$index] = $service . '_mongodb';
                    } else {
                        $this->console->warn(['`:service` service is not exists: ignoring', 'service' => $service]);
                        unset($services[$index]);
                    }
                }
            }
        } else {
            $services = [];
            foreach ($this->configure->components as $service => $config) {
                $config = json_encode($config, JSON_UNESCAPED_SLASHES);
                if (preg_match('#mongodb://#', $config)) {
                    $services[] = $service;
                }
            }
        }

        return $services;
    }
1165177
protected function getEvents()
    {
        $events = [];

        foreach ($this->laravel->getProviders(EventServiceProvider::class) as $provider) {
            $providerEvents = array_merge($provider->discoverEvents(), $provider->listens());

            $events = array_merge_recursive($events, $providerEvents);
        }

        if ($this->filteringByEvent()) {
            $events = $this->filterEvents($events);
        }

        return collect($events)->map(function ($listeners, $event) {
            return ['Event' => $event, 'Listeners' => implode(PHP_EOL, $listeners)];
        })->sortBy('Event')->values()->toArray();
    }
1351409
public function getProviders()
	{
		$haconfig = $this->config['hybridauth'];
		$providers = array();

		//iterate over the social providers in the config
		foreach (array_get($haconfig, 'providers', array()) as $provider => $config)
		{
			if (array_get($config, 'enabled'))
			{
				$providers[] = $provider;
			}
		}

		return $providers;
	}
930491
public function provides() {
        return [
            \BackupManager\Filesystems\FilesystemProvider::class,
            \BackupManager\Databases\DatabaseProvider::class,
            \BackupManager\ShellProcessing\ShellProcessor::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;
    }
1004636
public function actionServices()
    {
        $this->checkAccess('services');
        
        $settings = [];
        $apiEndpoint = $this->model->ngRestApiEndpoint();
        $userSortSettings = Yii::$app->adminuser->identity->setting->get('ngrestorder.admin/'.$apiEndpoint, false);
        
        if ($userSortSettings && is_array($userSortSettings)) {
            if ($userSortSettings['sort'] == SORT_DESC) {
                $order = '-'.$userSortSettings['field'];
            } else {
                $order = '+'.$userSortSettings['field'];
            }
            
            $settings['order'] = $order;
        }
        
        $userFilter = Yii::$app->adminuser->identity->setting->get('ngrestfilter.admin/'.$apiEndpoint, false);
        if ($userFilter) {
            $settings['filterName'] = $userFilter;
        }
        
        $modelClass = $this->modelClass;

        // check if taggable exists, if yes return all used tags for the 
        if (ObjectHelper::isTraitInstanceOf($this->model, TaggableTrait::class)) {
            $tags = $this->model->findTags();
        } else {
            $tags = false;
        }

        return [
            'service' => $this->model->getNgRestServices(),
            '_tags' => $tags,
            '_hints' => $this->model->attributeHints(),
            '_settings' => $settings,
            '_locked' => [
                'data' => UserOnline::find()->select(['lock_pk', 'last_timestamp', 'u.firstname', 'u.lastname', 'u.id'])->joinWith('user as u')->where(['lock_table' => $modelClass::tableName()])->createCommand()->queryAll(),
                'userId' => Yii::$app->adminuser->id,
            ],
        ];
    }
819677
public function getConfig()
    {
        $config = [];
        foreach ($this->providers as $key => $provider) {
            $config[$key] = $provider->getConfig();
        }

        return $config;
    }
270508
protected function _getServicePath()
    {
        if (isset($this->_options['server'])) {
            return $this->_options['server']->getDirectory();
        }

        if (isset($this->_options['directories'])) {
            return $this->_options['directories'];
        }

        return array();
    }
1325617
public function getServices()
    {
        $services = $this->cacheProvider->fetch(self::CACHE_KEY_SERVICES_URLS);
        if (is_array($services)) {
            return $services;
        }

        $services = [];
        foreach ($this->analyticsServices as $name => $service) {
            if (is_numeric($name)) {
                continue;
            }

            $services[] = [
                '$ref' => $this->router->generate(
                    'graviton_analytics_service',
                    [
                        'service' => $service['route']
                    ],
                    false
                ),
                'profile' => $this->router->generate(
                    'graviton_analytics_service_schema',
                    [
                        'service' => $service['route']
                    ],
                    true
                )
            ];
        }
        $this->cacheProvider->save(
            self::CACHE_KEY_SERVICES_URLS,
            $services,
            $this->cacheTimeMetadata
        );
        return $services;
    }