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