Retrieve a class configured in the container

@param string $serviceName
@return object @SuppressWarnings(PHPMD.ElseExpression)
973864
public function get($serviceName)
    {
        if ($this->registry->has($serviceName)) {
            $service = $this->registry->getStrict($serviceName);
        }
        elseif ($this->parameterContainer->has($serviceName)) {
            $service = $this->parameterContainer->get($serviceName);
        }
        else {
            $service = $this->resolveService($serviceName);
        }

        return $service;
    }
415983
private function getReflection(string $className) : \ReflectionClass
    {
        if (empty($this->reflectionContainer[$className])) {
            $this->reflectionContainer[$className] = new \ReflectionClass($className);
        }

        return $this->reflectionContainer[$className];
    }
328410
public function getInstance($className)
    {
        switch ($className) {
            case '\\Zepi\\Api\\Rest\\Helper\\FrontendHelper':
                if ($this->frontendHelper === null) {
                    $this->frontendHelper = $this->framework->initiateObject($className);
                }
            
                return $this->frontendHelper;
            break;

            default: 
                return $this->framework->initiateObject($className);
            break;
        }
    }
175751
protected function getWsdlFileName($serviceName)
	{
		if(null === $this->cacheInstance)
		{
			$this->createCacheInstance();
		}
		$cacheAlias = 'WSDL' . $serviceName;
		$fileName = $this->cacheInstance->getFileName($cacheAlias);
		if(!is_file($fileName))
		{
			$this->getWsdlNoCache($serviceName);
		}
		return $fileName;
	}
398414
final protected function api($serviceName = null)
    {
        if ($serviceName !== null) {
            return $this->api->service($serviceName);
        }

        return $this->api;
    }
642800
public function createService($serviceClass)
    {
        $className = $serviceClass;
        if (!$this->isNamespacedClass($serviceClass)) {
            // Used for backwards compatibility.
            $className = $this->formClassName($serviceClass);
        }
        if (!class_exists($className)) {
            throw new Exception("Service '$serviceClass' was not found!");
        }
        $service = new $className($this->getServiceConfig());

        if (!($service instanceof ShopServiceInterface)) {
            throw new Exception("Service '$className' does not implement ShopServiceInterface interface!");
        }

        return $service;
    }
499177
public function get($className) {
        if (!$this->has($className)) {
            $errorMsg = sprintf(self::ERROR_SERVICE_NOT_FOUND, $className);
            throw new ulfberhtException($errorMsg);
        }
        //return service from service cache if it is there
        if (isset($this->_serviceCache[$className])) {
            return $this->_serviceCache[$className];
        }

        return $this->_resolveService($className);
    }
741081
public function singleton( $serviceName ) {

		if (  is_string( $serviceName ) && isset( $this->aliases[$serviceName] ) ) {
			$serviceName = $this->aliases[$serviceName];
		}

		return $this->getReturnValueFromSingletonFor( $serviceName, func_get_args() );
	}
448676
public static function serviceClassname($name)
    {
        $services = static::services();

        if (!isset($services[$name])) {
            throw new \InvalidArgumentException(
                sprintf('The provided service %s does not exist.', $name)
            );
        }

        return $services[$name];
    }
1271939
public function getWsdlNoCache($serviceName)
	{
		if(null === $this->cacheInstance)
		{
			$this->createCacheInstance();
		}
		$ctw = new ClassToWsdl($serviceName,Dispatch::url($this->exec,array('serviceName'=>$serviceName)),$this->wsdlStyle,$this->wsdlUse);
		$result = $ctw->getWsdl();
		$cacheName = 'WSDL' . $serviceName;
		$this->cacheInstance->set($cacheName,$result,array('raw'=>true));
		return $result;
	}
756900
public function getClass($pipelineName = null)
    {
        if (!is_array($this->class)) {
            return $this->class;
        }

        if (isset($this->class[$pipelineName])) {
            return $this->class[$pipelineName];
        }

        return null;
    }
285649
public function get($serviceName) {
        $container = $this->serviceData[$serviceName] ?? NULL;
        if($container) {
            return $container->getInstance();
        }

        if(in_array($serviceName, $this->getSelfReferenceNames()))
            return $this;

        $e = new UnknownServiceException("Service $serviceName is not registered", E_USER_ERROR);
        $e->setServiceName($serviceName);
        throw $e;
    }
42075
public function loadStatus($serviceName, $attributeName) {
        if (isset($this->data[$serviceName][$attributeName])) {
            return $this->data[$serviceName][$attributeName];
        }
        return "";
    }
122659
public function getService($name)
    {
        if (!isset($this->services[$name])) {
            $this->services[$name] = $this->createService($name);
        }
        return $this->services[$name];
    }
655931
public final function get($className)
   {
       try {
           return $this->cache->get(... func_get_args());
       } catch (NotFoundException $e) {
           try {
               $service = $this->resolver->resolve($className, $this->cache);
           } catch (NotFoundException $e) {
               throw $e;
           } catch (ContainerException $e) {
               throw $e;
           }
       }
       $this->cache->set($className, $service);
       return $this->cache->get($className);
   }
745187
protected function loadService($serviceName, $serviceConfig)
    {
        $isSingleton = false;

        if (array_key_exists('singleton', $serviceConfig)) {
            $isSingleton = (bool)$serviceConfig['singleton'];
        }

        $class = $this->activate($serviceName, $serviceConfig);

        if ($isSingleton) {
            // Only store if singleton'ed to spare memory
            $this->registry->set($serviceName, $class);
        }

        $this->inject($class, $serviceConfig);
        $class = $this->encapsulate($class, $serviceConfig);

        return $class;
    }
214484
public function get($serviceName)
    {
        if ($this->registry->has($serviceName)) {
            return $this->registry->get($serviceName);
        }

        $serviceConfig = $this->classes->resolve($serviceName, null);

        if ($serviceConfig == null) {
            throw new \DICIT\UnknownDefinitionException($serviceName);
        }

        try {
            return $this->loadService($serviceName, $serviceConfig->extract());
        }
        catch (\DICIT\UnknownDefinitionException $ex) {
            throw new \RuntimeException(
                sprintf("Dependency '%s' not found while trying to build '%s'.",
                    $ex->getServiceName(), $serviceName));
        }
    }