Gets a parameter by name. If the parameter is undefined, this method will
defer to the service container if available.

{@inheritdoc}
972610
public function get($name)
    {
        $this->initialize();

        if (!isset($this->parameters[$name]) && !array_key_exists($name, $this->parameters)) {
            if ($this->container) {
                return $this->container->getParameter($name);
            }

            return null;
        }

        return $this->parameters[$name];
    }
254611
final public function get(string $name)
    {
        $service_selected = null;
        foreach ($this->services as $one => $val) {
            if ($val['name'] === $name) {
                if (!in_array($val['content']->status, array("enabled", "disabled"))) {
                    throw new Server500(new \ArrayObject(array("explain" =>
                        "Undefined status [ ".$val['content']->status." ] for ".$val['name']." service",
                        "solution" => "Please set the status [disabled] or [enabled]")));
                }
                if ($val['content']->status == "disabled") {
                    throw new Server500(new \ArrayObject(array("explain" =>
                        "The service [ ".$val['name']." ] is currently disabled ",
                        "solution" => "Please set the status [enabled] to enable the service")));
                }
                $i = $val['content']->namespace;
                $container = FrameworkContainer::getInstance();
                return ($container->get($i));
            }
        }

        throw new Server500(new \ArrayObject(array("explain" =>
            "Undefined service : $name", "solution" => "Please register the [$name] service")));
    }
285964
public function getCallable($name)
     {
         if (method_exists($this, $name)) {
             return call_user_func([$this, $name]);
         } else {
             throw new InvalidArgumentException('Undefined property: '.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));
	}
859501
public function get($name,$default=null)
    {

        // Return null if the service is not in the container
        if(!isset($this->instances[$name]))
             return $default;

        if(array_key_exists($name,$this->bind))
            return $this->resolve($name);


        // Check if the service has been resolved in the container
        if(!$this->resolved[$name]){

            $this->instances[$name] = $this->resolve($name);
            

            return $this->instances[$name];
        }

        return $this->resolve($name);
    }
720865
@Override
    public Object getParameterType(String name) {
        if (name.equals(CHECK_RING_SYSTEM))
            return Boolean.TRUE;
        else
            throw new IllegalArgumentException("No parameter for name: " + name);
    }
791563
@Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        if (value == null) {
            value = parameters.get(name);
        }
        return value;
    }
1086665
public function getParameterByName($name)
    {
        foreach ($this->parameters as $parameter) {
            if ($parameter->getName() === $name) {
                return $parameter;
            }
        }

        return null;
    }
1316416
def get_parameter(self, parameter):
        ""
        parameter = self._get_parameter_name(parameter)
        return self._parameters[parameter]
1173328
protected static function getParameterValue(
        ContainerInterface $container,
        $param,
        int $index,
        array $map,
        bool $safe
    ) {
        if ($isReflection = ($param instanceof \ReflectionParameter)) {
            $name = $param->name;
        } elseif (\is_array($param)) {
            $name = $param['name'];
        } else {
            throw new \InvalidArgumentException('Parameter must be the instance of \ReflectionParameter or array');
        }

        if (\array_key_exists($name, $map)) {
            return $map[$name]; // // resolve as user-provided named argument
        }

        if (\array_key_exists($index, $map)) {
            return $map[$index]; // resolve as user-provided positional argument
        }

        $type = $isReflection ? static::getParameterType($param) : $param['type'];

        if ($type) {
            if (\array_key_exists($type, $map)) {
                return $map[$type]; // resolve as user-provided type-hinted argument
            }

            if ($container->has($type)) {
                return $container->get($type); // resolve as component registered by class/interface name
            }
        }

        if ($safe && $container->has($name)) {
            return $container->get($name); // resolve as component with matching parameter name
        }

        if ($isReflection) {
            if ($param->isOptional()) {
                return $param->getDefaultValue(); // unresolved, optional: resolve using default value
            }

            if ($type && $param->allowsNull()) {
                return null; // unresolved, type-hinted, nullable: resolve as NULL
            }

            $reflection = $param->getDeclaringFunction();
            $file = $reflection->getFileName();
            $line = $reflection->getStartLine();
        } elseif (\array_key_exists('default', $param)) {
            return $param['default'];
        } else {
            ['file' => $file, 'line' => $line] = $param;
        }

        // unresolved - throw a container exception:
        throw new \InvalidArgumentException(
            "Unable to resolve parameter: \${$name} " . ($type ? "({$type}) " : '') .
            'in file: ' . $file . ', line ' . $line
        );
    }
758168
public function get($name) {
        if (!isset($this->services[$name])) throw new ServiceNotFoundException('Service "'.$name.'" not found.');
        try {
            return $this->services[$name]->resolve($factory=false);
        }
        catch (\Exception $ex) {
            throw new ContainerException($ex->getMessage(), $ex->getCode(), $ex);
        }
    }
1237707
public function get($name)
    {
        if (!isset($this->parameters[$name])) {
            throw new ParameterNotFoundException("The requested parameter '{$name}' doesn't exist.");
        }

        return $this->parameters[$name];
    }
279109
public function getParameter($name)
    {
        if (isset($this->_parameters[$name])) {
            return $this->_parameters[$name];
        }
        return null;
    }
1335346
public function get($name)
    {
        $selected = null;
        /** @var ElementInterface|ContainerInterface $element */
        foreach ($this as $element) {
            if ($element->getName() == $name) {
                $selected = $element;
                break;
            }

            if ($element instanceof ContainerInterface) {
                $selected = $element->get($name);
                if (null !== $selected) {
                    break;
                }
            }
        }

        return $selected;
    }
706875
public static function get(string $name, ...$params) {
        if (AppContainer::isAutoLoad()) return self::getAutoLoad($name, $params);

        $map = self::getInstance();
        if (!$map->containsKey($name)) {
            return null;
        }
        /** @var Node $node */
        $node = $map->getNodeByKey($name);
        if (null === $node) {
            return null;
        }
        return $node->getValue()($params);
    }
345416
public String getParameter(String name)
    {
        if (!_paramsExtracted) extractParameters();
        return (String) _parameters.getValue(name, 0);
    }
884228
public function get_param($name) {
        if (array_key_exists($name, $this->params)) {
            return $this->params[$name];
        } else {
            return null;
        }
    }