Source for file jProfiles.class.php

Documentation is available at jProfiles.class.php

  1. <?php
  2. /**
  3. * @package     jelix
  4. * @subpackage  utils
  5. * @author      Laurent Jouanneau
  6. * @contributor Yannick Le Guédart, Julien Issler
  7. * @copyright   2011-2012 Laurent Jouanneau, 2007 Yannick Le Guédart, 2011 Julien Issler
  8. * @link        http://jelix.org
  9. * @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  10. */
  11.  
  12. /**
  13. * class to read profiles from the profiles.ini.php
  14. * @package     jelix
  15. * @subpackage  utils
  16. */
  17. class jProfiles {
  18.  
  19.     /**
  20.      * loaded profiles
  21.      * @var array 
  22.      */
  23.     protected static $_profiles = null;
  24.  
  25.     /**
  26.      * pool of objects loaded for profiles
  27.      * @var array   array of object
  28.      */
  29.     protected static $_objectPool = array();
  30.  
  31.  
  32.     protected static function loadProfiles() {
  33.         $file = jApp::configPath('profiles.ini.php');
  34.         self::$_profiles = parse_ini_file($file, true);
  35.     }
  36.  
  37.     /**
  38.     * load properties of a profile.
  39.     *
  40.     * A profile is a section in the profiles.ini.php file. Profiles are belong
  41.     * to a category. Each section names is composed by "category:profilename".
  42.     *
  43.     * The given name can be a profile name or an alias of a profile. An alias
  44.     * is a parameter name in the category section of the ini file, and the value
  45.     * of this parameter should be a profile name.
  46.     *
  47.     * @param string $category     the profile category
  48.     * @param string   $name  profile name or alias of a profile name. if empty, use the default profile
  49.     * @param boolean  $noDefault  if true and if the profile doesn't exist, throw an error instead of getting the default profile
  50.     * @return array  properties
  51.     */
  52.     public static function get ($category, $name='', $noDefault = false) {
  53.         if (self::$_profiles === null) {
  54.             self::loadProfiles();
  55.         }
  56.  
  57.         if ($name == '')
  58.             $name = 'default';
  59.         $section = $category.':'.$name;
  60.         $targetName = $section;
  61.  
  62.         if (isset(self::$_profiles[$category.':__common__'])) {
  63.             $common = self::$_profiles[$category.':__common__'];
  64.         }
  65.         else
  66.             $common = null;
  67.  
  68.         // the name attribute created in this method will be the name of the connection
  69.         // in the connections pool. So profiles of aliases and real profiles should have
  70.         // the same name attribute.
  71.  
  72.         if (isset(self::$_profiles[$section])) {
  73.             self::$_profiles[$section]['_name'] = $name;
  74.             if ($common)
  75.                 return array_merge($common, self::$_profiles[$section]);
  76.             return self::$_profiles[$section];
  77.         }
  78.         else if (isset(self::$_profiles[$category][$name])) {
  79.             // it is an alias
  80.             $name = self::$_profiles[$category][$name];
  81.             $targetName = $category.':'.$name;
  82.         }
  83.         // if the profile doesn't exist, we take the default one
  84.         elseif (!$noDefault) {
  85.             if (isset(self::$_profiles[$category.':default'])) {
  86.                 self::$_profiles[$category.':default']['_name'] = 'default';
  87.                 if ($common)
  88.                     return array_merge($common, self::$_profiles[$category.':default']);
  89.                 return self::$_profiles[$category.':default'];
  90.             }
  91.             elseif (isset(self::$_profiles[$category]['default'])) {
  92.                 $name = self::$_profiles[$category]['default'];
  93.                 $targetName = $category.':'.$name;
  94.             }
  95.         }
  96.         else {
  97.             if ($name == 'default')
  98.                 throw new jException('jelix~errors.profile.default.unknown', $category);
  99.             else
  100.                 throw new jException('jelix~errors.profile.unknown',array($name, $category));
  101.         }
  102.  
  103.         if (isset(self::$_profiles[$targetName]) && is_array(self::$_profiles[$targetName])) {
  104.             self::$_profiles[$targetName]['_name'] = $name;
  105.             if ($common)
  106.                 return array_merge($common, self::$_profiles[$targetName]);
  107.             return self::$_profiles[$targetName];
  108.         }
  109.         else {
  110.             throw new jException('jelix~errors.profile.unknown', array($name, $category));
  111.         }
  112.     }
  113.  
  114.     /**
  115.      * add an object in the objects pool, corresponding to a profile
  116.      * @param string $category the profile category
  117.      * @param string $name the name of the profile  (value of _name in the retrieved profile)
  118.      * @param object $obj the object to store
  119.      */
  120.     public static function storeInPool($category, $name, $object) {
  121.         self::$_objectPool[$category][$name] = $object;
  122.     }
  123.  
  124.     /**
  125.      * store an object in the objects pool, corresponding to a profile
  126.      * @param string $category the profile category
  127.      * @param string $name the name of the profile (value of _name in the retrieved profile)
  128.      * @return object|nullthe stored object
  129.      */
  130.     public static function getFromPool($category, $name) {
  131.         if (isset(self::$_objectPool[$category][$name]))
  132.             return self::$_objectPool[$category][$name];
  133.         return null;
  134.     }
  135.  
  136.     /**
  137.      * add an object in the objects pool, corresponding to a profile
  138.      * or store the object retrieved from the function, which accepts a profile
  139.      * as parameter (array)
  140.      * @param string $category the profile category
  141.      * @param string $name the name of the profile (will be given to jProfiles::get)
  142.      * @param string|array $function the function name called to retrieved the object. It uses call_user_func.
  143.      * @param boolean  $noDefault  if true and if the profile doesn't exist, throw an error instead of getting the default profile
  144.      * @return object|nullthe stored object
  145.      */
  146.     public static function getOrStoreInPool($category, $name, $function, $nodefault=false) {
  147.         $profile = self::get($category, $name, $nodefault);
  148.         if (isset(self::$_objectPool[$category][$profile['_name']]))
  149.             return self::$_objectPool[$category][$profile['_name']];
  150.         $obj = call_user_func($function, $profile);
  151.         if ($obj)
  152.             self::$_objectPool[$category][$profile['_name']] = $obj;
  153.         return $obj;
  154.     }
  155.  
  156.  
  157.     /**
  158.      * create a temporary new profile
  159.      * @param string $category the profile category
  160.      * @param string $name the name of the profile
  161.      * @param array|string$params parameters of the profile. key=parameter name, value=parameter value.
  162.      *                       we can also indicate a name of an other profile, to create an alias
  163.      */
  164.     public static function createVirtualProfile ($category, $name, $params) {
  165.         if ($name == '') {
  166.            throw new jException('jelix~errors.profile.virtual.no.name', $category);
  167.         }
  168.  
  169.         if (self::$_profiles === null) {
  170.             self::loadProfiles();
  171.         }
  172.         if (is_string($params)) {
  173.             self::$_profiles[$category][$name] = $params;
  174.         }
  175.         else {
  176.             $params['_name'] = $name;
  177.             self::$_profiles[$category.':'.$name] = $params;
  178.         }
  179.         unset (self::$_objectPool[$category][$name]); // close existing connection with the same pool name
  180.         if (gc_enabled())
  181.             gc_collect_cycles();
  182.     }
  183.  
  184.     /**
  185.      * clear the loaded profiles to force to reload the profiles file.
  186.      * WARNING: it destroy all objects stored in the pool!
  187.      */
  188.     public static function clear() {
  189.         self::$_profiles = null;
  190.         self::$_objectPool = array();
  191.         if (gc_enabled())
  192.             gc_collect_cycles();
  193.     }
  194. }

Documentation generated on Wed, 04 Jan 2017 22:55:58 +0100 by phpDocumentor 1.4.3