FileCacheClassLoader

Creates new FileCacheClassLoader instance and loads the cache file.

Registers this instance as a class autoloader.

Unregisters this instance as a class autoloader.

Tells if this instance is currently registered as a class autoloader.

Tells whether to use include_path as part of base paths.

When enabled, the directory paths in include_path are treated as base paths where to look for classes. This option defaults to false for PSR-4 compliance.

Sets whether to return values and throw exceptions from loadClass.

PSR-4 requires that autoloaders do not return values and do not throw exceptions from the autoloader. By default, the verbose mode is set to false for PSR-4 compliance.

Sets list of dot included file extensions to use for finding files.

If no list of extensions is provided, the extension array defaults to just '.php'.

Adds a PSR-0 compliant base path for searching classes.

In PSR-0, the class namespace structure directly reflects the location in the directory tree. A base path indicates the base directory where to search for classes. For example, if the class 'Foo\Bar', is defined in '/usr/lib/Foo/Bar.php', you would simply need to add the directory '/usr/lib' by calling:

addBasePath('/usr/lib')

Additionally, you may specify that the base path applies only to a specific namespace. You can do this by adding the namespace as the second parameter. For example, if you would like the path in the previous example to only apply to the namespace 'Foo', you could do so by calling:

addBasePath('/usr/lib/', 'Foo')

Note that as per PSR-0, the underscores in the class name are treated as namespace separators. Therefore 'Foo_Bar_Baz', would need to reside in 'Foo/Bar/Baz.php'. Regardless of whether the namespace is indicated by namespace separators or underscores, the namespace parameter must be defined using namespace separators, e.g 'Foo\Bar'.

In addition to providing a single path as a string, you may also provide an array of paths. It is also possible to provide an associative array where the keys indicate the namespaces. Each value in the associative array may also be a string or an array of paths.

Returns all known base paths.

The paths will be returned as an associative array. The key indicates the namespace and the values are arrays that contain all paths that apply to that specific namespace. Paths that apply to all namespaces can be found inside the key '' (i.e. empty string). Note that the array does not include the paths in include_path even if the use of include_path is enabled.

Adds a PSR-4 compliant prefix path for searching classes.

In PSR-4, it is possible to replace part of namespace with specific path in the directory tree instead of requiring the entire namespace structure to be present in the directory tree. For example, if the class 'Vendor\Library\Class' is located in '/usr/lib/Library/src/Class.php', You would need to add the path '/usr/lib/Library/src' to the namespace 'Vendor\Library' by calling:

addPrefixPath('/usr/lib/Library/src', 'Vendor\Library')

If the method is called without providing a namespace, then the paths work similarly to paths added via addBasePath(), except that the underscores in the file name are not treated as namespace separators.

Similarly to addBasePath(), the paths may be provided as an array or you can just provide a single associative array as the parameter.

Returns all known prefix paths.

The paths will be returned as an associative array. The key indicates the namespace and the values are arrays that contain all paths that apply to that specific namespace. Paths that apply to all namespaces can be found inside the key '' (i.e. empty string).

Loads the class by first checking if the file path is cached.

Attempts to find a file for the given class using known paths.

Loads the class from the given file and stores the path into cache.

Sets the callback used to store the cache.

Whenever a new file location for class is found, the cache handler is called with an associative array containing the paths for different classes. The cache handler should store the array and provide it in the constructor in following requests.

Writes the cache file if changes were made.

Returns the path to the cache file.

Stores the cache to be saved at the end of the request.