Source for file jConfig.class.php

Documentation is available at jConfig.class.php

  1. <?php
  2. /**
  3. * @package  jelix
  4. * @subpackage core
  5. * @author   Laurent Jouanneau
  6. * @copyright 2005-2013 Laurent Jouanneau
  7. * @link        http://www.jelix.org
  8. * @licence  GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  9. */
  10.  
  11. /**
  12.  * static class which loads the configuration
  13.  * @package  jelix
  14.  * @subpackage core
  15.  * @static
  16.  */
  17. class jConfig {
  18.  
  19.     /**
  20.      * indicate if the configuration was loading from the cache (true) or
  21.      * if the cache configuration was regenerated (false)
  22.      */
  23.     public static $fromCache = true;
  24.  
  25.     /**
  26.      * this is a static class, so private constructor
  27.      */
  28.     private function __construct (){ }
  29.  
  30.     /**
  31.      * load and read the configuration of the application
  32.      * The combination of all configuration files (the given file
  33.      * and the defaultconfig.ini.php) is stored
  34.      * in a single temporary file. So it calls the jConfigCompiler
  35.      * class if needed
  36.      * @param string $configFile the config file name
  37.      * @return object it contains all configuration options
  38.      * @see jConfigCompiler
  39.      */
  40.     static public function load($configFile){
  41.         $config=array();
  42.         $file = jApp::tempPath().str_replace('/','~',$configFile);
  43.  
  44.         if (BYTECODE_CACHE_EXISTS)
  45.             $file .= '.conf.php';
  46.         else
  47.             $file .= '.resultini.php';
  48.  
  49.         self::$fromCache = true;
  50.         if(!file_exists($file)){
  51.             // no cache, let's compile
  52.             self::$fromCache = false;
  53.         }else{
  54.             $t = filemtime($file);
  55.             $dc = jApp::configPath('defaultconfig.ini.php');
  56.             if( (file_exists($dc) && filemtime($dc)>$t)
  57.                 || filemtime(jApp::configPath($configFile))>$t){
  58.                 // one of the two config file have been modified: let's compile
  59.                 self::$fromCache = false;
  60.             }else{
  61.  
  62.                 // let's read the cache file
  63.                 if(BYTECODE_CACHE_EXISTS){
  64.                     include($file);
  65.                     $config = (object) $config;
  66.                 }else{
  67.                     $config = jelix_read_ini($file);
  68.                 }
  69.  
  70.                 // we check all directories to see if it has been modified
  71.                 if($config->compilation['checkCacheFiletime']){
  72.                     foreach($config->_allBasePath as $path){
  73.                         if(!file_exists($path) || filemtime($path)>$t){
  74.                             self::$fromCache = false;
  75.                             break;
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.         }
  81.         if(!self::$fromCache){
  82.             require_once(JELIX_LIB_CORE_PATH.'jConfigCompiler.class.php');
  83.             return jConfigCompiler::readAndCache($configFile);
  84.         }else
  85.             return $config;
  86.     }
  87. }

Documentation generated on Wed, 04 Jan 2017 22:52:31 +0100 by phpDocumentor 1.4.3