Get complete service object.

@return \Droath\ProjectX\Engine\DockerService
A fully defined service object.
968637
public function getService()
    {
        if (!isset($this->service)) {
            $info = $this->getInfo();
            $this->service = $this->service();

            // Apply the overridden property values.
            foreach (static::PROPERTIES_OVERRIDE as $property) {
                if (!isset($info[$property]) || empty($info[$property])) {
                    continue;
                }
                $method = 'set' . ucwords($property);

                if (is_callable([$this->service, $method])) {
                    call_user_func_array([$this->service, $method], [$info[$property]]);
                }
            }
        }

        return $this->service;
    }
466738
public function get($service)
    {
        return $this->has($service) ? $this->container->get($service) : null;
    }
122367
public function query() {
        $builder = $this->getServiceLocator()->get($this->builderClassName);
        $builder->setOptions($this->options)->setServiceLocator($this->serviceLocator);
        return $builder;
    }
1161797
protected function getClassService()
    {
        if (is_null($this->service)) {
            $this->service = taoItems_models_classes_ItemsService::singleton();
        }
        return $this->service;
    }
1053607
public static function getServiceProvider() {
		if (is_callable('_elgg_services')) {
			return _elgg_services();
		}

		global $CONFIG;
		if (!isset($CONFIG)) {
			$path = self::getRootPath() . '/engine/settings.php';
			if (!is_file($path)) {
				$path = self::getRootPath() . '/elgg-config/settings.php';
			}
			require_once $path;
		}

		return new \Elgg\Di\ServiceProvider(new \Elgg\Config($CONFIG));
	}
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);
    }
1056881
public function getContentLanguageService()
    {
        if ($this->languageService !== null) {
            return $this->languageService;
        }

        $this->languageService = new LanguageService(
            $this,
            $this->persistenceHandler->contentLanguageHandler(),
            $this->serviceSettings['language']
        );

        return $this->languageService;
    }
1216573
private function addServices()
    {
        if (!$this->container->getDefinitions()) {
            return '';
        }

        $code = "services:\n";
        foreach ($this->container->getDefinitions() as $id => $definition) {
            $code .= $this->addService($id, $definition);
        }

        $aliases = $this->container->getAliases();
        foreach ($aliases as $alias => $id) {
            while (isset($aliases[(string) $id])) {
                $id = $aliases[(string) $id];
            }
            $code .= $this->addServiceAlias($alias, $id);
        }

        return $code;
    }
305724
public function getProspectService()
    {
        if (! $this->prospectService) {
            $this->prospectService = $this->getServiceLocator()->get('playgroundflow_prospect_service');
        }
    
        return $this->prospectService;
    }
416347
public function getServiceLocator()
	{
		if (is_null($this->_serviceLocator))
			$this->_serviceLocator = new ServiceManager(new Config()); //ServiceLocatorFactory::getInstance();
		return $this->_serviceLocator;
	}
1212387
protected function getServiceManager()
    {
        try {
            $serviceManager = $this->getOriginalServiceManager();
        } catch (InvalidServiceManagerException $e) {
            $serviceManager = ServiceManager::getServiceManager();
        }
        return $serviceManager;
    }
772300
public function getAllServices()
    {
        $result = array();
        foreach ($this->getExtensions() as $handle) {
            $result[$handle] = $this->getService($handle);
        }

        return $result;
    }
739507
protected function getService()
    {
        if (!isset($this->service)) {
            $this->service = $this->getServiceLocator()
                    ->get($this->getModuleNamespace() . '\Service\\' . $this->getEntityName());
        }

        return $this->service;
    }
1224898
public function getContainer()
    {
        if (null === $this->_container) {
            // try to fetch from service locator first
            $serviceLocator = $this->getServiceLocator();
            if ($serviceLocator->has('Navigation')) {
                $navigationContainer = $serviceLocator->get('Navigation');
            } else {
                // nothing found in service locator, create new container
                $navigationContainer = new ZendNavigation;
            }
            $this->setContainer($navigationContainer);
        }

        return $this->_container;
    }
1262339
public function getContainer()
    {
        if (property_exists(__CLASS__, 'container')) {
            return $this->container;
        } else {
            return parent::getContainer();
        }

        throw new RuntimeException(sprintf('The service container must be accessible from class %s to use this trait', __CLASS__));
    }
54822
public static function getContainer($zendServiceManager = null)
    {
        if (!self::$container) {
            self::$container = new SymfonyContainerWithZFFallback();
        }

        if (!Module::$zendServiceManager && $zendServiceManager) {
            if ($zendServiceManager->has('serviceLocator')) {
                $zendServiceManager = $zendServiceManager->get('serviceLocator');
            }
            Module::$zendServiceManager = $zendServiceManager;
        }

        return self::$container;
    }
875931
public static function getInstance()
    {
        if (!self::$instance instanceof ClientInterface) {

            $serviceContainer = ServiceContainer::getInstance();

            self::$instance = new static(
                $serviceContainer->get('engine'),
                $serviceContainer->get('procedure_loader'),
                $serviceContainer->get('procedure_compiler'),
                $serviceContainer->get('message_factory')
            );
        }

        return self::$instance;
    }