Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

Loader.php @ 672

Last change on this file since 672 was 289, checked in by dungnv, 11 years ago

File size: 29.9 KB

Rev	Line
[289]	1	<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
	2	/**
	3	* CodeIgniter
	4	*
	5	* An open source application development framework for PHP 5.1.6 or newer
	6	*
	7	* @package CodeIgniter
	8	* @author ExpressionEngine Dev Team
	9	* @copyright Copyright (c) 2008 - 2011, EllisLab, Inc.
	10	* @license http://codeigniter.com/user_guide/license.html
	11	* @link http://codeigniter.com
	12	* @since Version 1.0
	13	* @filesource
	14	*/
	15
	16	// ------------------------------------------------------------------------
	17
	18	/**
	19	* Loader Class
	20	*
	21	* Loads views and files
	22	*
	23	* @package CodeIgniter
	24	* @subpackage Libraries
	25	* @author ExpressionEngine Dev Team
	26	* @category Loader
	27	* @link http://codeigniter.com/user_guide/libraries/loader.html
	28	*/
	29	class CI_Loader {
	30
	31	// All these are set automatically. Don't mess with them.
	32	/**
	33	* Nesting level of the output buffering mechanism
	34	*
	35	* @var int
	36	* @access protected
	37	*/
	38	protected $_ci_ob_level;
	39	/**
	40	* List of paths to load views from
	41	*
	42	* @var array
	43	* @access protected
	44	*/
	45	protected $_ci_view_paths = array();
	46	/**
	47	* List of paths to load libraries from
	48	*
	49	* @var array
	50	* @access protected
	51	*/
	52	protected $_ci_library_paths = array();
	53	/**
	54	* List of paths to load models from
	55	*
	56	* @var array
	57	* @access protected
	58	*/
	59	protected $_ci_model_paths = array();
	60	/**
	61	* List of paths to load helpers from
	62	*
	63	* @var array
	64	* @access protected
	65	*/
	66	protected $_ci_helper_paths = array();
	67	/**
	68	* List of loaded base classes
	69	* Set by the controller class
	70	*
	71	* @var array
	72	* @access protected
	73	*/
	74	protected $_base_classes = array(); // Set by the controller class
	75	/**
	76	* List of cached variables
	77	*
	78	* @var array
	79	* @access protected
	80	*/
	81	protected $_ci_cached_vars = array();
	82	/**
	83	* List of loaded classes
	84	*
	85	* @var array
	86	* @access protected
	87	*/
	88	protected $_ci_classes = array();
	89	/**
	90	* List of loaded files
	91	*
	92	* @var array
	93	* @access protected
	94	*/
	95	protected $_ci_loaded_files = array();
	96	/**
	97	* List of loaded models
	98	*
	99	* @var array
	100	* @access protected
	101	*/
	102	protected $_ci_models = array();
	103	/**
	104	* List of loaded helpers
	105	*
	106	* @var array
	107	* @access protected
	108	*/
	109	protected $_ci_helpers = array();
	110	/**
	111	* List of class name mappings
	112	*
	113	* @var array
	114	* @access protected
	115	*/
	116	protected $_ci_varmap = array('unit_test' => 'unit',
	117	'user_agent' => 'agent');
	118
	119	/**
	120	* Constructor
	121	*
	122	* Sets the path to the view files and gets the initial output buffering level
	123	*/
	124	public function __construct()
	125	{
	126	$this->_ci_ob_level = ob_get_level();
	127	$this->_ci_library_paths = array(APPPATH, BASEPATH);
	128	$this->_ci_helper_paths = array(APPPATH, BASEPATH);
	129	$this->_ci_model_paths = array(APPPATH);
	130	$this->_ci_view_paths = array(APPPATH.'views/' => TRUE);
	131
	132	log_message('debug', "Loader Class Initialized");
	133	}
	134
	135	// --------------------------------------------------------------------
	136
	137	/**
	138	* Initialize the Loader
	139	*
	140	* This method is called once in CI_Controller.
	141	*
	142	* @param array
	143	* @return object
	144	*/
	145	public function initialize()
	146	{
	147	$this->_ci_classes = array();
	148	$this->_ci_loaded_files = array();
	149	$this->_ci_models = array();
	150	$this->_base_classes =& is_loaded();
	151
	152	$this->_ci_autoloader();
	153
	154	return $this;
	155	}
	156
	157	// --------------------------------------------------------------------
	158
	159	/**
	160	* Is Loaded
	161	*
	162	* A utility function to test if a class is in the self::$_ci_classes array.
	163	* This function returns the object name if the class tested for is loaded,
	164	* and returns FALSE if it isn't.
	165	*
	166	* It is mainly used in the form_helper -> _get_validation_object()
	167	*
	168	* @param string class being checked for
	169	* @return mixed class object name on the CI SuperObject or FALSE
	170	*/
	171	public function is_loaded($class)
	172	{
	173	if (isset($this->_ci_classes[$class]))
	174	{
	175	return $this->_ci_classes[$class];
	176	}
	177
	178	return FALSE;
	179	}
	180
	181	// --------------------------------------------------------------------
	182
	183	/**
	184	* Class Loader
	185	*
	186	* This function lets users load and instantiate classes.
	187	* It is designed to be called from a user's app controllers.
	188	*
	189	* @param string the name of the class
	190	* @param mixed the optional parameters
	191	* @param string an optional object name
	192	* @return void
	193	*/
	194	public function library($library = '', $params = NULL, $object_name = NULL)
	195	{
	196	if (is_array($library))
	197	{
	198	foreach ($library as $class)
	199	{
	200	$this->library($class, $params);
	201	}
	202
	203	return;
	204	}
	205
	206	if ($library == '' OR isset($this->_base_classes[$library]))
	207	{
	208	return FALSE;
	209	}
	210
	211	if ( ! is_null($params) && ! is_array($params))
	212	{
	213	$params = NULL;
	214	}
	215
	216	$this->_ci_load_class($library, $params, $object_name);
	217	}
	218
	219	// --------------------------------------------------------------------
	220
	221	/**
	222	* Model Loader
	223	*
	224	* This function lets users load and instantiate models.
	225	*
	226	* @param string the name of the class
	227	* @param string name for the model
	228	* @param bool database connection
	229	* @return void
	230	*/
	231	public function model($model, $name = '', $db_conn = FALSE)
	232	{
	233	if (is_array($model))
	234	{
	235	foreach ($model as $babe)
	236	{
	237	$this->model($babe);
	238	}
	239	return;
	240	}
	241
	242	if ($model == '')
	243	{
	244	return;
	245	}
	246
	247	$path = '';
	248
	249	// Is the model in a sub-folder? If so, parse out the filename and path.
	250	if (($last_slash = strrpos($model, '/')) !== FALSE)
	251	{
	252	// The path is in front of the last slash
	253	$path = substr($model, 0, $last_slash + 1);
	254
	255	// And the model name behind it
	256	$model = substr($model, $last_slash + 1);
	257	}
	258
	259	if ($name == '')
	260	{
	261	$name = $model;
	262	}
	263
	264	if (in_array($name, $this->_ci_models, TRUE))
	265	{
	266	return;
	267	}
	268
	269	$CI =& get_instance();
	270	if (isset($CI->$name))
	271	{
	272	show_error('The model name you are loading is the name of a resource that is already being used: '.$name);
	273	}
	274
	275	$model = strtolower($model);
	276
	277	foreach ($this->_ci_model_paths as $mod_path)
	278	{
	279	if ( ! file_exists($mod_path.'models/'.$path.$model.'.php'))
	280	{
	281	continue;
	282	}
	283
	284	if ($db_conn !== FALSE AND ! class_exists('CI_DB'))
	285	{
	286	if ($db_conn === TRUE)
	287	{
	288	$db_conn = '';
	289	}
	290
	291	$CI->load->database($db_conn, FALSE, TRUE);
	292	}
	293
	294	if ( ! class_exists('CI_Model'))
	295	{
	296	load_class('Model', 'core');
	297	}
	298
	299	require_once($mod_path.'models/'.$path.$model.'.php');
	300
	301	$model = ucfirst($model);
	302
	303	$CI->$name = new $model();
	304
	305	$this->_ci_models[] = $name;
	306	return;
	307	}
	308
	309	// couldn't find the model
	310	show_error('Unable to locate the model you have specified: '.$model);
	311	}
	312
	313	// --------------------------------------------------------------------
	314
	315	/**
	316	* Database Loader
	317	*
	318	* @param string the DB credentials
	319	* @param bool whether to return the DB object
	320	* @param bool whether to enable active record (this allows us to override the config setting)
	321	* @return object
	322	*/
	323	public function database($params = '', $return = FALSE, $active_record = NULL)
	324	{
	325	// Grab the super object
	326	$CI =& get_instance();
	327
	328	// Do we even need to load the database class?
	329	if (class_exists('CI_DB') AND $return == FALSE AND $active_record == NULL AND isset($CI->db) AND is_object($CI->db))
	330	{
	331	return FALSE;
	332	}
	333
	334	require_once(BASEPATH.'database/DB.php');
	335
	336	if ($return === TRUE)
	337	{
	338	return DB($params, $active_record);
	339	}
	340
	341	// Initialize the db variable. Needed to prevent
	342	// reference errors with some configurations
	343	$CI->db = '';
	344
	345	// Load the DB class
	346	$CI->db =& DB($params, $active_record);
	347	}
	348
	349	// --------------------------------------------------------------------
	350
	351	/**
	352	* Load the Utilities Class
	353	*
	354	* @return string
	355	*/
	356	public function dbutil()
	357	{
	358	if ( ! class_exists('CI_DB'))
	359	{
	360	$this->database();
	361	}
	362
	363	$CI =& get_instance();
	364
	365	// for backwards compatibility, load dbforge so we can extend dbutils off it
	366	// this use is deprecated and strongly discouraged
	367	$CI->load->dbforge();
	368
	369	require_once(BASEPATH.'database/DB_utility.php');
	370	require_once(BASEPATH.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_utility.php');
	371	$class = 'CI_DB_'.$CI->db->dbdriver.'_utility';
	372
	373	$CI->dbutil = new $class();
	374	}
	375
	376	// --------------------------------------------------------------------
	377
	378	/**
	379	* Load the Database Forge Class
	380	*
	381	* @return string
	382	*/
	383	public function dbforge()
	384	{
	385	if ( ! class_exists('CI_DB'))
	386	{
	387	$this->database();
	388	}
	389
	390	$CI =& get_instance();
	391
	392	require_once(BASEPATH.'database/DB_forge.php');
	393	require_once(BASEPATH.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_forge.php');
	394	$class = 'CI_DB_'.$CI->db->dbdriver.'_forge';
	395
	396	$CI->dbforge = new $class();
	397	}
	398
	399	// --------------------------------------------------------------------
	400
	401	/**
	402	* Load View
	403	*
	404	* This function is used to load a "view" file. It has three parameters:
	405	*
	406	* 1. The name of the "view" file to be included.
	407	* 2. An associative array of data to be extracted for use in the view.
	408	* 3. TRUE/FALSE - whether to return the data or load it. In
	409	* some cases it's advantageous to be able to return data so that
	410	* a developer can process it in some way.
	411	*
	412	* @param string
	413	* @param array
	414	* @param bool
	415	* @return void
	416	*/
	417	public function view($view, $vars = array(), $return = FALSE)
	418	{
	419	return $this->_ci_load(array('_ci_view' => $view, '_ci_vars' => $this->_ci_object_to_array($vars), '_ci_return' => $return));
	420	}
	421
	422	// --------------------------------------------------------------------
	423
	424	/**
	425	* Load File
	426	*
	427	* This is a generic file loader
	428	*
	429	* @param string
	430	* @param bool
	431	* @return string
	432	*/
	433	public function file($path, $return = FALSE)
	434	{
	435	return $this->_ci_load(array('_ci_path' => $path, '_ci_return' => $return));
	436	}
	437
	438	// --------------------------------------------------------------------
	439
	440	/**
	441	* Set Variables
	442	*
	443	* Once variables are set they become available within
	444	* the controller class and its "view" files.
	445	*
	446	* @param array
	447	* @param string
	448	* @return void
	449	*/
	450	public function vars($vars = array(), $val = '')
	451	{
	452	if ($val != '' AND is_string($vars))
	453	{
	454	$vars = array($vars => $val);
	455	}
	456
	457	$vars = $this->_ci_object_to_array($vars);
	458
	459	if (is_array($vars) AND count($vars) > 0)
	460	{
	461	foreach ($vars as $key => $val)
	462	{
	463	$this->_ci_cached_vars[$key] = $val;
	464	}
	465	}
	466	}
	467
	468	// --------------------------------------------------------------------
	469
	470	/**
	471	* Get Variable
	472	*
	473	* Check if a variable is set and retrieve it.
	474	*
	475	* @param array
	476	* @return void
	477	*/
	478	public function get_var($key)
	479	{
	480	return isset($this->_ci_cached_vars[$key]) ? $this->_ci_cached_vars[$key] : NULL;
	481	}
	482
	483	// --------------------------------------------------------------------
	484
	485	/**
	486	* Load Helper
	487	*
	488	* This function loads the specified helper file.
	489	*
	490	* @param mixed
	491	* @return void
	492	*/
	493	public function helper($helpers = array())
	494	{
	495	foreach ($this->_ci_prep_filename($helpers, '_helper') as $helper)
	496	{
	497	if (isset($this->_ci_helpers[$helper]))
	498	{
	499	continue;
	500	}
	501
	502	$ext_helper = APPPATH.'helpers/'.config_item('subclass_prefix').$helper.'.php';
	503
	504	// Is this a helper extension request?
	505	if (file_exists($ext_helper))
	506	{
	507	$base_helper = BASEPATH.'helpers/'.$helper.'.php';
	508
	509	if ( ! file_exists($base_helper))
	510	{
	511	show_error('Unable to load the requested file: helpers/'.$helper.'.php');
	512	}
	513
	514	include_once($ext_helper);
	515	include_once($base_helper);
	516
	517	$this->_ci_helpers[$helper] = TRUE;
	518	log_message('debug', 'Helper loaded: '.$helper);
	519	continue;
	520	}
	521
	522	// Try to load the helper
	523	foreach ($this->_ci_helper_paths as $path)
	524	{
	525	if (file_exists($path.'helpers/'.$helper.'.php'))
	526	{
	527	include_once($path.'helpers/'.$helper.'.php');
	528
	529	$this->_ci_helpers[$helper] = TRUE;
	530	log_message('debug', 'Helper loaded: '.$helper);
	531	break;
	532	}
	533	}
	534
	535	// unable to load the helper
	536	if ( ! isset($this->_ci_helpers[$helper]))
	537	{
	538	show_error('Unable to load the requested file: helpers/'.$helper.'.php');
	539	}
	540	}
	541	}
	542
	543	// --------------------------------------------------------------------
	544
	545	/**
	546	* Load Helpers
	547	*
	548	* This is simply an alias to the above function in case the
	549	* user has written the plural form of this function.
	550	*
	551	* @param array
	552	* @return void
	553	*/
	554	public function helpers($helpers = array())
	555	{
	556	$this->helper($helpers);
	557	}
	558
	559	// --------------------------------------------------------------------
	560
	561	/**
	562	* Loads a language file
	563	*
	564	* @param array
	565	* @param string
	566	* @return void
	567	*/
	568	public function language($file = array(), $lang = '')
	569	{
	570	$CI =& get_instance();
	571
	572	if ( ! is_array($file))
	573	{
	574	$file = array($file);
	575	}
	576
	577	foreach ($file as $langfile)
	578	{
	579	$CI->lang->load($langfile, $lang);
	580	}
	581	}
	582
	583	// --------------------------------------------------------------------
	584
	585	/**
	586	* Loads a config file
	587	*
	588	* @param string
	589	* @param bool
	590	* @param bool
	591	* @return void
	592	*/
	593	public function config($file = '', $use_sections = FALSE, $fail_gracefully = FALSE)
	594	{
	595	$CI =& get_instance();
	596	$CI->config->load($file, $use_sections, $fail_gracefully);
	597	}
	598
	599	// --------------------------------------------------------------------
	600
	601	/**
	602	* Driver
	603	*
	604	* Loads a driver library
	605	*
	606	* @param string the name of the class
	607	* @param mixed the optional parameters
	608	* @param string an optional object name
	609	* @return void
	610	*/
	611	public function driver($library = '', $params = NULL, $object_name = NULL)
	612	{
	613	if ( ! class_exists('CI_Driver_Library'))
	614	{
	615	// we aren't instantiating an object here, that'll be done by the Library itself
	616	require BASEPATH.'libraries/Driver.php';
	617	}
	618
	619	if ($library == '')
	620	{
	621	return FALSE;
	622	}
	623
	624	// We can save the loader some time since Drivers will always be in a subfolder,
	625	// and typically identically named to the library
	626	if ( ! strpos($library, '/'))
	627	{
	628	$library = ucfirst($library).'/'.$library;
	629	}
	630
	631	return $this->library($library, $params, $object_name);
	632	}
	633
	634	// --------------------------------------------------------------------
	635
	636	/**
	637	* Add Package Path
	638	*
	639	* Prepends a parent path to the library, model, helper, and config path arrays
	640	*
	641	* @param string
	642	* @param boolean
	643	* @return void
	644	*/
	645	public function add_package_path($path, $view_cascade=TRUE)
	646	{
	647	$path = rtrim($path, '/').'/';
	648
	649	array_unshift($this->_ci_library_paths, $path);
	650	array_unshift($this->_ci_model_paths, $path);
	651	array_unshift($this->_ci_helper_paths, $path);
	652
	653	$this->_ci_view_paths = array($path.'views/' => $view_cascade) + $this->_ci_view_paths;
	654
	655	// Add config file path
	656	$config =& $this->_ci_get_component('config');
	657	array_unshift($config->_config_paths, $path);
	658	}
	659
	660	// --------------------------------------------------------------------
	661
	662	/**
	663	* Get Package Paths
	664	*
	665	* Return a list of all package paths, by default it will ignore BASEPATH.
	666	*
	667	* @param string
	668	* @return void
	669	*/
	670	public function get_package_paths($include_base = FALSE)
	671	{
	672	return $include_base === TRUE ? $this->_ci_library_paths : $this->_ci_model_paths;
	673	}
	674
	675	// --------------------------------------------------------------------
	676
	677	/**
	678	* Remove Package Path
	679	*
	680	* Remove a path from the library, model, and helper path arrays if it exists
	681	* If no path is provided, the most recently added path is removed.
	682	*
	683	* @param type
	684	* @param bool
	685	* @return type
	686	*/
	687	public function remove_package_path($path = '', $remove_config_path = TRUE)
	688	{
	689	$config =& $this->_ci_get_component('config');
	690
	691	if ($path == '')
	692	{
	693	$void = array_shift($this->_ci_library_paths);
	694	$void = array_shift($this->_ci_model_paths);
	695	$void = array_shift($this->_ci_helper_paths);
	696	$void = array_shift($this->_ci_view_paths);
	697	$void = array_shift($config->_config_paths);
	698	}
	699	else
	700	{
	701	$path = rtrim($path, '/').'/';
	702	foreach (array('_ci_library_paths', '_ci_model_paths', '_ci_helper_paths') as $var)
	703	{
	704	if (($key = array_search($path, $this->{$var})) !== FALSE)
	705	{
	706	unset($this->{$var}[$key]);
	707	}
	708	}
	709
	710	if (isset($this->_ci_view_paths[$path.'views/']))
	711	{
	712	unset($this->_ci_view_paths[$path.'views/']);
	713	}
	714
	715	if (($key = array_search($path, $config->_config_paths)) !== FALSE)
	716	{
	717	unset($config->_config_paths[$key]);
	718	}
	719	}
	720
	721	// make sure the application default paths are still in the array
	722	$this->_ci_library_paths = array_unique(array_merge($this->_ci_library_paths, array(APPPATH, BASEPATH)));
	723	$this->_ci_helper_paths = array_unique(array_merge($this->_ci_helper_paths, array(APPPATH, BASEPATH)));
	724	$this->_ci_model_paths = array_unique(array_merge($this->_ci_model_paths, array(APPPATH)));
	725	$this->_ci_view_paths = array_merge($this->_ci_view_paths, array(APPPATH.'views/' => TRUE));
	726	$config->_config_paths = array_unique(array_merge($config->_config_paths, array(APPPATH)));
	727	}
	728
	729	// --------------------------------------------------------------------
	730
	731	/**
	732	* Loader
	733	*
	734	* This function is used to load views and files.
	735	* Variables are prefixed with _ci_ to avoid symbol collision with
	736	* variables made available to view files
	737	*
	738	* @param array
	739	* @return void
	740	*/
	741	protected function _ci_load($_ci_data)
	742	{
	743	// Set the default data variables
	744	foreach (array('_ci_view', '_ci_vars', '_ci_path', '_ci_return') as $_ci_val)
	745	{
	746	$$_ci_val = ( ! isset($_ci_data[$_ci_val])) ? FALSE : $_ci_data[$_ci_val];
	747	}
	748
	749	$file_exists = FALSE;
	750
	751	// Set the path to the requested file
	752	if ($_ci_path != '')
	753	{
	754	$_ci_x = explode('/', $_ci_path);
	755	$_ci_file = end($_ci_x);
	756	}
	757	else
	758	{
	759	$_ci_ext = pathinfo($_ci_view, PATHINFO_EXTENSION);
	760	$_ci_file = ($_ci_ext == '') ? $_ci_view.'.php' : $_ci_view;
	761
	762	foreach ($this->_ci_view_paths as $view_file => $cascade)
	763	{
	764	if (file_exists($view_file.$_ci_file))
	765	{
	766	$_ci_path = $view_file.$_ci_file;
	767	$file_exists = TRUE;
	768	break;
	769	}
	770
	771	if ( ! $cascade)
	772	{
	773	break;
	774	}
	775	}
	776	}
	777
	778	if ( ! $file_exists && ! file_exists($_ci_path))
	779	{
	780	show_error('Unable to load the requested file: '.$_ci_file);
	781	}
	782
	783	// This allows anything loaded using $this->load (views, files, etc.)
	784	// to become accessible from within the Controller and Model functions.
	785
	786	$_ci_CI =& get_instance();
	787	foreach (get_object_vars($_ci_CI) as $_ci_key => $_ci_var)
	788	{
	789	if ( ! isset($this->$_ci_key))
	790	{
	791	$this->$_ci_key =& $_ci_CI->$_ci_key;
	792	}
	793	}
	794
	795	/*
	796	* Extract and cache variables
	797	*
	798	* You can either set variables using the dedicated $this->load_vars()
	799	* function or via the second parameter of this function. We'll merge
	800	* the two types and cache them so that views that are embedded within
	801	* other views can have access to these variables.
	802	*/
	803	if (is_array($_ci_vars))
	804	{
	805	$this->_ci_cached_vars = array_merge($this->_ci_cached_vars, $_ci_vars);
	806	}
	807	extract($this->_ci_cached_vars);
	808
	809	/*
	810	* Buffer the output
	811	*
	812	* We buffer the output for two reasons:
	813	* 1. Speed. You get a significant speed boost.
	814	* 2. So that the final rendered template can be
	815	* post-processed by the output class. Why do we
	816	* need post processing? For one thing, in order to
	817	* show the elapsed page load time. Unless we
	818	* can intercept the content right before it's sent to
	819	* the browser and then stop the timer it won't be accurate.
	820	*/
	821	ob_start();
	822
	823	// If the PHP installation does not support short tags we'll
	824	// do a little string replacement, changing the short tags
	825	// to standard PHP echo statements.
	826
	827	if ((bool) @ini_get('short_open_tag') === FALSE AND config_item('rewrite_short_tags') == TRUE)
	828	{
	829	echo eval('?>'.preg_replace("/;\s\?>/", "; ?>", str_replace('<?=', '<?php echo ', file_get_contents($_ci_path))));
	830	}
	831	else
	832	{
	833	include($_ci_path); // include() vs include_once() allows for multiple views with the same name
	834	}
	835
	836	log_message('debug', 'File loaded: '.$_ci_path);
	837
	838	// Return the file data if requested
	839	if ($_ci_return === TRUE)
	840	{
	841	$buffer = ob_get_contents();
	842	@ob_end_clean();
	843	return $buffer;
	844	}
	845
	846	/*
	847	* Flush the buffer... or buff the flusher?
	848	*
	849	* In order to permit views to be nested within
	850	* other views, we need to flush the content back out whenever
	851	* we are beyond the first level of output buffering so that
	852	* it can be seen and included properly by the first included
	853	* template and any subsequent ones. Oy!
	854	*
	855	*/
	856	if (ob_get_level() > $this->_ci_ob_level + 1)
	857	{
	858	ob_end_flush();
	859	}
	860	else
	861	{
	862	$_ci_CI->output->append_output(ob_get_contents());
	863	@ob_end_clean();
	864	}
	865	}
	866
	867	// --------------------------------------------------------------------
	868
	869	/**
	870	* Load class
	871	*
	872	* This function loads the requested class.
	873	*
	874	* @param string the item that is being loaded
	875	* @param mixed any additional parameters
	876	* @param string an optional object name
	877	* @return void
	878	*/
	879	protected function _ci_load_class($class, $params = NULL, $object_name = NULL)
	880	{
	881	// Get the class name, and while we're at it trim any slashes.
	882	// The directory path can be included as part of the class name,
	883	// but we don't want a leading slash
	884	$class = str_replace('.php', '', trim($class, '/'));
	885
	886	// Was the path included with the class name?
	887	// We look for a slash to determine this
	888	$subdir = '';
	889	if (($last_slash = strrpos($class, '/')) !== FALSE)
	890	{
	891	// Extract the path
	892	$subdir = substr($class, 0, $last_slash + 1);
	893
	894	// Get the filename from the path
	895	$class = substr($class, $last_slash + 1);
	896	}
	897
	898	// We'll test for both lowercase and capitalized versions of the file name
	899	foreach (array(ucfirst($class), strtolower($class)) as $class)
	900	{
	901	$subclass = APPPATH.'libraries/'.$subdir.config_item('subclass_prefix').$class.'.php';
	902
	903	// Is this a class extension request?
	904	if (file_exists($subclass))
	905	{
	906	$baseclass = BASEPATH.'libraries/'.ucfirst($class).'.php';
	907
	908	if ( ! file_exists($baseclass))
	909	{
	910	log_message('error', "Unable to load the requested class: ".$class);
	911	show_error("Unable to load the requested class: ".$class);
	912	}
	913
	914	// Safety: Was the class already loaded by a previous call?
	915	if (in_array($subclass, $this->_ci_loaded_files))
	916	{
	917	// Before we deem this to be a duplicate request, let's see
	918	// if a custom object name is being supplied. If so, we'll
	919	// return a new instance of the object
	920	if ( ! is_null($object_name))
	921	{
	922	$CI =& get_instance();
	923	if ( ! isset($CI->$object_name))
	924	{
	925	return $this->_ci_init_class($class, config_item('subclass_prefix'), $params, $object_name);
	926	}
	927	}
	928
	929	$is_duplicate = TRUE;
	930	log_message('debug', $class." class already loaded. Second attempt ignored.");
	931	return;
	932	}
	933
	934	include_once($baseclass);
	935	include_once($subclass);
	936	$this->_ci_loaded_files[] = $subclass;
	937
	938	return $this->_ci_init_class($class, config_item('subclass_prefix'), $params, $object_name);
	939	}
	940
	941	// Lets search for the requested library file and load it.
	942	$is_duplicate = FALSE;
	943	foreach ($this->_ci_library_paths as $path)
	944	{
	945	$filepath = $path.'libraries/'.$subdir.$class.'.php';
	946
	947	// Does the file exist? No? Bummer...
	948	if ( ! file_exists($filepath))
	949	{
	950	continue;
	951	}
	952
	953	// Safety: Was the class already loaded by a previous call?
	954	if (in_array($filepath, $this->_ci_loaded_files))
	955	{
	956	// Before we deem this to be a duplicate request, let's see
	957	// if a custom object name is being supplied. If so, we'll
	958	// return a new instance of the object
	959	if ( ! is_null($object_name))
	960	{
	961	$CI =& get_instance();
	962	if ( ! isset($CI->$object_name))
	963	{
	964	return $this->_ci_init_class($class, '', $params, $object_name);
	965	}
	966	}
	967
	968	$is_duplicate = TRUE;
	969	log_message('debug', $class." class already loaded. Second attempt ignored.");
	970	return;
	971	}
	972
	973	include_once($filepath);
	974	$this->_ci_loaded_files[] = $filepath;
	975	return $this->_ci_init_class($class, '', $params, $object_name);
	976	}
	977
	978	} // END FOREACH
	979
	980	// One last attempt. Maybe the library is in a subdirectory, but it wasn't specified?
	981	if ($subdir == '')
	982	{
	983	$path = strtolower($class).'/'.$class;
	984	return $this->_ci_load_class($path, $params);
	985	}
	986
	987	// If we got this far we were unable to find the requested class.
	988	// We do not issue errors if the load call failed due to a duplicate request
	989	if ($is_duplicate == FALSE)
	990	{
	991	log_message('error', "Unable to load the requested class: ".$class);
	992	show_error("Unable to load the requested class: ".$class);
	993	}
	994	}
	995
	996	// --------------------------------------------------------------------
	997
	998	/**
	999	* Instantiates a class
	1000	*
	1001	* @param string
	1002	* @param string
	1003	* @param bool
	1004	* @param string an optional object name
	1005	* @return null
	1006	*/
	1007	protected function _ci_init_class($class, $prefix = '', $config = FALSE, $object_name = NULL)
	1008	{
	1009	// Is there an associated config file for this class? Note: these should always be lowercase
	1010	if ($config === NULL)
	1011	{
	1012	// Fetch the config paths containing any package paths
	1013	$config_component = $this->_ci_get_component('config');
	1014
	1015	if (is_array($config_component->_config_paths))
	1016	{
	1017	// Break on the first found file, thus package files
	1018	// are not overridden by default paths
	1019	foreach ($config_component->_config_paths as $path)
	1020	{
	1021	// We test for both uppercase and lowercase, for servers that
	1022	// are case-sensitive with regard to file names. Check for environment
	1023	// first, global next
	1024	if (defined('ENVIRONMENT') AND file_exists($path .'config/'.ENVIRONMENT.'/'.strtolower($class).'.php'))
	1025	{
	1026	include($path .'config/'.ENVIRONMENT.'/'.strtolower($class).'.php');
	1027	break;
	1028	}
	1029	elseif (defined('ENVIRONMENT') AND file_exists($path .'config/'.ENVIRONMENT.'/'.ucfirst(strtolower($class)).'.php'))
	1030	{
	1031	include($path .'config/'.ENVIRONMENT.'/'.ucfirst(strtolower($class)).'.php');
	1032	break;
	1033	}
	1034	elseif (file_exists($path .'config/'.strtolower($class).'.php'))
	1035	{
	1036	include($path .'config/'.strtolower($class).'.php');
	1037	break;
	1038	}
	1039	elseif (file_exists($path .'config/'.ucfirst(strtolower($class)).'.php'))
	1040	{
	1041	include($path .'config/'.ucfirst(strtolower($class)).'.php');
	1042	break;
	1043	}
	1044	}
	1045	}
	1046	}
	1047
	1048	if ($prefix == '')
	1049	{
	1050	if (class_exists('CI_'.$class))
	1051	{
	1052	$name = 'CI_'.$class;
	1053	}
	1054	elseif (class_exists(config_item('subclass_prefix').$class))
	1055	{
	1056	$name = config_item('subclass_prefix').$class;
	1057	}
	1058	else
	1059	{
	1060	$name = $class;
	1061	}
	1062	}
	1063	else
	1064	{
	1065	$name = $prefix.$class;
	1066	}
	1067
	1068	// Is the class name valid?
	1069	if ( ! class_exists($name))
	1070	{
	1071	log_message('error', "Non-existent class: ".$name);
	1072	show_error("Non-existent class: ".$class);
	1073	}
	1074
	1075	// Set the variable name we will assign the class to
	1076	// Was a custom class name supplied? If so we'll use it
	1077	$class = strtolower($class);
	1078
	1079	if (is_null($object_name))
	1080	{
	1081	$classvar = ( ! isset($this->_ci_varmap[$class])) ? $class : $this->_ci_varmap[$class];
	1082	}
	1083	else
	1084	{
	1085	$classvar = $object_name;
	1086	}
	1087
	1088	// Save the class name and object name
	1089	$this->_ci_classes[$class] = $classvar;
	1090
	1091	// Instantiate the class
	1092	$CI =& get_instance();
	1093	if ($config !== NULL)
	1094	{
	1095	$CI->$classvar = new $name($config);
	1096	}
	1097	else
	1098	{
	1099	$CI->$classvar = new $name;
	1100	}
	1101	}
	1102
	1103	// --------------------------------------------------------------------
	1104
	1105	/**
	1106	* Autoloader
	1107	*
	1108	* The config/autoload.php file contains an array that permits sub-systems,
	1109	* libraries, and helpers to be loaded automatically.
	1110	*
	1111	* @param array
	1112	* @return void
	1113	*/
	1114	private function _ci_autoloader()
	1115	{
	1116	if (defined('ENVIRONMENT') AND file_exists(APPPATH.'config/'.ENVIRONMENT.'/autoload.php'))
	1117	{
	1118	include(APPPATH.'config/'.ENVIRONMENT.'/autoload.php');
	1119	}
	1120	else
	1121	{
	1122	include(APPPATH.'config/autoload.php');
	1123	}
	1124
	1125	if ( ! isset($autoload))
	1126	{
	1127	return FALSE;
	1128	}
	1129
	1130	// Autoload packages
	1131	if (isset($autoload['packages']))
	1132	{
	1133	foreach ($autoload['packages'] as $package_path)
	1134	{
	1135	$this->add_package_path($package_path);
	1136	}
	1137	}
	1138
	1139	// Load any custom config file
	1140	if (count($autoload['config']) > 0)
	1141	{
	1142	$CI =& get_instance();
	1143	foreach ($autoload['config'] as $key => $val)
	1144	{
	1145	$CI->config->load($val);
	1146	}
	1147	}
	1148
	1149	// Autoload helpers and languages
	1150	foreach (array('helper', 'language') as $type)
	1151	{
	1152	if (isset($autoload[$type]) AND count($autoload[$type]) > 0)
	1153	{
	1154	$this->$type($autoload[$type]);
	1155	}
	1156	}
	1157
	1158	// A little tweak to remain backward compatible
	1159	// The $autoload['core'] item was deprecated
	1160	if ( ! isset($autoload['libraries']) AND isset($autoload['core']))
	1161	{
	1162	$autoload['libraries'] = $autoload['core'];
	1163	}
	1164
	1165	// Load libraries
	1166	if (isset($autoload['libraries']) AND count($autoload['libraries']) > 0)
	1167	{
	1168	// Load the database driver.
	1169	if (in_array('database', $autoload['libraries']))
	1170	{
	1171	$this->database();
	1172	$autoload['libraries'] = array_diff($autoload['libraries'], array('database'));
	1173	}
	1174
	1175	// Load all other libraries
	1176	foreach ($autoload['libraries'] as $item)
	1177	{
	1178	$this->library($item);
	1179	}
	1180	}
	1181
	1182	// Autoload models
	1183	if (isset($autoload['model']))
	1184	{
	1185	$this->model($autoload['model']);
	1186	}
	1187	}
	1188
	1189	// --------------------------------------------------------------------
	1190
	1191	/**
	1192	* Object to Array
	1193	*
	1194	* Takes an object as input and converts the class variables to array key/vals
	1195	*
	1196	* @param object
	1197	* @return array
	1198	*/
	1199	protected function _ci_object_to_array($object)
	1200	{
	1201	return (is_object($object)) ? get_object_vars($object) : $object;
	1202	}
	1203
	1204	// --------------------------------------------------------------------
	1205
	1206	/**
	1207	* Get a reference to a specific library or model
	1208	*
	1209	* @param string
	1210	* @return bool
	1211	*/
	1212	protected function &_ci_get_component($component)
	1213	{
	1214	$CI =& get_instance();
	1215	return $CI->$component;
	1216	}
	1217
	1218	// --------------------------------------------------------------------
	1219
	1220	/**
	1221	* Prep filename
	1222	*
	1223	* This function preps the name of various items to make loading them more reliable.
	1224	*
	1225	* @param mixed
	1226	* @param string
	1227	* @return array
	1228	*/
	1229	protected function _ci_prep_filename($filename, $extension)
	1230	{
	1231	if ( ! is_array($filename))
	1232	{
	1233	return array(strtolower(str_replace('.php', '', str_replace($extension, '', $filename)).$extension));
	1234	}
	1235	else
	1236	{
	1237	foreach ($filename as $key => $val)
	1238	{
	1239	$filename[$key] = strtolower(str_replace('.php', '', str_replace($extension, '', $val)).$extension);
	1240	}
	1241
	1242	return $filename;
	1243	}
	1244	}
	1245	}
	1246
	1247	/* End of file Loader.php */
	1248	/* Location: ./system/core/Loader.php */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: pro-violet-viettel/sourcecode/system/core/Loader.php @ 672

Download in other formats: