How do you revise this AutoLoader class for a more complicated file structure?

Lord_Yggdrasill

Well I currently have a file structure that I believe is kinda unscientific, so I decide to revise it. The old and new file structures are illustrated as below:

Old structure:

classes
- abstracts
- finals
- interfaces
- traits

New structure:

library
- controller
  - admincp
  - base
  - modcp
  - site
  - and more...
- model
  - data
  - group
  - item
  - page
  - setting
  - system
  - user
  - and more...
- helper
- resource
  - core
  - exception
  - gui
  - io
  - math
  - native
  - utility
  - and more...
- view
  - lang
  - main
  - template
  - and more...

I know it is getting more complicated, and this is definitely giving me a headache on how to redesign my Loader class. As most of you probably know, PHP introduces new ways to define autoload approach so that we do not have to use __autoload() with so many constraints anymore. Here is the loader class I designed for my old structure:

<?php

class Loader extends Object implements Loadable, Extractable{
  protected $classes = array();

  public function __construct(){
     // The Loader object constructor

 spl_autoload_register(array($this, 'load'));
  }

  public function load($class){
     // The method that autoloads a class

 if(!in_array($class, $this->classes)){
    // The class is not yet loaded, it should be a good idea to load
	$this->classes[] = $class;
	$class_path = strtolower("classes/class_{$class}");
	$dir = (defined("SUBDIR"))?"../":"";
    if(file_exists("{$dir}{$class_path}.php")) include("{$dir}{$class_path}.php");
	else{
	   $abstract_path = strtolower("classes/abstract/abstract_{$class}");
	   $final_path = strtolower("classes/final/final_{$class}");
	   $interface_path = strtolower("classes/interfaces/interface_{$class}");
	   if(file_exists("{$dir}{$abstract_path}.php")) include("{$dir}{$abstract_path}.php");
	   elseif(file_exists("{$dir}{$interface_path}.php")) include("{$dir}{$interface_path}.php");
	   else throw new Exception("Fatal Error: Class {$class} either does not exist!");
	}
 }
 else Throw new Exception("An error has occurred. Class {$class} has already been loaded.");
  }

  public function extract(){
     // This method returns a list of loader method
	 return spl_autoload_function();
  }  

}

The Loader::load() method is a bit more complex than you'd imagine, this is because my old class file structure has prefix class, abstract, final and interface to distinguish them from executable view files(this should not be a problem anymore with MVC, at least I hope). With a file structure that only contains 2-5 directories storing class library files, a loader class is very easy to design. But this becomes a problem with my proposed new file structure, in which a class may be found from 20-30+ different library directories. How will you redesign the loader class and its method given this circumstance? Is it enough just to use set_include_path()? Is it gonna help with usage of namespace? If you have any ideas, please lemme know and I'd appreciate more with a bit of dummy examples. Thx.

Lord_Yggdrasill

umm no one knows how to do this? 😕

johanafm

Only you yourself. Since you are the one who chooses where to place files, you are the only one who can know from where to load them.

If you choose to place the files in a way that can be described by an algorithm, there is your answer. If the files are placed in an arbitrary fashion so that this is not possible, you'd need to keep some kind of list mapping classes to file locations and use that.

Or you could chuck all classes in one directory and be done with it in a straightforward way.

Your choice, your solution.

But I would point out that it's impossible for your code to compute wether a given class is final or abstract without first having access to that class! Thus, your code can never know that is should load a specific class from directory classes/abstract/ until it has allready done so. As such, I would not keep the files separated that way. Esp. since it's evident by looking at the first line of the class definition to see find out what it is, due to the use of those exact words: "abstract", "final", "implements" etc.

Lord_Yggdrasill

johanafm;11012381 wrote:
But I would point out that it's impossible for your code to compute wether a given class is final or abstract without first having access to that class! Thus, your code can never know that is should load a specific class from directory classes/abstract/ until it has allready done so. As such, I would not keep the files separated that way. Esp. since it's evident by looking at the first line of the class definition to see find out what it is, due to the use of those exact words: "abstract", "final", "implements" etc.

Yeah, thats why I am trying to redesign the class. The old approach was to select from the directories classes, abstract, interfaces and finals in an iterative manner, but I'd agree that its quite inefficient. I hope the new design will work out nicer, but of course figuring out whether a class is a model, view, controller, resource or helper can be a pain as much as deciding whether its a concrete, abstract, final class or interface.

Derokorian

I'll tell you what I do ygg; I use namespaces to mirror my folder structure, then when I include a file I can use the namespace turn become a folder path relative to my application root. So I might have something like the following: (simplified for brevity)

namespace 'Application\Models';
class User extends BaseModel {}

namespace 'Application\Core\Helpers';
class HTMLTable extends BaseHelper {}

function __autoload($class) 
{ // Yes I just use this autoload instead of spl register
   $file = str_replace('\\',DIRECTORY_SEPARATOR,$class) . '.php';
   if( file_exists(ROOT . $file) ) 
   {
      require_once(ROOT . $file);
      return true;
   }

   foreach( explode(PATH_SEPARATOR,get_include_path()) as $path ) 
   {
      if( file_exists($path . DIRECTORY_SEPARATOR . $file) ) 
      {
         require_once($path . DIRECTORY_SEPARATOR . $file);
         return true;
      }
   }
   return false;
}

