stream_resolve_include_path - PHP code example

The php Function Stream_ResolveInclude_Path

PHP provides a wide array of functions for developers to use. These functions enable you to perform various tasks in a script, and are invaluable tools when it comes to writing efficient code. It's important to know how these function work, so you can avoid getting caught off guard if you ever need to use them on a live project.

Stream functions are a way of generalizing file, network and data compression operations that exhibit streamable behavior. A stream is a resource object that can be read from or written to in a linear fashion, and may also have associated wrappers to handle specific protocols/encodings.

A stream can be configured with a number of options, and these can be specified when it is created by calling stream_context_create(), or later using stream_context_set_option(). The exact set of options that can be configured is dependent on the type of wrapper in use. Once a stream has been configured, if it encounters an error it will report a message and/or severity to the caller.

The php function stream_resolve_include_path resolves a filename against an include path according to the same rules as fopen() and fopen_include(). It then returns the resolved absolute filename if successful, or false on failure.

stream_resolve_include_path example

$_stream_resolve_include_path = function_exists('stream_resolve_include_path');

        // test if all registered template_dir are accessible         foreach($smarty->getTemplateDir() as $template_dir) {
            $_template_dir = $template_dir;
            $template_dir = realpath($template_dir);
            // resolve include_path or fail existance             if (!$template_dir) {
                if ($smarty->use_include_path && !preg_match('/^([\/\\\\]|[a-zA-Z]:[\/\\\\])/', $_template_dir)) {
                    // try PHP include_path                     if ($_stream_resolve_include_path) {
                        $template_dir = stream_resolve_include_path($_template_dir);
                    } else {
                        $template_dir = Smarty_Internal_Get_Include_Path::getIncludePath($_template_dir);
                    }

                    if ($template_dir !== false) {
                        if ($errors === null) {
                            echo "$template_dir is OK.\n";
                        }

                        continue;
                    } else {

$_plugin_dir . $_plugin_filename,
                $_plugin_dir . strtolower($_plugin_filename),
            );
            foreach ($names as $file) {
                if (file_exists($file)) {
                    require_once($file);
                    return $file;
                }
                if ($this->use_include_path && !preg_match('/^([\/\\\\]|[a-zA-Z]:[\/\\\\])/', $_plugin_dir)) {
                    // try PHP include_path                     if ($_stream_resolve_include_path) {
                        $file = stream_resolve_include_path($file);
                    } else {
                        $file = Smarty_Internal_Get_Include_Path::getIncludePath($file);
                    }

                    if ($file !== false) {
                        require_once($file);
                        return $file;
                    }
                }
            }
        }

return false;
        }

        foreach (self::$autoloadNamespaces as $namespace => $dirs) {
            if (strpos($class, $namespace) !== 0) {
                continue;
            }

            $file = str_replace('\\', DIRECTORY_SEPARATOR, $class) . '.php';

            if ($dirs === null) {
                $path = stream_resolve_include_path($file);
                if ($path) {
                    require $path;

                    return true;
                }
            } else {
                foreach ((array) $dirs as $dir) {
                    if (is_file($dir . DIRECTORY_SEPARATOR . $file)) {
                        require $dir . DIRECTORY_SEPARATOR . $file;

                        return true;
                    }

    public static function isReadable($path)
    {
        if (is_readable($path)) {
            return $path;
        }

        return stream_resolve_include_path($path);
    }

    /** * Realpath implementation that is 100% compatible but symlink aware * * @param string $path * * @return string|false */
    public static function realpath($path)
    {

    public static function getIncludePath($filePath)
    {
        static $_include_path = null;

        if (function_exists('stream_resolve_include_path')) {
            // available since PHP 5.3.2             $filePath = strpos($filePath, '.' . DS) === 0 ? substr($filePath, 2) : $filePath;
            return stream_resolve_include_path($filePath);
        }

        if ($_include_path === null) {
            $_include_path = explode(PATH_SEPARATOR, get_include_path());
        }

        foreach ($_include_path as $_path) {
            if (file_exists($_path . DS . $filePath)) {
                return $_path . DS . $filePath;
            }
        }

        }

        // PSR-0 fallback dirs         foreach ($this->fallbackDirsPsr0 as $dir) {
            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
                return $file;
            }
        }

        // PSR-0 include paths.         if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
            return $file;
        }

        return false;
    }
}

/** * Scope isolated include. * * Prevents access to $this/self from included files. * * @param string $file * @return void * @private */