I hate puting the namespece in a class names so it is OK to do have import() instrument. I also have a core folder where I put basic classes which are loaded default bu autoload

I had my own library that has lots of features from Java. And “import” is one of primary features.

In real life use, I’ve split to different method as follow :

class Tine {
static function importClass( $class )
{
$class_path = trim( strtr( $class, ‘.*’, ‘/ ‘ ) );
$class_name = strtolower( basename( $class_path ) );
$class_path = TINE_CLASS_PATH . ‘/’ . $class_path . ‘.php’;
if ( file_exists( $class_path ) && is_file( $class_path ) && !class_exists( $class_name ) )
{
require( $class_path );
}
}

static function importPackage( $package )
{
$class_path = TINE_CLASS_PATH . ‘/’.trim( strtr( $package, ‘.*’, ‘/ ‘) );
self::importFiles( $class_path );
}

static function importFiles( $folder, $create_instance = false )
{
if ( file_exists( $folder ) && is_dir( $folder ) )
{
$append = substr( $folder, -1, 1 ) == ‘/’ ? ” : ‘/’;
$handle = opendir( $folder );
if ( is_resource( $handle ) )
{
while ( true == ( $file = readdir( $handle ) ) )
{
$full_file = $folder . $append . $file;
if ( is_file( $full_file ) )
{
$res = null;
$ext = substr( $file, -4, 4 );
$class_name = substr( $file, 0, -4 );
if ( 0 == strcasecmp( $ext, ‘.php’ ) )
{
$class_exists = class_exists( $class_name );
if ( !$class_exists )
{
require( $folder . $append . $file );
}
if ( $create_instance && $class_exists )
{
new $res[1];
}
}
}
}
closedir( $handle );
}
return;
}
}

static function importFolder( $folder, $create_instance = false )
{
self::importFiles( $folder, $create_instance );
}

static function importFile( $file, $once = true )
{
if( $once )
require_once( $file );
else
require( $file );
}

static function import($class)
{
$class = str_replace( ‘ ‘, ”, $class );
$pos = strpos( $class, ‘/’ );
if ( $pos === false )
{
if ( $class{ strlen( $class ) – 1 } == ‘*’ )
self::importPackage( $class );
else
self::importClass( $class );
}
else
{
if ( is_dir( $class ) )
self::importFiles( $class );
else
self::importFile( $class );
}
}
}

Most of application developped for my clients, use more than 100 classes. So to gain performance, I've found a little way to load faster : As the main goal is to load fewer files, i use a import tracker to generate a file containing most imported files, something like:

static function trackFile( $path ) {
if ( defined('TINE_CLASS_TRACKER') && file_exists( $path ) ) {
global $trackers; $trackers[ $path ] = md5_file( $path );
}
}


Also, it might also be worth looking into SPL autoloaders rather than the vanilla __autoload magic if you’re not familiar with them. You could write specific functions that load classes from well known file system hierarchies, thus eliminating the need for an “import” kinda thing, but still being able to maintain the java-like package structure you enjoy. The nice thing about SPL auto loaders is that you can define as many as you want, and PHP will execute all the autoloaders you’ve defined and registered before throwing up a class doesn’t exist error (to put it crudely). They’re also faster than regular ol’ __autoload, so there’s no huge penalty (outside filesystem access) for using them

That’s my 2 cents

I think the question Topbit raises (though it was not stated this plainly), is why is this necessary or even desirable, given that we already have Autoload.

I’m not saying it is or isn’t, I’d just like to see if there’s an answer. I’m curious, but I need to understand the utility of your concept.

It’s AutoLoading, as demonstrated with such tools as Zend_Loader, part of Zend Framework (though it can be used separately to the rest of it)