1<?php 2/** 3 * Class auto-loader 4 * 5 * PHP versions 4 6 * 7 * LICENSE: This source file is subject to version 3.0 of the PHP license 8 * that is available through the world-wide-web at the following URI: 9 * http://www.php.net/license/3_0.txt. If you did not receive a copy of 10 * the PHP License and are unable to obtain it through the web, please 11 * send a note to license@php.net so we can mail you a copy immediately. 12 * 13 * @category pear 14 * @package PEAR 15 * @author Stig Bakken <ssb@php.net> 16 * @copyright 1997-2006 The PHP Group 17 * @license http://www.php.net/license/3_0.txt PHP License 3.0 18 * @version CVS: $Id: Autoloader.php,v 1.13 2006/01/06 04:47:36 cellog Exp $ 19 * @link http://pear.php.net/manual/en/core.ppm.php#core.ppm.pear-autoloader 20 * @since File available since Release 0.1 21 * @deprecated File deprecated in Release 1.4.0a1 22 */ 23 24// /* vim: set expandtab tabstop=4 shiftwidth=4: */ 25 26if (!extension_loaded("overload")) { 27 // die hard without ext/overload 28 die("Rebuild PHP with the `overload' extension to use PEAR_Autoloader"); 29} 30 31/** 32 * Include for PEAR_Error and PEAR classes 33 */ 34require_once "PEAR.php"; 35 36/** 37 * This class is for objects where you want to separate the code for 38 * some methods into separate classes. This is useful if you have a 39 * class with not-frequently-used methods that contain lots of code 40 * that you would like to avoid always parsing. 41 * 42 * The PEAR_Autoloader class provides autoloading and aggregation. 43 * The autoloading lets you set up in which classes the separated 44 * methods are found. Aggregation is the technique used to import new 45 * methods, an instance of each class providing separated methods is 46 * stored and called every time the aggregated method is called. 47 * 48 * @category pear 49 * @package PEAR 50 * @author Stig Bakken <ssb@php.net> 51 * @copyright 1997-2006 The PHP Group 52 * @license http://www.php.net/license/3_0.txt PHP License 3.0 53 * @version Release: 1.4.11 54 * @link http://pear.php.net/manual/en/core.ppm.php#core.ppm.pear-autoloader 55 * @since File available since Release 0.1 56 * @deprecated File deprecated in Release 1.4.0a1 57 */ 58class PEAR_Autoloader extends PEAR 59{ 60 // {{{ properties 61 62 /** 63 * Map of methods and classes where they are defined 64 * 65 * @var array 66 * 67 * @access private 68 */ 69 var $_autoload_map = array(); 70 71 /** 72 * Map of methods and aggregate objects 73 * 74 * @var array 75 * 76 * @access private 77 */ 78 var $_method_map = array(); 79 80 // }}} 81 // {{{ addAutoload() 82 83 /** 84 * Add one or more autoload entries. 85 * 86 * @param string $method which method to autoload 87 * 88 * @param string $classname (optional) which class to find the method in. 89 * If the $method parameter is an array, this 90 * parameter may be omitted (and will be ignored 91 * if not), and the $method parameter will be 92 * treated as an associative array with method 93 * names as keys and class names as values. 94 * 95 * @return void 96 * 97 * @access public 98 */ 99 function addAutoload($method, $classname = null) 100 { 101 if (is_array($method)) { 102 array_walk($method, create_function('$a,&$b', '$b = strtolower($b);')); 103 $this->_autoload_map = array_merge($this->_autoload_map, $method); 104 } else { 105 $this->_autoload_map[strtolower($method)] = $classname; 106 } 107 } 108 109 // }}} 110 // {{{ removeAutoload() 111 112 /** 113 * Remove an autoload entry. 114 * 115 * @param string $method which method to remove the autoload entry for 116 * 117 * @return bool TRUE if an entry was removed, FALSE if not 118 * 119 * @access public 120 */ 121 function removeAutoload($method) 122 { 123 $method = strtolower($method); 124 $ok = isset($this->_autoload_map[$method]); 125 unset($this->_autoload_map[$method]); 126 return $ok; 127 } 128 129 // }}} 130 // {{{ addAggregateObject() 131 132 /** 133 * Add an aggregate object to this object. If the specified class 134 * is not defined, loading it will be attempted following PEAR's 135 * file naming scheme. All the methods in the class will be 136 * aggregated, except private ones (name starting with an 137 * underscore) and constructors. 138 * 139 * @param string $classname what class to instantiate for the object. 140 * 141 * @return void 142 * 143 * @access public 144 */ 145 function addAggregateObject($classname) 146 { 147 $classname = strtolower($classname); 148 if (!class_exists($classname)) { 149 $include_file = preg_replace('/[^a-z0-9]/i', '_', $classname); 150 include_once $include_file; 151 } 152 $obj =& new $classname; 153 $methods = get_class_methods($classname); 154 foreach ($methods as $method) { 155 // don't import priviate methods and constructors 156 if ($method{0} != '_' && $method != $classname) { 157 $this->_method_map[$method] = $obj; 158 } 159 } 160 } 161 162 // }}} 163 // {{{ removeAggregateObject() 164 165 /** 166 * Remove an aggregate object. 167 * 168 * @param string $classname the class of the object to remove 169 * 170 * @return bool TRUE if an object was removed, FALSE if not 171 * 172 * @access public 173 */ 174 function removeAggregateObject($classname) 175 { 176 $ok = false; 177 $classname = strtolower($classname); 178 reset($this->_method_map); 179 while (list($method, $obj) = each($this->_method_map)) { 180 if (is_a($obj, $classname)) { 181 unset($this->_method_map[$method]); 182 $ok = true; 183 } 184 } 185 return $ok; 186 } 187 188 // }}} 189 // {{{ __call() 190 191 /** 192 * Overloaded object call handler, called each time an 193 * undefined/aggregated method is invoked. This method repeats 194 * the call in the right aggregate object and passes on the return 195 * value. 196 * 197 * @param string $method which method that was called 198 * 199 * @param string $args An array of the parameters passed in the 200 * original call 201 * 202 * @return mixed The return value from the aggregated method, or a PEAR 203 * error if the called method was unknown. 204 */ 205 function __call($method, $args, &$retval) 206 { 207 $method = strtolower($method); 208 if (empty($this->_method_map[$method]) && isset($this->_autoload_map[$method])) { 209 $this->addAggregateObject($this->_autoload_map[$method]); 210 } 211 if (isset($this->_method_map[$method])) { 212 $retval = call_user_func_array(array($this->_method_map[$method], $method), $args); 213 return true; 214 } 215 return false; 216 } 217 218 // }}} 219} 220 221overload("PEAR_Autoloader"); 222 223?> 224