(non-PHPdoc) @see Resolver::resolve()
553356
public function resolve($reference)
    {
        $reference = substr($reference, 7);
        $method = $this->getMethod($reference);
        $callback = [
            $this->container->resolve($method->getOwner()),
            $method->getName()
        ];

        if ($method->hasArguments()) {
            return function () use($callback, $method)
            {
                return call_user_func_array($callback, $method->extractArguments($this->container, new ArrayResolver()));
            };
        }

        return is_array($callback) ? function () use ($callback) {
            return call_user_func_array($callback, func_get_args());
        } : $callback;
    }
753166
public function resolve()
    {
        if ($this->sourceFile instanceof UploadedFile) {
            $extension = $this->sourceFile->guessExtension();
            $name = preg_filter('/^php(.+)/', '$1', $this->sourceFile->getBasename());
            $this->originalName = $this->sourceFile->getClientOriginalName();
        } else {
            $extension = $this->sourceFile->getExtension();
            $this->originalName = $name = $this->sourceFile->getBasename('.'.$extension);
        }

        $this->setPhysicalFile(
            $this->sourceFile->move(
                $this->storePath,
                sprintf('%s%s.%s',
                    strtolower($name),
                    base_convert(microtime(), 10, 36),
                    $extension
                )
            )
        );

        return parent::resolve();
    }
881567
public function resolve($query)
    {
        $queryClassName = self::findBaseName($query);
    
        if ($query instanceof ICommand) {
            
            if (isset($this->commandHandlers[$queryClassName])) {
                return $this->commandHandlers[$queryClassName];
            }
            
            throw new HandlerNotFoundException($queryClassName);
        }
        
        // if its not a command, then it must be a query
        if (isset($this->queryHandlers[$queryClassName])) {
            return $this->queryHandlers[$queryClassName];
        }
        
        throw new HandlerNotFoundException($queryClassName);
    }
301549
private function resolveOptions(array $options = [])
    {
        $resolver = new OptionsResolver();
        $this->configure($resolver);

        return $resolver->resolve($options);
    }
982497
public function resolve($file)
    {
        $class = Str::studly(implode('_', array_slice(explode('_', $file), 4)));

        return new $class($this->output);
    }
694241
protected function resolve($expr)
    {
        if (\is_array($expr)) {
            foreach ($expr as &$value) {
                if (!is_scalar($value)) {
                    $value = $this->resolve($value);
                }
            }

            return $expr;
        }

        if (\is_object($expr) && $expr instanceof self) {
            return $expr->build();
        }

        return $expr;
    }
792674
protected function resolveOptions(): void
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);
        $this->options = $resolver->resolve($this->options);
    }
263535
function resolve(){
		var args = Array.prototype.slice.call(arguments);
		event.trigger('resolve', args);
	}
216684
public function resolve()
    {
        $this->page
            ->setName($this->name)
            ->setOnline(!empty($this->online))
            ->setTitle($this->title)
            ->setMeta(array('title' => $this->title))
            ->setPath($this->getFullPath())
        ;

        $this->assertEntityIsValid($this->page, array('Page', 'creation'));

        $this->fireEvent(
            PageEvents::PAGE_CREATED,
            new PageEvent($this->page, $this)
        );

        return $this->page;
    }
1085132
public function resolveServices($value)
    {
        if (is_array($value)) {
            foreach ($value as $k => $v) {
                $value[$k] = $this->resolveServices($v);
            }
        } elseif ($value instanceof Reference) {
            $value = $this->get((string) $value, $value->getInvalidBehavior());
        } elseif ($value instanceof Definition) {
            $value = $this->createService($value, null);
        } elseif ($value instanceof Expression) {
            $value = $this->getExpressionLanguage()->evaluate($value, array('container' => $this));
        }

        return $value;
    }
45519
public function resolve($resource, $type = null){
		$resolvingLoader = false;
		foreach($this->loaders as $loader){
			if($loader->supports($resource, $type)){
				$resolvingLoader = $loader;
			}
		}
		if(!$resolvingLoader){
			if(!$type){
				$type = (is_callable($resource))
					? 'closure'
					: pathinfo($resource, PATHINFO_EXTENSION)
				;
			}
			$resolvingLoader = $this->createLoaderForType($type);
		}

		return $resolvingLoader;
	}
822924
protected function resolve( $class )
	{
		$instance = UniversalBuilder::resolveClass( $class );

		if ( isset( $this->command ) )
			$instance->setCommand( $this->command );

		return $instance;
	}
326629
public function resolve($key)
    {
        if (is_array($key)) {
            foreach ($key as $k => $v) {
                $key[$k] = $this->resolve($v);
            }
        } elseif (is_string($key)) {
            $matches = array();
            preg_match_all('/{[\s]*?([^\s]+)[\s]*?}/i', $key, $matches, PREG_SET_ORDER);
            foreach ($matches as $match) {
                if (array_key_exists($match[1], $this->bindings)) {
                    $key = preg_replace('/' . $match[0] . '/', $this->bindings[$match[1]], $key, 1);
                }
            }
        }

        return $key;
    }
763394
public function getResolver()/*# : ParameterInterface */
    {
        if (!$this->hasResolver()) {
            throw new NotFoundException(
                Message::get(Message::PARAM_RESOLVER_MISS),
                Message::PARAM_RESOLVER_MISS
            );
        }
        return $this->resolver;
    }
179033
public function resolve($service)
    {
        if (isset($this->resolved[$service])) {
            return $this->resolved[$service];
        }

        return $this->resolved[$service] = $this->getFunc($service);
    }
1363889
public function resolve()
    {
        if (!empty($this->resolvedParameters)) {
            return $this->attributes;
        }
        $this->evaluateRequirements($this->attributes);
        $this->resolveAllParameters();

        return $this->attributes;
    }
42657
public static function get($resolverClass)
    {
        if (!is_string($resolverClass)) {
            throw new InvalidArgumentException('$resolverClass must be a string.');
        }

        if (!array_key_exists($resolverClass, self::$cache)) {
            if (!class_exists($resolverClass)) {
                throw new InvalidArgumentException(
                    sprintf('Resolver class "%s" is not found.', $resolverClass)
                );
            }

            /** @var OptionsResolver $resolver */
            $resolver = new $resolverClass();
            if (!$resolver instanceof self) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Resolver class "%s" must extend "%s".',
                        $resolverClass,
                        self::class
                    )
                );
            }

            $resolver->configureOptions();

            self::$cache[$resolverClass] = $resolver;
        }

        return self::$cache[$resolverClass];
    }