Resolve the given binding.

@param string $binding The binding to resolve.

@return mixed The results of invoking the binding callback.
339873
public function resolve($binding)
    {
        $rawObject = $this->getRaw($binding);

        // If the abstract is not registered, do it now for easy resolution.
        if (is_null($rawObject)) {
            // Pass $binding to both so it doesn't need to check if null again.
            $this->bind($binding, $binding);

			$rawObject = $this->getRaw($binding);
        }

        return $rawObject($this);
    }
206916
protected function resolveCallable($callable)
    {
        if (!$this->container instanceof ContainerInterface) {
            return $callable;
        }

        /** @var CallableResolverInterface $resolver */
        $resolver = $this->container->get('callableResolver');

        return $resolver->resolve($callable);
    }
676739
protected function resolveHandlerAndMethod($handler)
    {
        list ($handler, $method) = array_pad(explode('@', $handler), 2, null);

        return [$handler, $method];
    }
1311058
public function getRaw($binding)
    {
        if (isset($this->bindings[$binding])) {
            return $this->bindings[$binding];
        } elseif (isset($this->parent)) {
            return $this->parent->getRaw($binding);
        }

        return null;
    }
179033
public function resolve($service)
    {
        if (isset($this->resolved[$service])) {
            return $this->resolved[$service];
        }

        return $this->resolved[$service] = $this->getFunc($service);
    }
892481
protected function compileFactoryBinding(Binding $binding)
	{
		$code = '';
		$target = $binding->getTarget();
		
		$call = '$this->callFactoryMethod(' . var_export($binding->getTypeName(), true);
		$call.= ', $this->get(' . var_export($target[0], true);
		$call .= '), ' . var_export($target[1], true);
		
		$resolvers = (array)$binding->getResolvers();
		
		if(empty($resolvers))
		{
			$call .= ', NULL';
		}
		else
		{
			$call .= ', [';
			$i = 0;
				
			foreach($resolvers as $name => $resolver)
			{
				if($i++ != 0)
				{
					$call .= ', ';
				}
		
				$call .= var_export($name, true) . ' => ';
		
				if($resolver instanceof \Closure)
				{
					$num = count($this->methods);
						
					$ref = new \ReflectionFunction($resolver);
					$sig = $this->generateReplacementMethodSignature($ref, $num);
					$body = $this->extractClosureCode($ref);
						
					$this->methods[] = "\t\t" . $sig . " {\n" . $body . "\n\t\t}";
						
					$call = $this->generateCallCode($binding->getTypeName(), $ref, $num);
						
					$call .= 'function() { return ' . $call . '; }';
						
					continue;
				}
		
				$call .= var_export($resolver, true);
			}
				
			$call .= ']';
		}
		
		$call .= ', $point)';
		
		$setterInjection = $binding->isMarked(SetterInjection::class);
		$initializers = (array)$binding->getInitializers();
		
		if(empty($initializers) && !$setterInjection)
		{
			$code .= "return \$this->initialize(" . $call . ");\n";
		}
		else
		{
			$code .= "\$obj = \$this->initialize(" . $call . ");\n";
				
			if($setterInjection)
			{
				$code .= "\t\t" . $this->compileSetterInjector($binding, false) . "\n";
			}
				
			foreach($initializers as $initializer)
			{
				$num = count($this->methods);
					
				$ref = new \ReflectionFunction($initializer);
				$sig = $this->generateReplacementMethodSignature($ref, $num);
				$body = $this->extractClosureCode($ref);
					
				$this->methods[] = "\t\t" . $sig . " {\n" . $body . "\n\t\t}";
		
				$code .= "\t\t\$obj = " . $this->generateCallCode($binding->getTypeName(), $ref, $num, ['$obj']) . " ?: \$obj;\n";
			}
				
			$code .= "\t\treturn \$obj;\n";
		}
		
		return $code;
	}
206408
public function render(Bound $bound)
    {
        $arguments = [];
        $formatter = $this->getFormatter();

        if (!$bound->hasExtendables() && $bound->hasCoordinates()) {
            $arguments[] = $bound->getSouthWest()->getVariable();
            $arguments[] = $bound->getNorthEast()->getVariable();
        }

        return $formatter->renderObjectAssignment($bound, $formatter->renderObject('LatLngBounds', $arguments));
    }
336448
protected function resolveBinding($key, $value, $callbackParameters)
    {
        $newValue = $this->resolveExplicitBindingIfPossible($key, $value);

        return $newValue === $value ? $this->resolveImplicitBindingIfPossible(
            $key, $value, $callbackParameters
        ) : $newValue;
    }
1313322
protected function resolveBinding($key, $value)
    {
        // Explicit binding
        if (isset($this->bindings[$key])) {
            list($binder, $errorHandler) = $this->bindings[$key];

            $callable = $this->getBindingCallable($binder, $value);

            return $this->callBindingCallable($callable, $value, $errorHandler);
        }

        // Implicit binding
        foreach ($this->implicitBindings as $binding) {
            $class = $binding['namespace'] . '\\' . $binding['prefix'] . ucfirst($key) . $binding['suffix'];

            if (class_exists($class)) {
                $instance = $this->resolveClass($class);

                // If special method name is defined, use it, otherwise, use the default
                if ($method = $binding['method']) {
                    $callable = [$instance, $method];
                } else {
                    $callable = $this->getDefaultBindingResolver($instance, $value);
                }

                return $this->callBindingCallable(
                    $callable,
                    $value,
                    $binding['errorHandler']
                );
            }
        }

        // Return the value unchanged if no binding found
        return $value;
    }
383705
private function cleanup($bind)
    {
        if (!is_array($bind)) {
            if (!empty($bind))
                $bind = array($bind);
            else
                $bind = array();
        }
        return $bind;
    }
143771
public function resolve($reference)
    {
        $parts = explode('?:', $reference, 2);

        for ($index = 0; $index < count($parts); $index++) {
            try {
                return $this->resolver->resolve(trim($parts[$index]));
            }
            catch (UnknownDefinitionException $exception) {
                continue;
            }
        }

        return null;
    }
739504
protected function resolve($writer)
    {
        $resolver = 'resolve' . ucwords(gettype($writer)) . 'Writer';

        if (method_exists($this, $resolver) && $resolved = $this->{$resolver}($writer)) {
            return $resolved;
        }

        $this->handleUnknownWriter($writer);
    }
155805
protected function getBindings(string $event) {
        if (!isset($this->bindings[$event]) || !is_array($this->bindings[$event])) {
            return [];
        }
        return $this->bindings[$event];
    }
168027
public function resolve($name, $params = null)
    {
        if (!$resolved = $this->resolver->resolve($name, $params)) {
        }

        return $resolved;
    }
114919
public function resolve($event)
    {
        if ($event instanceof FilterUserResponseEvent) {
            return $this->getEventDetailsArray($event->getUser()->getUsername());
        }

        return null;
    }
1067948
private function resolve($definition)
    {
        return !is_null($this->resolver) ? $this->resolver->resolve($definition) : $definition;
    }
598667
public function resolve($name)
    {
        $name = array_key_exists($name, $this->aliasMap) ? $this->aliasMap[$name] : $name;

        return $this->a->resolve($name);
    }