@param      $name
@param null $params

@return mixed
349280
public function resolve($name, $params = null)
    {
        if ($registered = $this->provider->hasProvider($name)) {

            if (!is_object($registered) && !is_callable($registered)) {
                $registered = $this->provider->make($registered, $params);
            }

            if ($this->provider->isProvider($registered)) {
                return $registered->resolve($params);
            }

            return $registered;
        }

        return $this->provider->make($name, $params);
    }
408892
public function callExtension($name, array $params = [])
    {
        $extension = $this->getExtension($name);

        // call_user_func_array seems to be slow
        switch (count($params)) {
            case 0:
                $result = call_user_func($extension);
                break;
            case 1:
                $result = call_user_func($extension, $params[0]);
                break;
            case 2:
                $result = call_user_func($extension, $params[0], $params[1]);
                break;
            case 3:
                $result = call_user_func($extension, $params[0], $params[1], $params[2]);
                break;
            case 4:
                $result = call_user_func($extension, $params[0], $params[1], $params[2], $params[3]);
                break;
            default:
                $result = call_user_func_array($extension, $params);
                break;
        }

        $this->callListeners($name, $result);

        return $result;
    }
305947
public static function load($params = null)
    {
        if (!isset(self::$_instance)) {
            self::$_instance = new Auth($params);
        }

        return self::$_instance;
    }
695527
protected function getParam($name)
    {
        if (!isset($this->params[$name])) {
            throw new \InvalidArgumentException("Param is not valid: ".$name);
        }

        return $this->params[$name];
    }
323753
public function param($name)
    {
        $params = $this->params();
        if (isset($params[$name])) {
            return $params[$name];
        } else {
            return null;
        }
    }
995872
protected function getSymfonyFormFromParams($params, $name, $throwException = false)
    {
        $sfForm = $this->getParam($params, $name);

        if (null === $sfForm && false === $throwException) {
            return null;
        }

        if (!$sfForm instanceof SymfonyForm) {
            throw new \InvalidArgumentException(
                sprintf(
                    "%s parameter must be an instance of " .
                    "\Symfony\Component\Form\Form, instance of %s found",
                    $name,
                    is_object($sfForm) ? get_class($sfForm) : gettype($sfForm)
                )
            );
        }

        return $sfForm;
    }
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;
    }
472717
public function getConnection(string $name=null, array $params=[])
  {
    # Find the connection - null if it's not created
    $connection = $this->findConnection($name);

    if (\is_null($connection)) {
      # Create the connection
      $connection = $this->createConnection($name, $params);

      if (!\is_null($connection)) {
        $this->addConnection($connection);
      }
    }

    return $connection;
  }
279109
public function getParameter($name)
    {
        if (isset($this->_parameters[$name])) {
            return $this->_parameters[$name];
        }
        return null;
    }
935660
public function getParam($paramName)
    {
        return !empty($this->_params[$paramName]) ? $this->_params[$paramName] : NULL;
    }
1130607
public function generate($name, ...$params)
    {
        return (new Builder($this->callbacks))
            ->call($name, $params)
            ->toArray();
    }
665286
public function getParam($paramName)
    {
        if (isset($this->params[$paramName]))
            return $this->params[$paramName];
        else
            return null;
    }
145210
public function getParam($name)
    {
        if ( ! is_string($name) || ! isset($this->data[$name])) {
            return null;
        }

        return $this->data[$name];
    }
1332218
protected function getParamFromRequest($name)
    {
        if (null !== $value = $this->requestStack->getCurrentRequest()->get($name)) {
            return $value;
        }

        if ((null !== $request = $this->requestStack->getParentRequest()) && null !== $value = $request->get($name)) {
            return $value;
        }

        if ((null !== $request = $this->requestStack->getMasterRequest()) && null !== $value = $request->get($name)) {
            return $value;
        }

        return null;
    }
58289
public function getParameter($name)
    {
        $key = strtolower($name);

        if (isset($this->parameters[$key])) {
            return $this->parameters[$key];
        }

        return null;
    }
1185287
public function getParameter($paramName) {
		if(isset($this->params[$paramName])) {
					return $this->params[$paramName];
		}
		return null;
	}
855862
public function get(string $name, ...$params) {
        if ($this->created->containsKey($name)) return $this->created->getNodeByKey($name)->getValue();
        if ($this->instances->containsKey($name)) return $this->fromInstances($name, $params);

        try {
            $reflectionClass = new ReflectionClass($name);
            $constructor = $reflectionClass->getConstructor();
            $parameters = [];

            if (null !== $constructor) {
                /** @var ReflectionParameter $parameter */
                foreach ($constructor->getParameters() as $parameter) {
                    $className = $parameter->getClass()->getName();
                    $class = $this->get($className);
                    if (null === $class) throw new ClassNotFoundException();
                    $parameters[] = $class;
                }
            }
            $clazz = $reflectionClass->newInstanceArgs($parameters + $params);
            $this->created->add($name, $clazz);
            return $clazz;
        } catch (Exception $exception) {
            return null;
        }
    }