import java.awt.event.*;

But in the spirit of ‘programming into the language’, what we can do is try to simulate a ‘package-like’ concept in PHP. Take the following directory structure.

So now if we want to import the ‘login.php’ file in our code we must be able to do the following with a newly created ‘import’ function:

import("com.codediesel.Security.login");

This will include the ‘login.php’ file from the ‘com/codediesel/Security’ directory. To include all the files from the ‘Security’ directory we can do the following:

import("com.codediesel.Security.*);

As you can see that this is actually quite different from what the actual package concept implies, which is to import related classes.

Anyways, taking it as a conceptual idea only the code for the import function is shown below:

<?php
 
$basePath = "./";
 
function import($classPath)
{
    global $basePath;
 
    /* If the path ends with a '.*' then include
       all the files in the last given directory.
    */
    if(preg_match('/(\.\*)$/', $classPath))
    {
        $importFilePath = substr($classPath, 0, strlen($classPath) - 2);
        $importFilePath = str_replace(".", "/", $importFilePath);
        $d= dir($basePath . $importFilePath);
 
        while(false !== ($file = $d->read())) 
        {
            /* Reject parent, current directories and sub directories */
            if(($file == '.')  ||
               ($file == '..') ||
               (is_dir($d->path . "/" . $file)))
            {
                continue;
            }
 
            require_once($basePath . $importFilePath . "/" . $file);
        }
    } else {
        /* If a single file is specified */
        $importFile = str_replace(".", "/", $classPath) . ".php";
    	require_once($basePath . $importFile);
    }
}
 
?>

Please note that this is just an idea. Detailed error handling is not included to keep the code conceptually simple to understand. It would be fun if readers could bounce around some thoughts.

Now the Problems

The first main problem is that this is not exactly what the package concept implies. What we are essentially doing is dressing-up the ‘include’ concept in new clothes.

The second is that for multiple file inclusion as shown above, we cannot predict in which sequence the files will be included, which can raise some dependency issues.

Including a large number of files can incur a small performance hit. This can be better handled if developed as a PECL extension.