@param string $serviceUtilClassName

@return $this
977964
public function setServiceUtilClassName($serviceUtilClassName)
    {
        $this->serviceUtilClassName = (string)$serviceUtilClassName;
        $this->serviceUtil = null;

        return $this;
    }
923038
public function getService($serviceClass)
    {
        $dfpServices = new DfpServices();

        $session = $this->session();

        return $dfpServices->get($session, $serviceClass);
    }
1242198
public final function set(string $className, $value): CacheInterface
   {
       $this->service[$className] = $value;
       return $this;
   }
843669
public function persistService($serviceName, $isPermanent = false)
    {
        $service = $this->grabService($serviceName);
        $this->persistentServices[$serviceName] = $service;
        if ($isPermanent) {
            $this->permanentServices[$serviceName] = $service;
        }
        if ($this->client) {
            $this->client->persistentServices[$serviceName] = $service;
        }
    }
1050766
function withServices(array $services) {
        foreach ($services as $method => $type) {
            $this->bind($method, $type);
        }
        return $this;
    }
1179410
public function setService()
    {
        $serviceData = $this->getConfig('service.' . $this->service);
        foreach ($serviceData as $key => $value) {
            Arr::set($this->serviceData, $key, $value);
        }
        Arr::forget($this->configData,'service');
        return $this;
    }
138205
private function _instanciateService($className, $resolvedDependencies) {
        $service = $this->_services[$className];
        switch ($service->constructorType) {
            case (serviceWrapper::SINGLETON_CONSTRUCTOR):
                if (!isset($this->_serviceCache[$className])) {
                    $classDef = $service->classDef;
                    $this->_serviceCache[$className] = $classDef->newInstanceArgs($resolvedDependencies);
                }
                return $this->_serviceCache[$className];
            case (serviceWrapper::FACTORY_CONSTRUCTOR):
                $classDef = $service->classDef;
                return $classDef->newInstanceArgs($resolvedDependencies);
        }
    }
875174
public function setService($service)
    {
        Service::isValid($service);

        $this->service = $service;

        if ($service === Service::EP) {
            $this->set(Config::T200, 'T13');
            $this->set(Config::T206, $service);
        } elseif ($service === Service::SHD || $service === Service::FDF) {
            $this->set(Config::T200, $service);
            $this->set(Config::T750, Service::getLabel($service));
        }

        return $this;
    }
702337
public function setClass($classname) {
		$this->class      = trim($classname, '\\');
		$this->reflection = null;
		
		$this->reset();
		
		return $this;
	}
1310810
public function createService($serviceType)
    {
        $class = sprintf('%s\services\%s', __NAMESPACE__, ucwords($serviceType));
        if (class_exists($class)) {
            $handler = new $class($this);
            return $handler;
        } else {
            throw new Exception("Unknown service: $serviceType");
        }
    }
328516
public function setUserClass(string $classname)
    {
        if (!class_exists($classname) || !is_subclass_of($classname, UserInterface::class))
            throw new DomainException("Invalid user class: $classname");
        $this->user_class = $classname;
        return $this;
    }
307906
public function setInServiceRoute($inServiceRoute)
    {
        if (!is_bool($inServiceRoute)) {
            throw new \InvalidArgumentException(
                __CLASS__ . ' ' . __METHOD__ . ': Not a boolean'
            );
        }

        $this->inServiceRoute = $inServiceRoute;

        return $this;
    }
888912
public function setServiceLocator(ServiceLocatorInterface $serviceLocator)
    {
        /** @var ServiceManager $serviceLocator */
        $this->serviceManager = $serviceLocator;
        $this->serviceManager->setAllowOverride(true);
        $this->setPluginManager($serviceLocator);

        return $this;
    }
1022944
public function createService(ServiceLocatorInterface $serviceLocator)
    {
        $className = $this->getClassName();
        $keyName   = $this->getKeyName();
        $config    = $serviceLocator->get('config');
        $options   = isset($config[$keyName]) ? $config[$keyName] : [];
        return new $className($options);
    }
751602
public function setName(string $name) : Application
    {
        $service = $this->getService();
        $service->setName($name);
        $this->name = $service->getName();
        return $this;
    }
389191
public function get($serviceClassName)
    {
        if (false === $this->hasBeenInitialized) {
            throw new InitializationNotSetException(
                'You can get a service instance only when the service factory has been initialized.',
                1456419587
            );
        }

        if (false === $this->has($serviceClassName)) {
            throw new EntryNotFoundException(
                'The service "' . $serviceClassName . '" was not found in this service factory. Attach it before trying to get it!',
                1456419653
            );
        }

        return $this->serviceInstances[$serviceClassName];
    }
619972
static public function create(ServiceLocator $serviceLocator, $requestedClass, array $options = null)
    {
        if (class_exists($requestedClass)) {
            $reflection = new \ReflectionClass($requestedClass);

            $arguments = [];
            $constructor = $reflection->getConstructor();
            if ($constructor) {
                $constructorParams = $reflection->getConstructor()->getParameters();

                if (count($constructorParams) == 0) {
                    return new $requestedClass;
                } else {

                    foreach ($constructorParams as $param) {
                        $class = $param->getClass();

                        $argument = null;
                        if ($class) {
                            $argument = $serviceLocator->get($class->getName());

                            // The Service Locator itself is not in the SL, so checking for it explicitly
                            if ($class->getName() == ServiceLocator::class) {
                                $argument = $serviceLocator;
                            }
                        }

                        if ($argument == null && $serviceLocator->has($param->getName())) {
                            $argument = $serviceLocator->get($param->getName());
                        }

                        if (!$param->isOptional() && $argument == null) {
                            throw new \RuntimeException('Missing required argument "' . $param->getName() . '" for class "' . $requestedClass);
                        }

                        if ($param->isOptional() && $argument == null) {
                            $arguments[$param->getName()] = $param->getDefaultValue();
                        } else {
                            $arguments[$param->getName()] = $argument;
                        }
                    }
                }
            }

            $instance = $reflection->newInstanceArgs($arguments);
            return $instance;
        }

        throw new \RuntimeException('Cannot find class ' . $requestedClass);
    }