To complete the autoloading mechanism the full mapper class has to be constructed. First, consider its structure by looking at the code with most data removed, several minor methods left out, and the longer methods' code removed:

class smartClassMapper extends cachedSingleton
{
protected static $instance = CLASS ;
protected $dynamap = array(); protected $debug_log = array(); protected $populating = false;
protected $classlist = array();
protected $subclasses = array();
protected $classmap = array ('aliroAbstractDatabase' =>
'aliroDatabase','aliroDatabaseHandler' => 'aliroDatabase',);
protected $extmap = array('PclZip' => 'pclzip.lib',
'Archive_Tar' => 'Tar');
protected function construct ()
{
// Enforce singleton by being protected
$this->classlist = $this->listDir(_ALIRO_CLASS_BASE.'/classes');
}
public static function getInstance () {
if (!is_object(self::$instance)) {
self::$instance = parent::getCachedSingleton(self::$instance);
self::$instance->reset();
}
self::$instance->checkDynamic();
return self::$instance;
}
public function print ()
{
return sprintf(T_('SmartClassMapper, %s dynamic items, %
logs'), count($this->dynamap), count($this->debug_log));
}
protected function populateMap ()
{
}
public function getClassPath ($classname)
{
}
protected function saveMap ($path, $map)
{
}
public function requireClass ($classname) {
$path = $this->getClassPath($classname);
if ($path AND file_exists($path)) {
require_once($path);
}
else {
$message = sprintf('Class %s not found, trying with path = %s', $classname, $path);
trigger_error($message);
}
}
public static function autoloadClass ($classname) {
$mapper = _ALIRO_IS_ADMIN ? call_user_func(array('smartAdminClassMapper', 'getInstance')) : call_user_func(array('smartClassMapper', 'getInstance'));
$mapper->requireClass($classname);
}
}

Note that the class mapper inherits from the cachedSingleton, which is an abstract class described in detail in the chapter on caches. The inheritance makes it easy to build a singleton class that will only be constructed infrequently so as to reduce the overhead of organizing data, and cut down on database access. Most times, the single instance of the class is retrieved from cache by methods in cachedSingleton and related classes.

Any number of variations is possible, but the scheme currently adopted for Aliro is that commonly used framework classes for the user (as opposed to administration) side of Aliro are stored in files that have the same name as the class apart from the addition of the extension php. They are all held in a classes directory. There is no stored data in the mapper for these classes, but they are found using the listdir method. Classes belonging to extensions that have been added to the CMS are described in a database table, which is updated by the installer. Other class information comes from the arrays that are properties of the mapper and filled with data in the code of the class:

Some PHP code goes to great pains to handle paths with backslashes for Windows, and slashes for Linux. This is unnecessary. It is tidier to be consistent, and far easier to handle ordinary (forward) slashes. PHP sorts out the operating system dependencies.

Other properties of the Smart Class Mapper are the static instance variable that is used to hold the one and only object instance of the singleton class, and the debug_log array that contains an entry for every class that is loaded. As its name implies it is available for debug, or performance tuning.

The short methods that are shown in full in the last code are as follows:

With the code in front of us, we can now see how the autoload method works. It is static because until we know whether we are working with the user side or the administrator side, we cannot tell which class to use. The symbol _ALIRO_IS_ADMIN has been set at the very start of request processing to be true or false as appropriate. Now, it determines which class will be used for handling the loading of classes.

What happens as a result of the autoload mechanism is that whenever PHP encounters a reference to a class that is unknown, it calls the autoloadClass method. (On the few occasions this needs to be bypassed, a possible solution is to use the PHP5 function class_exists with the optional second parameter set to false to prevent autoloading; another way is to call this class's classExists method.)

One parameter is passed to autoloadClass, which is the name of the class. The real work is done by the requireClass method, which figures out where to find the requested class and then loads it using the PHP require function. The way it finds out the whereabouts of the class is explained in the next section as other methods are introduced. Assuming the Smart Class Mapper has done its work well, PHP will now know all about the class whose name was passed in as a parameter to the autoloadClass method. If the path for the class is not found, or turns out not to exist, then an error is triggered.

Although not part of the smartClassLoader, it is worth mentioning how the class information that relates to extensions is obtained. Within the aliroExtensionInstaller class that is at the heart of installing either a new extension or an upgrade to an existing one is this method:

protected function handleClassFile ($extension, $side, $filename, $path) {
$tokens = token_get_all(file_get_contents($path.'/'.$filename));
if (!empty($tokens)) foreach ($tokens as $key=>$token) {
if (T_CLASS == $token[0]) {
$classname = isset($tokens[$key+2][1]) ? $tokens[$key+2][1] : '';
$extends = (isset($tokens[$key+4][0]) AND T_EXTENDS == $tokens[$key+4][0] AND isset($tokens[$key+6][1])) ? $tokens[$key+6][1] : '';
$classes[] = array('classname' => $classname, 'extends' => $extends);
}
}
if (!empty($classes)) {
$filedir = dirname($filename);
$filemap = ('.' == $filedir ? '' : $filedir.'/').basename($filename, '.php');
foreach ($classes as $class) {
smartClassMapper::insertClass($extension->type, $extension->formalname, $side, $filemap, $class['classname'], $class['extends']);
}
}
unset($tokens);
}

It is passed each file that is expected to contain PHP code, as well as an object that represents the extension and an indicator of whether the code is for the exclusive use of administrators or not.

The method relies on the powerful PHP function token_get_all to parse the PHP code and turn it into an array of tokens. The array is searched for instances of the class keyword, with the name of the class being the next but one token. If the class is a subclass, then the keyword extends will follow two items later, and the name of the parent class another two items later (the intervening tokens will be white space).

Once all the tokens have been analyzed, the class information is processed. Each class is used to insert a record in the class mapping database table, using a method provided by the smartClassMapper class. Clearly the database operation could have been coded directly, but it is preferable to put it into the smartClassMapper so that all operations on the table are within the one class. That way, any changes in the implementation are kept within the one class.