@param      $name
@param null $params

@return mixed
@throws IocNotResolvableException
168027
public function resolve($name, $params = null)
    {
        if (!$resolved = $this->resolver->resolve($name, $params)) {
        }

        return $resolved;
    }
884228
public function get_param($name) {
        if (array_key_exists($name, $this->params)) {
            return $this->params[$name];
        } else {
            return null;
        }
    }
277127
public function resolveClass($name, $params = [])
    {
        $reflectionClass = new ReflectionClass($name);

        if (!$reflectionClass->isInstantiable()) {
            throw new Exception("The [ {$name} ] is not instantiable.");
        }

        $constructor = $reflectionClass->getConstructor();

        if (!is_null($constructor)) {
            $dependencies = $constructor->getParameters();

            $resolving = $this->getDependencies($dependencies, $params);

            $instance = $reflectionClass->newInstanceArgs($resolving);

            return $this->resolved[$name] = $this->getInstanceWithAppProperty($instance);
        }

        $instance = new $name;

        return $this->resolved[$name] = $this->getInstanceWithAppProperty($instance);
    }
664573
public function getParam($name){
        if(isset($this->getParams[$name])){
            return $this->getParams[$name];
        }else{
            return NULL;
        }
    }
547288
private function getService(string $name, array $params = []): ?IService
    {
        if (array_key_exists($name, $this->servicesInstances)) {
            return $this->servicesInstances[$name];
        }

        $serviceConfig = $this->getServiceConfig($name);
        if ($serviceConfig === null) {
            return null;
        }

        $class = $serviceConfig['class'];
        unset($serviceConfig['class']);
        $serviceConfig = array_merge($serviceConfig, isset($params[0]) && \is_array($params[0]) ? $params[0] : []);

        if (!class_exists($class)) {
            throw new InvalidConfigException(sprintf('Class %s does not exists', $class));
        }

        if (\is_subclass_of($class, BaseModelService::class)
            || \is_subclass_of($class, BaseControllerService::class)
        ) {
            $service = new $class($this, $serviceConfig);
        } else {
            $service = new $class($serviceConfig);
        }

        if (!($service instanceof IService)) {
            throw new InvalidConfigException('Service class must implement `' . IService::class . '`.');
        }

        return $this->servicesInstances[$name] = $service;
    }
758647
public function getParameter($name): ?Parameter
    {
        /** @var Parameter $parameter */
        foreach ($this->parameters as $parameter) {
            if ($parameter->getKey() === $name) {
                return $parameter;
            }
        }

        return null;
    }
843277
public function getParams($name=NULL) {
		if(!isset($this->payload['params'])) {
			return NULL;
		}
		$params = $this->payload['params'];
		if(isset($name)) {
			if(isset($params[$name])) {
				return $params[$name];
			}
		} else {
			return $params;
		}
		return NULL;
	}
1237707
public function get($name)
    {
        if (!isset($this->parameters[$name])) {
            throw new ParameterNotFoundException("The requested parameter '{$name}' doesn't exist.");
        }

        return $this->parameters[$name];
    }
1168524
public function toRoute($name, array $params = [])
    {
        $url = $this->getUrl()->fromRoute($name, $params);

        return $this->toUrl($url);
    }
714085
public function __callResolver(string $name, array $args)
    {
        //get the handler
        $handler = $this->getResolverHandler();

        //can it be resolved?
        if ($handler->canResolve($name)) {
            //is it shared ?
            if ($handler->isShared($name)) {
                //resolve the shared
                return $this->resolveShared($name, ...$args);
            }

            //resolve it the regular way
            return $this->resolve($name, ...$args);
        }

        //oops ?
        throw ResolverException::forMethodNotFound(get_class($this), $name);
    }
834529
public function getParameter($name)
	{
		if(array_key_exists($name, $this->parameters))
		{
			return $this->parameters[$name];
		}
		
		if(func_num_args() > 1)
		{
			return func_get_arg(1);
		}
		
		throw new ContextParamNotFoundException(sprintf('Container parameter "%s" was not found', $name));
	}
1020851
public function bind($name,$params) 
    {

        $this->instances[$name] = $params;
        $this->bind[$name] = true;

    }
849658
public function make($name, array $params = array(), $force = false)
    {
        if (isset($this->_ioc[$name])) {

            // If a singleton instance exists, return it
            if ($this->_ioc[$name]['instance'] && !$force)
                return $this->_ioc[$name]['instance'];

            // Include an instance of this object as the final argument
            $params[] = $this;

            // Call the stored container
            $result = call_user_func_array($this->_ioc[$name]['closure'], $params);

            // If this is supposed to be a singleton, store it
            if ($this->_ioc[$name]['singleton'])
                $this->_ioc[$name]['instance'] = $result;

            return $result;
        }

        return null;
    }
523588
public function getGet($name = null)
    {
        if ($name !== null) {
            return isset($this->getParams[$name]) ? $this->getParams[$name] : null;
        }

        return $this->getParams;
    }
367453
public static function url($name, array $params = null, $protocol = null)
    {
        $route = Route::get($name);
        return $route->isExternal()
            ? $route->uri($params)
            : Url::site($route->uri($params), $protocol);
    }
1370588
public function resolve($name)
        {
            if (!isset(self::$resources[$name])) {
                throw new Exception("[$name] is not a known resource.");
            }

            return isAke(self::$resources, $name);
        }
684768
public function resolveByName($name)
    {
        $detectedAdapter = $this->detectByName($name);

        if ($detectedAdapter === null) {
            $exception = EnvironmentAdapterNotFoundException::createByName($name);
            throw $exception;
        }

        return $detectedAdapter;
    }