Lord_Yggdrasill

I see, this is kinda interesting. So you used a foreach loop on get_include_path() function to get all possible sub-paths for your classes. I have a question though... Assume I have some classes located in lots of directories and their subdirectories, say the structure I proposed in my very first post. Do I have to set include paths for all possible class paths? If so, is this gonna be quite tedious and inefficient if I have too many subdirectories that contain class files?

Derokorian

No no, my way of doing it only has the default include path, plus my path to zend, all the files that i create for my own application are in folder structure matching the name spacing. This means I have one file_exists call for anything I created and possibly 3 or 4 if it goes beyond that.

Lord_Yggdrasill

Derokorian;11012419 wrote:
No no, my way of doing it only has the default include path, plus my path to zend, all the files that i create for my own application are in folder structure matching the name spacing. This means I have one file_exists call for anything I created and possibly 3 or 4 if it goes beyond that.

I see, only one default include path? Is namespace really the key to achieving the goal of loading classes from various subdirectories?
😕

Derokorian

Its not necessarily the key, its all about how YOU want to do it. There comes a point when you can have too much folder structure, there's also a point when there's not enough. What it comes down to is what will be easiest to maintain. For me that means I can just add a class to my system, put it in a name space matching the folder structure and bam it works. When I create a new folder, the classes in it just have another namespace part, what this means is that I don't have to update my autoloader to update my folder structure.

There are of course many different ways to do this, another option might be defining constants for different folders, like CONTROLLER_PATH MODEL_PATH etc, then prioritizing the if file exists to use the most common directories first, that way most of your requirements will only require one check while some will require two and fewer still will require three... etc. This could lead to an autoloader along these lines:

function __autoload($class) {
   if( file_exists(CONT_PATH . $class . '.php') ) {
      require_once(CONT_PATH . $class . '.php');
      return TRUE;
   }
   if( file_exists(MODEL_PATH  . $class . '.php') ) {
      require_once(MODEL_PATH . $class . '.php');
      return TRUE;
   }
   if( file_exists(CORE_PATH . $class . '.php') ) {
      require_once(CORE_PATH . $class . '.php');
      return TRUE;
   }
   foreach( explode(PATH_SEPARATOR,get_include_path()) as $path) {
      if( file_exists($path . DS . $class . '.php') ) {
         require_once($path . DS . $class . '.php');
         return TRUE;
      }
   }
   return FALSE;
}

bradgrafelman

Couldn't you also replace this:

   foreach( explode(PATH_SEPARATOR,get_include_path()) as $path) { 
      if( file_exists($path . DS . $class . '.php') ) { 
         require_once($path . DS . $class . '.php'); 
         return TRUE; 
      } 
   }

with this:

   if( file_exists($class . '.php') ) {
      require_once($class . '.php');
      return TRUE;
   }

Derokorian

I don't believe so brad, IIRC file_exists doesn't use the include_path - as mentioned in comments on the manual page for it. Haven't tested it as I'm at work atm.

bradgrafelman

Oops... what I really meant to say was:

   if( stream_resolve_include_path($class . '.php') ) {
      require_once($class . '.php');
      return TRUE;
   }

😛

Derokorian

Well in that case, yes - yes you could.

Lord_Yggdrasill

Derokorian;11012443 wrote:
Its not necessarily the key, its all about how YOU want to do it. There comes a point when you can have too much folder structure, there's also a point when there's not enough. What it comes down to is what will be easiest to maintain. For me that means I can just add a class to my system, put it in a name space matching the folder structure and bam it works. When I create a new folder, the classes in it just have another namespace part, what this means is that I don't have to update my autoloader to update my folder structure.

There are of course many different ways to do this, another option might be defining constants for different folders, like CONTROLLER_PATH MODEL_PATH etc, then prioritizing the if file exists to use the most common directories first, that way most of your requirements will only require one check while some will require two and fewer still will require three... etc. This could lead to an autoloader along these lines:
function __autoload($class) {
   if( file_exists(CONT_PATH . $class . '.php') ) {
      require_once(CONT_PATH . $class . '.php');
      return TRUE;
   }
   if( file_exists(MODEL_PATH  . $class . '.php') ) {
      require_once(MODEL_PATH . $class . '.php');
      return TRUE;
   }
   if( file_exists(CORE_PATH . $class . '.php') ) {
      require_once(CORE_PATH . $class . '.php');
      return TRUE;
   }
   foreach( explode(PATH_SEPARATOR,get_include_path()) as $path) {
      if( file_exists($path . DS . $class . '.php') ) {
         require_once($path . DS . $class . '.php');
         return TRUE;
      }
   }
   return FALSE;
}

I see, thanks for the explanation, I think I understand better now. Still dont quite know what Namespace does in the case of auto-loading though. XD