Hi Marcus,
"Marcus Boerger" <[EMAIL PROTECTED]> wrote in message
news:[EMAIL PROTECTED]
>
> > 3) Simply pass an extra argument (or pass an array or object as the
first
> > argument) to __autoload containing the names of the imported namespaces
of
> > the calling file. __autoload can then use this array against the class
name
> > and perform its own lookup.
>
> None of the above makes any sense. Look __autoload() is just bein called
at
> any place where a class is missing. So looking for the file first and then
> loading __autoload(I) makes no sense whatsoever. IMO what we need here is
a
> default implementation for import behavior accomplished by __autoload().
So
> for example "import ns:cls;" leads to "__autoload('ns:cls')". Here the SPL
> default implementation would relpace all ':' with the directory divider
'/'
> or '\', append '.inc' or '.php' or '.inc.php' and append the result to all
> directories in the include_path to look for the file. If were are to
support
> import with '*' the the autoload implementation would need to take care of
> this and load all matching files. A user land implementation can easily
> achieve that by using SPLs (Recursive)DirectoryIterator and
FilterIterator.
>
Regarding a fully-specified class import, such as ns:cls, if I simply remove
my include logic, then __autoload('ns:cls') would automatically be called.
There are no issues with this type of import.
Now, namespace imports (wildcard imports) are a different story. Maybe I did
not make my explanations clear enough, but you basically agreed to point #3
in my previous email. Now, the class name cannot simply be passed to
__autoload, because there is no way for __autoload to know to which
namespace the class belongs to, and you only want __autoload to include the
classes belonging to the namespaces that have been imported. That is why the
list of imported namespaces for the __calling__ file must be accessible
somehow to the __autoload function, either as an additional argument or by
having the first argument be an array/object.
So the namespace imports will work like how you described simple imports,
but with a slight twist. To quote you:
"Simple" Imports
----------------
> So for example "import ns:cls;" leads to "__autoload('ns:cls')". Here the
SPL
> default implementation would relpace all ':' with the directory divider
'/'
> or '\', append '.inc' or '.php' or '.inc.php' and append the result to all
> directories in the include_path to look for the file.
By slightly modifying your sentence, we implement namespace imports:
Namespace Imports
-----------------
Here the SPL default implementation would, in a loop, prefix the class name
with each imported namespace, replace all ':' with the directory divider '/'
or '\', append '.inc' or '.php' or '.inc.php' and append the result to all
directories in the include_path to look for the file.
For example, here is how the userland __autoload might look (notice that
this code is exactly what I provided in the last post). In this example, the
user has the directory structure as "namespace-name/class-name.php".
<?php
function __autoload($className, $importNamespaces)
{
$paths = explode( PATH_SEPARATOR, get_include_path() );
foreach( $paths as $path )
{
foreach( $importNamespaces as $ns )
{
$fullPath = $path . DIRECTORY_SEPARATOR . str_replace( ':',
DIRECTORY_SEPARATOR, $ns ) . DIRECTORY_SEPARATOR . $className . '.php';
if( file_exists( $fullPath ) )
{
require_once( $fullPath );
break;
}
}
}
}
?>
Let me know if the above make sense or if you see any problems with this
approach.
--
Jessie
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
