libraries/Loader.php

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