Source for file basemodel.php

Documentation is available at basemodel.php

  1. <?php
  2. /**
  3.  * This application is free software; you can redistribute
  4.  * it and/or modify it under the terms of the GNU
  5.  * General Public License as published by the Free
  6.  * Software Foundation; either version 3 of the License,
  7.  * or (at your option) any later version.
  8.  * 
  9.  * This application is distributed in the hope that it will
  10.  * be useful, but WITHOUT ANY WARRANTY; without even the
  11.  * implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU General Public
  13.  * License for more details.
  14.  *
  15.  *
  16.  * @author Andrew Judd <contact@andrewjudd.ca>
  17.  * @copyright Andrew Judd, 2010
  18.  * @license http://www.gnu.org/licenses/gpl-3.0.txt GPLv3
  19.  *
  20.  * @project Mini MVC
  21.  * @name app/models/basemodel.php
  22.  * @description This class acts as a base line class for the creation of any
  23.  *               future models which are made.  It will provide a load
  24.  *               library function which will automatically create an instance
  25.  *               of the library.
  26.  */
  27.  
  28. /* Check if attempting for direct access */
  29. if !defined '__FULLPATH__' ) )
  30. {
  31.     die header 'HTTP/1.0 404 Not Found' ) );
  32. }
  33.  
  34. abstract class BaseModel extends Base
  35. {
  36.     public function __construct ()
  37.     {
  38.         /* If there are any database connections, set them up */
  39.         if isset Base::$config Base::DATABASE ) )
  40.         {
  41.             /* Enforce an array of arrays for databases */
  42.             foreach Base::$config Base::DATABASE as $key => $value )
  43.             {
  44.                 /* Check if the connection has been made */
  45.                 if !isset Base::$db_conns $key ) )
  46.                 {
  47.                     /* Hasn't been set, so create it */
  48.                     $this -> __loadLibrary 'database'$value );
  49.  
  50.                     /* Move it from the default location to where it will reside */
  51.                     Base::$db_conns $key $this -> database;
  52.  
  53.                     /* Remove the default pointer to it */
  54.                     unset $this -> database );
  55.                 }
  56.  
  57.                 /* Make a local copy of it */
  58.                 $this -> $key Base::$db_conns $key ];
  59.             }
  60.         }
  61.  
  62.     }
  63.  
  64.     /**
  65.      * This function can be used anywhere in order to load a specific library
  66.      * in order to allow it to be used later on.
  67.      * @param string $library - The name of the library to load
  68.      * @param array $params - The parameters for the constructor of the object
  69.      * @returns boolean - TRUE if the library has been loaded, FALSE otherwise
  70.      */
  71.     public function __loadLibrary $library$params array () )
  72.     {
  73.         /* Firstly, check the system libraries */
  74.         $chkPath __SYSTEMLIBS__ strtolower $library '.php';
  75.  
  76.         /* Check if the file exists */
  77.         if file_exists $chkPath == true )
  78.         {
  79.              /* Then load the system library */
  80.              require_once $chkPath );
  81.         }
  82.         else
  83.         {
  84.             /* 
  85.              * Otherwise, it isn't a system library, so look in the user library
  86.              * folder.
  87.              */
  88.             $chkPath __USERLIBS__ $library '.php';
  89.  
  90.             /* Check if the file exists */
  91.             if file_exists $chkPath == true )
  92.             {
  93.                 /* Then load the library */
  94.                 require_once $chkPath );
  95.             }
  96.             else
  97.             {
  98.                 /* It doesn't exist, so add it to the list of error messages */
  99.                 Base::$errors [sprintf Base::$errorMessages 'invalidlibrary' ],
  100.                     $library );
  101.  
  102.                 return false );
  103.             }
  104.         }
  105.  
  106.         /* Create the instance */
  107.         $class new ReflectionClass $library );
  108.         $this -> $library $class -> newInstanceArgs $params );
  109.  
  110.         return true );
  111.     }
  112.  
  113.     /**
  114.      * This function is used statically in order to load any of the models
  115.      * required for the application. The models can either be passed into
  116.      * this function one by one or as an array.  If they are passed in as
  117.      * an array, each on of them is included sequentially.
  118.      * @param array/string $models - The single or array of models to use
  119.      */
  120.     public function __loadModel $models )
  121.     {
  122.         /* Make sure to include the abstract class */
  123.         require_once __MODELS__ 'basemodel.php' );
  124.  
  125.         /* Check if an array of models has been provided */
  126.         if is_array $models ) )
  127.         {
  128.             /* An array has been provided */
  129.             foreach $models as $key => $model )
  130.             {
  131.                 /* Check if the file exists */
  132.                 $chkFile __MODELS__ strtolower $model '.php';
  133.  
  134.                 /* Make sure the file exists */
  135.                 if file_exists $chkFile ) )
  136.                 {
  137.                     /* Model existed */
  138.                     require_once $chkFile );
  139.  
  140.                     /* Instantiate the model */
  141.                     $this -> $model new $model ();
  142.                 }
  143.                 /* Otherwise, it was an invalid model */
  144.                 else
  145.                 {
  146.                     /* Provide an error */
  147.                     Base::$errors [sprintf Base::$errorMessages
  148.                         'modelfilenotfound' ]$model__MODELS__ );
  149.                 }
  150.             }
  151.         }
  152.         /* Otherwise only one file */
  153.         else
  154.         {
  155.             /* Check if the file exists */
  156.             $chkFile __MODELS__ $model '.php';
  157.  
  158.             /* Make sure the file exists */
  159.             if file_exists $chkFile ) )
  160.             {
  161.                 /* Model existed */
  162.                 require_once $chkFile );
  163.  
  164.                 $this -> $model new $model ();
  165.             }
  166.             /* Otherwise, it was an invalid model */
  167.             else
  168.             {
  169.                 /* Provide an error */
  170.                 Base::$errors [sprintf Base::$errorMessages
  171.                     'modelfilenotfound' ]$model__MODELS__ );
  172.             }
  173.         }
  174.     }
  175.  
  176. }

Documentation generated on Thu, 01 Jul 2010 20:37:14 -0400 by phpDocumentor 1.4.3