Resolve a path to a render engine

@param   string $path

@return  IEngine
541560
public function resolve(string $path): IEngine
    {
        if ($this->cache === null) {
            $this->cache = [];
            foreach ($this->engines as $engine) {
                $this->cache[] = $engine[0]($this->renderer);
            }
        }

        foreach ($this->cache as $engine) {
            if ($engine->canHandle($path)) {
                return $engine;
            }
        }

        return $this->renderer->getDefaultEngine();
    }
413383
public function resolve(
        AbsolutePathInterface $basePath,
        PathInterface $path
    ) {
        if ($path instanceof AbsolutePathInterface) {
            return $path;
        }
        if ($path instanceof RelativeWindowsPathInterface) {
            if ($path->isAnchored()) {
                return $path->joinDrive($basePath->drive());
            }
            if ($path->hasDrive() && !$path->matchesDrive($basePath->drive())) {
                return $path->toAbsolute();
            }
        }

        return $basePath->join($path);
    }
665643
protected function prepare($path)
    {
        foreach ($this->paths as $type => $pathValue) {
            if ($pathValue instanceof pathmanager\FallbackInterface) {
                $pathValue = $pathValue->resolve('');
            }

            $path = str_replace('{{'.$type.'_dir}}', $pathValue, $path);
        }

        return $path;
    }
963019
public function cover(string $path): DriverInterface
    {
        return new Adapters\Cover(
            $this,
            $this->imagePath($path)
        );
    }
1274321
protected function resolveTemplatePath($path) {
		switch ($path[0]) {
		case '/':
			break;
		case '.':
			$path = realpath(dirname($this->template) . '/' . $path . '.phtml');
			break;
		default:
			$path = realpath($this->pathService->getTemplatesPath() . '/' . $path . '.phtml');
			break;
		}

		if ($path === false) {
			throw new NotFoundException($this->template . ' file not found');
		}

		return $path;
	}
1041455
public function resolve($path)
    {
        $path = str_replace('/', '.', preg_replace('/\/:\w+/', '', $path));

        $finder = $this->container['view.finder'];

        try {
            $finder->find($path);
        } catch (InvalidArgumentException $e) {
            $explodedPath = explode('.', $path);


            if ($explodedPath[0] === 'static') {
                return null;
            }

            if (count($explodedPath) > 1) {
                $explodedPath[0] = 'shared';
                $explodedPath = array('shared', end($explodedPath));
                try {
                    $finder->find(implode('.', $explodedPath));
                    $path = implode('.', $explodedPath);
                } catch (InvalidArgumentException $e) {
                    $this->app->error($e);
                }
            }
        }

        return $path;
    }
475286
public function get(string $path): ViewInterface
    {
        if (!empty($this->cache) && $this->cache->has($this->context, $path)) {
            return $this->cache->get($this->context, $path);
        }

        $view = $this->findEngine($path)->get($path, $this->context);

        if (!empty($this->cache)) {
            $this->cache->set($this->context, $path, $view);
        }

        return $view;
    }
1097357
private function resolveStylesheetUrl($path){
        $websource = WebsourceManager::singleton()->getWebsource($this->get(ThemeRegistry::WEBSOURCE));
        if(strpos($path , ThemeRegistry::WEBSOURCE) === 0) {
                return $websource->getAccessUrl(substr($path, strlen(ThemeRegistry::WEBSOURCE)));
        }
        else {
            $assetService = $this->getServiceManager()->get(AssetService::SERVICE_ID);
            return $assetService->getAsset($path);
        }
    }
1255915
public function resolve($path)
    {
        return $this->service->getObjectUrl(
            $this->bucket,
            ltrim($this->baseDir . '/' . ltrim($path, '/'), '/')
        );
    }
410005
public function getVisibility($path)
    {
        [$prefix, $path] = $this->getPrefixAndPath($path);

        return $this->getFilesystem($prefix)->getVisibility($path);
    }
1143983
public function resolvePath($path)
    {
        if ($path[0] == '/') {
            throw new \InvalidArgumentException('Cannot resolve absolute path.');
        }

        $segments = $this->getPathSegments();
        if (!empty($segments)) {
            // Remove the last segment for relative paths.
            array_pop($segments);
        }
        $path = trim($path, '/');
        foreach (explode('/', trim($path, '/')) as $segment) {
            if ($segment == '.') {
                continue;
            }
            elseif ($segment == '..' && !empty($segments) && end($segments) != '..') {
                array_pop($segments);
            }
            else {
                $segments[] = $segment;
            }
        }

        return implode('/', $segments);
    }
557928
protected function getDestenationPath($path)
    {
        if (!empty($path)) {
            $path = Helpers::getPathWithSlash($path);
        }

        return Config::getViewsPath() . $path;
    }
333675
public function buildAssetUrl(string $path) : string {
        return starts_with($path, '//') ? $path : $this->app['url']->asset($path);
    }
629827
public function processPath($path)
    {
        $path = $this->replaceDoubleOpeningBrackets($path);
        $path = $this->convertSingleOpeningSquareBracketsToPipes($path);
        $path = $this->replaceBracketEscapeSequenceWithSingleOpeningBrackets($path);
        $this->constructPathNameLexer();
        $path = $this->templateRenderer->renderString($path);
        $this->restoreOriginalLexer();
        $path = $this->removeUnwantedCharactersFromString($path);

        return $path;
    }
240604
public static function resolve($path)
    {
        if (empty($path)) {
            return false;
        }

        $path = Uri::canonpath($path);

        if ($path . '/' === self::path() || strpos($path, self::path()) === 0) {
            return $path;
        }

        return self::path() . $path;
    }
904443
function requireAsset($path)
    {
        $resolvedPath = $this->resolve($path);

        if (null === $resolvedPath) {
            throw new \UnexpectedValueException("Asset $path not found");
        }

        $asset = $this->environment->find($resolvedPath);

        if (!in_array($resolvedPath, $this->requiredPaths)) {
            $this->dependOn($resolvedPath);

            $processors = is_callable(array($asset, "getProcessors")) ? $asset->getProcessors() : array();

            $this->dependencyAssets[] = $this->evaluate($resolvedPath, array(
                "processors" => $processors
            ), $path);

            $this->requiredPaths[] = $resolvedPath;
        }

        return $this;
    }
1263065
protected function resolvePath($path)
    {
        $parts = explode('.', $path);
        $settings = $this->settings;
        foreach ($parts as $part) {
            if (!isset($settings[$part])) {
                return null;
            }
        
            $settings = $settings[$part];
        }
        
        return $settings;
    }