MY Loader

Category:Libraries::Extended Made the BASEPATH and APPPATH changable [code] class MY_Loader extends CI_Loader {

    var $_ci_base_path        = '';
    var $_ci_app_path        = '';

    function CI_Loader()
{    
    parent::CI_Loader();
            $this->_ci_base_path = BASEPATH;
            $this->_ci_app_path = APPPATH
        $this->_ci_view_path = $this->_ci_app_path.'views/';    
    log_message('debug', "MY_Loader Class Initialized");
}

    function model($model, $name = '', $db_conn = FALSE)
{        
    if (is_array($model))
    {
        foreach($model as $babe)
        {
            $this->model($babe);    
        }
        return;
    }

    if ($model == '')
    {
        return;
    }

    // Is the model in a sub-folder? If so, parse out the filename and path.
    if (strpos($model, '/') === FALSE)
    {
        $path = '';
    }
    else
    {
        $x = explode('/', $model);
        $model = end($x);            
        unset($x[count($x)-1]);
        $path = implode('/', $x).'/';
    }

    if ($name == '')
    {
        $name = $model;
    }
    
    if (in_array($name, $this->_ci_models, TRUE))
    {
        return;
    }
    
    $CI =& get_instance();
    if (isset($CI->$name))
    {
        show_error('The model name you are loading is the name of a resource that is already being used: '.$name);
    }

    $model = strtolower($model);
    
    if ( ! file_exists($this->_ci_app_path.'models/'.$path.$model.EXT))
    {
        show_error('Unable to locate the model you have specified: '.$model);
    }
            
    if ($db_conn !== FALSE AND ! class_exists('CI_DB'))
    {
        if ($db_conn === TRUE)
            $db_conn = '';
    
        $CI->load->database($db_conn, FALSE, TRUE);
    }

    if ( ! class_exists('Model'))
    {
        load_class('Model', FALSE);
    }

    require_once($this->_ci_app_path.'models/'.$path.$model.EXT);

    $model = ucfirst($model);
            
    $CI->$name = new $model();
    $CI->$name->_assign_libraries();
    
    $this->_ci_models[] = $name;    
}

    function database($params = '', $return = FALSE, $active_record = FALSE)
{
    // Grab the super object
    $CI =& get_instance();
    
    // Do we even need to load the database class?
    if (class_exists('CI_DB') AND $return == FALSE AND $active_record == FALSE AND isset($CI->db) AND is_object($CI->db))
    {
        return FALSE;
    }    

    require_once($this->_ci_base_path.'database/DB'.EXT);

    if ($return === TRUE)
    {
        return DB($params, $active_record);
    }
    
    // Initialize the db variable.  Needed to prevent   
    // reference errors with some configurations
    $CI->db = '';
    
    // Load the DB class
    $CI->db =& DB($params, $active_record);    
    
    // Assign the DB object to any existing models
    $this->_ci_assign_to_models();
}

    function dbutil()
{
    if ( ! class_exists('CI_DB'))
    {
        $this->database();
    }
    
    $CI =& get_instance();

    // for backwards compatibility, load dbforge so we can extend dbutils off it
    // this use is deprecated and strongly discouraged
    $CI->load->dbforge();

    require_once($this->_ci_base_path.'database/DB_utility'.EXT);
    require_once($this->_ci_base_path.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_utility'.EXT);
    $class = 'CI_DB_'.$CI->db->dbdriver.'_utility';

    $CI->dbutil =& new $class();

    $CI->load->_ci_assign_to_models();
}

    function dbforge()
{
    if ( ! class_exists('CI_DB'))
    {
        $this->database();
    }
    
    $CI =& get_instance();

    require_once($this->_ci_base_path.'database/DB_forge'.EXT);
    require_once($this->_ci_base_path.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_forge'.EXT);
    $class = 'CI_DB_'.$CI->db->dbdriver.'_forge';

    $CI->dbforge = new $class();
}

    function helper($helpers = array())
{
    if ( ! is_array($helpers))
    {
        $helpers = array($helpers);
    }

    foreach ($helpers as $helper)
    {        
        $helper = strtolower(str_replace(EXT, '', str_replace('_helper', '', $helper)).'_helper');
    
        if (isset($this->_ci_helpers[$helper]))
        {
            continue;
        }
        
        $ext_helper = $this->_ci_app_path.'helpers/'.config_item('subclass_prefix').$helper.EXT;

        // Is this a helper extension request?            
        if (file_exists($ext_helper))
        {
            $base_helper = $this->_ci_base_path.'helpers/'.$helper.EXT;
            
            if ( ! file_exists($base_helper))
            {
                show_error('Unable to load the requested file: helpers/'.$helper.EXT);
            }
            
            include_once($ext_helper);
            include_once($base_helper);
        }
        elseif (file_exists($this->_ci_app_path.'helpers/'.$helper.EXT))
        { 
            include_once($this->_ci_app_path.'helpers/'.$helper.EXT);
        }
        else
        {        
            if (file_exists($this->_ci_base_path.'helpers/'.$helper.EXT))
            {
                include($this->_ci_base_path.'helpers/'.$helper.EXT);
            }
            else
            {
                show_error('Unable to load the requested file: helpers/'.$helper.EXT);
            }
        }

        $this->_ci_helpers[$helper] = TRUE;
        
    }
    
    log_message('debug', 'Helpers loaded: '.implode(', ', $helpers));
}

    function plugin($plugins = array())
{
    if ( ! is_array($plugins))
    {
        $plugins = array($plugins);
    }

    foreach ($plugins as $plugin)
    {    
        $plugin = strtolower(str_replace(EXT, '', str_replace('_pi', '', $plugin)).'_pi');        

        if (isset($this->_ci_plugins[$plugin]))
        {
            continue;
        }

        if (file_exists($this->_ci_app_path.'plugins/'.$plugin.EXT))
        {
            include($this->_ci_app_path.'plugins/'.$plugin.EXT);    
        }
        else
        {
            if (file_exists($this->_ci_base_path.'plugins/'.$plugin.EXT))
            {
                include($this->_ci_base_path.'plugins/'.$plugin.EXT);    
            }
            else
            {
                show_error('Unable to load the requested file: plugins/'.$plugin.EXT);
            }
        }
        
        $this->_ci_plugins[$plugin] = TRUE;
    }
    
    log_message('debug', 'Plugins loaded: '.implode(', ', $plugins));
}

    function script($scripts = array())
{
    if ( ! is_array($scripts))
    {
        $scripts = array($scripts);
    }

    foreach ($scripts as $script)
    {    
        $script = strtolower(str_replace(EXT, '', $script));

        if (isset($this->_ci_scripts[$script]))
        {
            continue;
        }
    
        if ( ! file_exists($this->_ci_app_path.'scripts/'.$script.EXT))
        {
            show_error('Unable to load the requested script: scripts/'.$script.EXT);
        }
        
        include($this->_ci_app_path.'scripts/'.$script.EXT);
    }
    
    log_message('debug', 'Scripts loaded: '.implode(', ', $scripts));
}

    function _ci_load_class($class, $params = NULL)
{    
    // Get the class name
    $class = str_replace(EXT, '', $class);

    // We'll test for both lowercase and capitalized versions of the file name
    foreach (array(ucfirst($class), strtolower($class)) as $class)
    {
        $subclass = $this->_ci_app_path.'libraries/'.config_item('subclass_prefix').$class.EXT;

        // Is this a class extension request?            
        if (file_exists($subclass))
        {
            $baseclass = $this->_ci_base_path.'libraries/'.ucfirst($class).EXT;
            
            if ( ! file_exists($baseclass))
            {
                log_message('error', "Unable to load the requested class: ".$class);
                show_error("Unable to load the requested class: ".$class);
            }

            // Safety:  Was the class already loaded by a previous call?
            if (in_array($subclass, $this->_ci_classes))
            {
                $is_duplicate = TRUE;
                log_message('debug', $class." class already loaded. Second attempt ignored.");
                return;
            }

            include($baseclass);                
            include($subclass);
            $this->_ci_classes[] = $subclass;

            return $this->_ci_init_class($class, config_item('subclass_prefix'), $params);            
        }
    
        // Lets search for the requested library file and load it.
        $is_duplicate = FALSE;        
        for ($i = 1; $i < 3; $i++)
        {
            $path = ($i % 2) ? $this->_ci_app_path : $this->_ci_base_path;    
            $filepath = $path.'libraries/'.$class.EXT;
            
            // Does the file exist?  No?  Bummer...
            if ( ! file_exists($filepath))
            {
                continue;
            }
            
            // Safety:  Was the class already loaded by a previous call?
            if (in_array($filepath, $this->_ci_classes))
            {
                $is_duplicate = TRUE;
                log_message('debug', $class." class already loaded. Second attempt ignored.");
                return;
            }
            
            include($filepath);
            $this->_ci_classes[] = $filepath;
            return $this->_ci_init_class($class, '', $params);
        }
    } // END FOREACH
    
    // If we got this far we were unable to find the requested class.
    // We do not issue errors if the load call failed due to a duplicate request
    if ($is_duplicate == FALSE)
    {
        log_message('error', "Unable to load the requested class: ".$class);
        show_error("Unable to load the requested class: ".$class);
    }
}

} [/code]