WebSVN – Applications.framework – Diff – /trunk/framework/Config.php


<?php
// declare(encoding='UTF-8');
/**
 * Config permet de charger automatiquement les fichiers ini du Framework et de l'application.
 * Elle offre l'accès en lecture seule aux paramètres de config.
 * C'est une Singleton.
 * Si vous avez besoin de modifier dynamiquement des paramètres de configuration, utiliser le @see Registe, il est fait pour ça.
 * 
 * @category	PHP 5.2
 * @package		Framework
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
 * @license		http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3
 * @license		http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2 
 * @version		SVN : $Id: Config.php 239 2010-11-25 18:04:00Z jpm $
 * @link		/doc/framework/
 */
 
class Config {
 
	/**
	 * instance de la classe pointant sur elle même (pour le pattern singleton)
	 */
	private static $instance = null;
 
	/**
	 * paramètres de configuration
	 */
	private static $parametres = array();
 
	/**
	 * Constructeur vide
	 */
	private function __construct() {
		// Définition de paramètres avant chargement du config.ini
		self::$parametres = array(
			'fw_fichier_config' => 'config%s.ini',
			'fw_chemin' => dirname(__FILE__).DS
			);
 
		// Chargement du fichier config.ini du Framework
		$existe = self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));
		if ($existe === false) {
			trigger_error("Veuillez configurer le Framework en renommant le fichier config.defaut.ini en config.ini.", E_USER_ERROR);
		}
 
		// Chargement du fichier config.ini par défaut de l'application
		$chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fw_fichier_config'], '');
		self::parserFichierIni($chemin_config_defaut_appli);
 
		// Chargement des fichiers config.ini contextuels
		if (PHP_SAPI == 'cli') {// mode console
			foreach ($_SERVER['argv'] as $cle => $valeur) {
				if ($valeur == '-contexte') {
					chargerFichierContexte($_SERVER['argv'][($cle+1)]);
					break;
				}
			}
		} else {// mode web
			// Pour Papyrus
			if (defined('PAP_VERSION')) {
				self::chargerFichierContexte('papyrus');
			}
			// Via le fichie .ini par défaut de l'appli
			if (Config::existeValeur('info.contexte', self::$parametres)) {
				self::chargerFichierContexte(Config::get('info.contexte'));
			}
 
			// Chargement du contexte présent dans le GET
			if (isset($_GET['contexte'])) {
				$_GET['contexte'] = strip_tags($_GET['contexte']);
				self::chargerFichierContexte($_GET['contexte']);
			}
 
			// Chargement du contexte présent dans le POST
			if (isset($_POST['contexte'])) {
				$_POST['contexte'] = strip_tags($_POST['contexte']);
				self::chargerFichierContexte($_POST['contexte']);
			}
		}
	}
 
	/**
	 * Charge le fichier de config correspondant au contexte
	 * @param string $contexte le contexte
	 */
	private static function chargerFichierContexte($contexte) {
		$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
		$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);
		self::parserFichierIni($chemin_config_appli_contextuel);
	}
 
	/**
	 * Parse le fichier ini donné en paramètre
	 * @param string $fichier_ini nom du fichier ini à parser
	 * @return array tableau contenant les paramètres du fichier ini
	 */
	private static function parserFichierIni($fichier_ini) {
		$retour = false;
		if (file_exists($fichier_ini)) {
			$ini = parse_ini_file($fichier_ini, true);
			$ini = self::analyserTableauIni($ini);
			self::fusionner($ini);
			$retour = true;
		}
		return $retour;
	}
 
	/**
	 * fusionne un tableau de paramètres avec le tableau de paramètres global
	 * @param array $ini le tableau à fusionner
	 */
	private static function fusionner(array $ini) {
		self::$parametres = array_merge(self::$parametres, $ini);
	}
 
	/**
	 * renvoie la valeur demandé grâce une chaine de paramètres
	 * @param string $param la chaine de paramètres
	 * @param array $config le tableau de paramètre
	 * @return string la valeur de la chaine demandée
	 */
	private static function getValeur($param, $config) {
		if ($param === null) {
			return null;
		} else {
			if (isset($config[$param])) {
				return $config[$param];
			} else if (strpos($param, '.') !== false) {
				$pieces = explode('.', $param, 2);
				if (strlen($pieces[0]) && strlen($pieces[1])) {
					if (isset($config[$pieces[0]])) {
					   if (is_array($config[$pieces[0]])) {
					   		return self::getValeur($pieces[1], $config[$pieces[0]]);
					   }
					}
				}
			} else {
				return null;
			}
		}
	}
 
	/**
	 * Teste si param existe dans le tableau config
	 * @param string $param nom du paramètre
	 * @param array tableau de configuration
	 */
	private static function existeValeur($param, $config) {
		$retour = false;
		if (self::getValeur($param, $config) !== null) {
			$retour = true;
		}
		return $retour;
	}
 
	/**
	 * Vérifie si l'instance de classe à été crée, si non la crée
	 */
	private static function verifierCreationInstance() {
		if (empty(self::$instance)) {
			self::$instance = new Config();
		}
	}
 
	/**
	 * analyse un tableau de paramètres
	 * @param array $config le tableau de paramètres
	 * @return array le tableau analysé
	 */
	private static function analyserTableauIni($config = array()) {
		foreach ($config as $cle => &$valeur) {
			if (is_array($valeur)) {
				$config[$cle] = self::analyserTableauIni($valeur);
			} else {
				self::evaluerReferences($config, $cle);
				self::evaluerPhp($config, $cle);
				self::evaluerCle($config, $cle, $config[$cle]);
			}
		}
		return $config;
	}
 
	/**
	 * dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)
	 * evalue les valeurs correspondantes et crée les sous tableaux associés
	 * @param array $config tableau de configuration (par référence)
	 * @param string $cle la cle dans le tableau
	 * @param string $valeur la valeur à affecter
	 */
	private static function evaluerCle(&$config, $cle, $valeur) {
		if (strpos($cle, '.') !== false) {
			unset($config[$cle]);
			$pieces = explode('.', $cle, 2);
			if (strlen($pieces[0]) && strlen($pieces[1])) {
				if (isset($config[$pieces[0]]) && !is_array($config[$pieces[0]])) {
					$m = "Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà";
					trigger_error($m, E_USER_WARNING);
				} else {
					$config[$pieces[0]][$pieces[1]] = $valeur;
					$config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);
				}
			} else {
				$m = "Clé invalide '$cle'";
				trigger_error($m, E_USER_WARNING);
			}
		} else {
			$config[$cle] = $valeur;
		}
		return $config;
	}
 
	/**
	 * Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle)
	 * @param array $config tableau de configuration
	 * @param string $cle la clé dont il faut évaluer les références
	 */
	private static function evaluerReferences(&$config, $cle) {
		if (preg_match_all('/{ref:([A-Za-z0-9_.-]+)}/', $config[$cle], $correspondances,  PREG_SET_ORDER)) {
			foreach ($correspondances as $ref) {
				$config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]);
			}
		}
	}
 
	/**
	 * Evalue le code php contenu dans un clé tu tableau config
	 * @param array $config tableau de configuration (par référence)
	 * @param string $cle le clé du tableau dont il faut évaluer la valeur
	 */
	private static function evaluerPhp(&$config, $cle) {
		if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {
			eval('$config["'.$cle.'"] = '.$correspondances[1].';');
		}
	}
 
	/**
	 * Charge un fichier ini dans le tableau des paramètres de l'appli
	 * @param string $fichier_ini le nom du fichier à charger
	 * @return array le fichier ini parsé
	 */
	public static function charger($fichier_ini) {
		self::verifierCreationInstance();
		return self::parserFichierIni($fichier_ini);
	}
 
	/**
	 * Acesseur pour la valeur d'un paramètre
	 * @param string $param le nom du paramètre
	 * @return string la valeur du paramètre
	 */
	public static function get($param = null) {
		self::verifierCreationInstance();
		return self::getValeur($param, self::$parametres);
	}
 
	/**
	 * Vérifie si la valeur d'un paramètre existe
	 * @param string $param le nom du paramètre
	 * @return boolean vrai si le paramètre existe, false sinon
	 */
	public static function existe($param) {
		self::verifierCreationInstance();
		return self::existeValeur($param, self::$parametres);
	}
}
?>

Subversion Repositories Applications.framework

(root)/trunk/framework/Config.php – Rev 203 → 239

Rev 203		Rev 239
1	`<?php`	1	`<?php`
2	`// declare(encoding='UTF-8');`	2	`// declare(encoding='UTF-8');`
3	`/**`	3	`/**`
4	`* Config permet de charger automatiquement les fichiers ini du Framework et de l'application.`	4	`* Config permet de charger automatiquement les fichiers ini du Framework et de l'application.`
5	`* Elle offre l'accès en lecture seule aux paramètres de config.`	5	`* Elle offre l'accès en lecture seule aux paramètres de config.`
6	`* C'est une Singleton.`	6	`* C'est une Singleton.`
-		7	`* Si vous avez besoin de modifier dynamiquement des paramètres de configuration, utiliser le @see Registe, il est fait pour ça.`
7	`*`	8	`*`
8	`* @category PHP 5.2`	9	`* @category PHP 5.2`
9	`* @package Framework`	10	`* @package Framework`
10	`* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>`	11	`* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>`
11	`* @copyright Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)`	12	`* @copyright Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)`
12	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3`	13	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3`
13	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2`	14	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2`
14	`* @version SVN : $Id: Config.php 203 2010-07-12 13:22:07Z jpm $`	15	`* @version SVN : $Id: Config.php 239 2010-11-25 18:04:00Z jpm $`
15	`* @link /doc/framework/`	16	`* @link /doc/framework/`
16	`*/`	17	`*/`
17		18
18	`class Config {`	19	`class Config {`
19		20
20	`/**`	21	`/**`
21	`* instance de la classe pointant sur elle même (pour le pattern singleton)`	22	`* instance de la classe pointant sur elle même (pour le pattern singleton)`
22	`*/`	23	`*/`
23	`private static $instance = null;`	24	`private static $instance = null;`
24		25
25	`/**`	26	`/**`
26	`* paramètres de configuration`	27	`* paramètres de configuration`
27	`*/`	28	`*/`
28	`private static $parametres = array();`	29	`private static $parametres = array();`
29		30
30	`/**`	31	`/**`
31	`* Constructeur vide`	32	`* Constructeur vide`
32	`*/`	33	`*/`
33	`private function __construct() {`	34	`private function __construct() {`
34	`// Définition de paramètres avant chargement du config.ini`	35	`// Définition de paramètres avant chargement du config.ini`
35	`self::$parametres = array(`	36	`self::$parametres = array(`
36	`'fw_fichier_config' => 'config%s.ini',`	37	`'fw_fichier_config' => 'config%s.ini',`
37	`'fw_chemin' => dirname(__FILE__).DS`	38	`'fw_chemin' => dirname(__FILE__).DS`
38	`);`	39	`);`
39		40
40	`// Chargement du fichier config.ini du Framework`	41	`// Chargement du fichier config.ini du Framework`
41	`$existe = self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));`	42	`$existe = self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));`
42	`if ($existe === false) {`	43	`if ($existe === false) {`
43	`trigger_error("Veuillez configurer le Framework en renommant le fichier config.defaut.ini en config.ini.", E_USER_ERROR);`	44	`trigger_error("Veuillez configurer le Framework en renommant le fichier config.defaut.ini en config.ini.", E_USER_ERROR);`
44	`}`	45	`}`
45		46
46	`// Chargement du fichier config.ini par défaut de l'application`	47	`// Chargement du fichier config.ini par défaut de l'application`
47	`$chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fw_fichier_config'], '');`	48	`$chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fw_fichier_config'], '');`
48	`self::parserFichierIni($chemin_config_defaut_appli);`	49	`self::parserFichierIni($chemin_config_defaut_appli);`
49		50
50	`// Chargement des fichiers config.ini contextuels`	51	`// Chargement des fichiers config.ini contextuels`
51	`if (PHP_SAPI == 'cli') {// mode console`	52	`if (PHP_SAPI == 'cli') {// mode console`
52	`foreach ($_SERVER['argv'] as $cle => $valeur) {`	53	`foreach ($_SERVER['argv'] as $cle => $valeur) {`
53	`if ($valeur == '-contexte') {`	54	`if ($valeur == '-contexte') {`
54	`chargerFichierContexte($_SERVER['argv'][($cle+1)]);`	55	`chargerFichierContexte($_SERVER['argv'][($cle+1)]);`
55	`break;`	56	`break;`
56	`}`	57	`}`
57	`}`	58	`}`
58	`} else {// mode web`	59	`} else {// mode web`
59	`// Pour Papyrus`	60	`// Pour Papyrus`
60	`if (defined('PAP_VERSION')) {`	61	`if (defined('PAP_VERSION')) {`
61	`self::chargerFichierContexte('papyrus');`	62	`self::chargerFichierContexte('papyrus');`
62	`}`	63	`}`
63	`// Via le fichie .ini par défaut de l'appli`	64	`// Via le fichie .ini par défaut de l'appli`
64	`if (Config::existeValeur('info.contexte', self::$parametres)) {`	65	`if (Config::existeValeur('info.contexte', self::$parametres)) {`
65	`self::chargerFichierContexte(Config::get('info.contexte'));`	66	`self::chargerFichierContexte(Config::get('info.contexte'));`
66	`}`	67	`}`
67		68
68	`// Chargement du contexte présent dans le GET`	69	`// Chargement du contexte présent dans le GET`
69	`if (isset($_GET['contexte'])) {`	70	`if (isset($_GET['contexte'])) {`
70	`$_GET['contexte'] = strip_tags($_GET['contexte']);`	71	`$_GET['contexte'] = strip_tags($_GET['contexte']);`
71	`self::chargerFichierContexte($_GET['contexte']);`	72	`self::chargerFichierContexte($_GET['contexte']);`
72	`}`	73	`}`
73		74
74	`// Chargement du contexte présent dans le POST`	75	`// Chargement du contexte présent dans le POST`
75	`if (isset($_POST['contexte'])) {`	76	`if (isset($_POST['contexte'])) {`
76	`$_POST['contexte'] = strip_tags($_POST['contexte']);`	77	`$_POST['contexte'] = strip_tags($_POST['contexte']);`
77	`self::chargerFichierContexte($_POST['contexte']);`	78	`self::chargerFichierContexte($_POST['contexte']);`
78	`}`	79	`}`
79	`}`	80	`}`
80	`}`	81	`}`
81		82
82	`/**`	83	`/**`
83	`* Charge le fichier de config correspondant au contexte`	84	`* Charge le fichier de config correspondant au contexte`
84	`* @param string $contexte le contexte`	85	`* @param string $contexte le contexte`
85	`*/`	86	`*/`
86	`private static function chargerFichierContexte($contexte) {`	87	`private static function chargerFichierContexte($contexte) {`
87	`$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];`	88	`$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];`
88	`$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);`	89	`$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);`
89	`self::parserFichierIni($chemin_config_appli_contextuel);`	90	`self::parserFichierIni($chemin_config_appli_contextuel);`
90	`}`	91	`}`
91		92
92	`/**`	93	`/**`
93	`* Parse le fichier ini donné en paramètre`	94	`* Parse le fichier ini donné en paramètre`
94	`* @param string $fichier_ini nom du fichier ini à parser`	95	`* @param string $fichier_ini nom du fichier ini à parser`
95	`* @return array tableau contenant les paramètres du fichier ini`	96	`* @return array tableau contenant les paramètres du fichier ini`
96	`*/`	97	`*/`
97	`private static function parserFichierIni($fichier_ini) {`	98	`private static function parserFichierIni($fichier_ini) {`
98	`$retour = false;`	99	`$retour = false;`
99	`if (file_exists($fichier_ini)) {`	100	`if (file_exists($fichier_ini)) {`
100	`$ini = parse_ini_file($fichier_ini, true);`	101	`$ini = parse_ini_file($fichier_ini, true);`
101	`$ini = self::analyserTableauIni($ini);`	102	`$ini = self::analyserTableauIni($ini);`
102	`self::fusionner($ini);`	103	`self::fusionner($ini);`
103	`$retour = true;`	104	`$retour = true;`
104	`}`	105	`}`
105	`return $retour;`	106	`return $retour;`
106	`}`	107	`}`
107		108
108	`/**`	109	`/**`
109	`* fusionne un tableau de paramètres avec le tableau de paramètres global`	110	`* fusionne un tableau de paramètres avec le tableau de paramètres global`
110	`* @param array $ini le tableau à fusionner`	111	`* @param array $ini le tableau à fusionner`
111	`*/`	112	`*/`
112	`private static function fusionner(array $ini) {`	113	`private static function fusionner(array $ini) {`
113	`self::$parametres = array_merge(self::$parametres, $ini);`	114	`self::$parametres = array_merge(self::$parametres, $ini);`
114	`}`	115	`}`
115		116
116	`/**`	117	`/**`
117	`* renvoie la valeur demandé grâce une chaine de paramètres`	118	`* renvoie la valeur demandé grâce une chaine de paramètres`
118	`* @param string $param la chaine de paramètres`	119	`* @param string $param la chaine de paramètres`
119	`* @param array $config le tableau de paramètre`	120	`* @param array $config le tableau de paramètre`
120	`* @return string la valeur de la chaine demandée`	121	`* @return string la valeur de la chaine demandée`
121	`*/`	122	`*/`
122	`private static function getValeur($param, $config) {`	123	`private static function getValeur($param, $config) {`
123	`if ($param === null) {`	124	`if ($param === null) {`
124	`return null;`	125	`return null;`
125	`} else {`	126	`} else {`
126	`if (isset($config[$param])) {`	127	`if (isset($config[$param])) {`
127	`return $config[$param];`	128	`return $config[$param];`
128	`} else if (strpos($param, '.') !== false) {`	129	`} else if (strpos($param, '.') !== false) {`
129	`$pieces = explode('.', $param, 2);`	130	`$pieces = explode('.', $param, 2);`
130	`if (strlen($pieces[0]) && strlen($pieces[1])) {`	131	`if (strlen($pieces[0]) && strlen($pieces[1])) {`
131	`if (isset($config[$pieces[0]])) {`	132	`if (isset($config[$pieces[0]])) {`
132	`if (is_array($config[$pieces[0]])) {`	133	`if (is_array($config[$pieces[0]])) {`
133	`return self::getValeur($pieces[1], $config[$pieces[0]]);`	134	`return self::getValeur($pieces[1], $config[$pieces[0]]);`
134	`}`	135	`}`
135	`}`	136	`}`
136	`}`	137	`}`
137	`} else {`	138	`} else {`
138	`return null;`	139	`return null;`
139	`}`	140	`}`
140	`}`	141	`}`
141	`}`	142	`}`
142		143
143	`/**`	144	`/**`
144	`* Teste si param existe dans le tableau config`	145	`* Teste si param existe dans le tableau config`
145	`* @param string $param nom du paramètre`	146	`* @param string $param nom du paramètre`
146	`* @param array tableau de configuration`	147	`* @param array tableau de configuration`
147	`*/`	148	`*/`
148	`private static function existeValeur($param, $config) {`	149	`private static function existeValeur($param, $config) {`
149	`$retour = false;`	150	`$retour = false;`
150	`if (self::getValeur($param, $config) !== null) {`	151	`if (self::getValeur($param, $config) !== null) {`
151	`$retour = true;`	152	`$retour = true;`
152	`}`	153	`}`
153	`return $retour;`	154	`return $retour;`
154	`}`	155	`}`
155		156
156	`/**`	157	`/**`
157	`* Vérifie si l'instance de classe à été crée, si non la crée`	158	`* Vérifie si l'instance de classe à été crée, si non la crée`
158	`*/`	159	`*/`
159	`private static function verifierCreationInstance() {`	160	`private static function verifierCreationInstance() {`
160	`if (empty(self::$instance)) {`	161	`if (empty(self::$instance)) {`
161	`self::$instance = new Config();`	162	`self::$instance = new Config();`
162	`}`	163	`}`
163	`}`	164	`}`
164		165
165	`/**`	166	`/**`
166	`* analyse un tableau de paramètres`	167	`* analyse un tableau de paramètres`
167	`* @param array $config le tableau de paramètres`	168	`* @param array $config le tableau de paramètres`
168	`* @return array le tableau analysé`	169	`* @return array le tableau analysé`
169	`*/`	170	`*/`
170	`private static function analyserTableauIni($config = array()) {`	171	`private static function analyserTableauIni($config = array()) {`
171	`foreach ($config as $cle => &$valeur) {`	172	`foreach ($config as $cle => &$valeur) {`
172	`if (is_array($valeur)) {`	173	`if (is_array($valeur)) {`
173	`$config[$cle] = self::analyserTableauIni($valeur);`	174	`$config[$cle] = self::analyserTableauIni($valeur);`
174	`} else {`	175	`} else {`
175	`self::evaluerReferences($config, $cle);`	176	`self::evaluerReferences($config, $cle);`
176	`self::evaluerPhp($config, $cle);`	177	`self::evaluerPhp($config, $cle);`
177	`self::evaluerCle($config, $cle, $config[$cle]);`	178	`self::evaluerCle($config, $cle, $config[$cle]);`
178	`}`	179	`}`
179	`}`	180	`}`
180	`return $config;`	181	`return $config;`
181	`}`	182	`}`
182		183
183	`/**`	184	`/**`
184	`* dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)`	185	`* dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)`
185	`* evalue les valeurs correspondantes et crée les sous tableaux associés`	186	`* evalue les valeurs correspondantes et crée les sous tableaux associés`
186	`* @param array $config tableau de configuration (par référence)`	187	`* @param array $config tableau de configuration (par référence)`
187	`* @param string $cle la cle dans le tableau`	188	`* @param string $cle la cle dans le tableau`
188	`* @param string $valeur la valeur à affecter`	189	`* @param string $valeur la valeur à affecter`
189	`*/`	190	`*/`
190	`private static function evaluerCle(&$config, $cle, $valeur) {`	191	`private static function evaluerCle(&$config, $cle, $valeur) {`
191	`if (strpos($cle, '.') !== false) {`	192	`if (strpos($cle, '.') !== false) {`
192	`unset($config[$cle]);`	193	`unset($config[$cle]);`
193	`$pieces = explode('.', $cle, 2);`	194	`$pieces = explode('.', $cle, 2);`
194	`if (strlen($pieces[0]) && strlen($pieces[1])) {`	195	`if (strlen($pieces[0]) && strlen($pieces[1])) {`
195	`if (isset($config[$pieces[0]]) && !is_array($config[$pieces[0]])) {`	196	`if (isset($config[$pieces[0]]) && !is_array($config[$pieces[0]])) {`
196	`$m = "Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà";`	197	`$m = "Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà";`
197	`trigger_error($m, E_USER_WARNING);`	198	`trigger_error($m, E_USER_WARNING);`
198	`} else {`	199	`} else {`
199	`$config[$pieces[0]][$pieces[1]] = $valeur;`	200	`$config[$pieces[0]][$pieces[1]] = $valeur;`
200	`$config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);`	201	`$config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);`
201	`}`	202	`}`
202	`} else {`	203	`} else {`
203	`$m = "Clé invalide '$cle'";`	204	`$m = "Clé invalide '$cle'";`
204	`trigger_error($m, E_USER_WARNING);`	205	`trigger_error($m, E_USER_WARNING);`
205	`}`	206	`}`
206	`} else {`	207	`} else {`
207	`$config[$cle] = $valeur;`	208	`$config[$cle] = $valeur;`
208	`}`	209	`}`
209	`return $config;`	210	`return $config;`
210	`}`	211	`}`
211		212
212	`/**`	213	`/**`
213	`* Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle)`	214	`* Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle)`
214	`* @param array $config tableau de configuration`	215	`* @param array $config tableau de configuration`
215	`* @param string $cle la clé dont il faut évaluer les références`	216	`* @param string $cle la clé dont il faut évaluer les références`
216	`*/`	217	`*/`
217	`private static function evaluerReferences(&$config, $cle) {`	218	`private static function evaluerReferences(&$config, $cle) {`
218	`if (preg_match_all('/{ref:([A-Za-z0-9_.-]+)}/', $config[$cle], $correspondances, PREG_SET_ORDER)) {`	219	`if (preg_match_all('/{ref:([A-Za-z0-9_.-]+)}/', $config[$cle], $correspondances, PREG_SET_ORDER)) {`
219	`foreach ($correspondances as $ref) {`	220	`foreach ($correspondances as $ref) {`
220	`$config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]);`	221	`$config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]);`
221	`}`	222	`}`
222	`}`	223	`}`
223	`}`	224	`}`
224		225
225	`/**`	226	`/**`
226	`* Evalue le code php contenu dans un clé tu tableau config`	227	`* Evalue le code php contenu dans un clé tu tableau config`
227	`* @param array $config tableau de configuration (par référence)`	228	`* @param array $config tableau de configuration (par référence)`
228	`* @param string $cle le clé du tableau dont il faut évaluer la valeur`	229	`* @param string $cle le clé du tableau dont il faut évaluer la valeur`
229	`*/`	230	`*/`
230	`private static function evaluerPhp(&$config, $cle) {`	231	`private static function evaluerPhp(&$config, $cle) {`
231	`if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {`	232	`if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {`
232	`eval('$config["'.$cle.'"] = '.$correspondances[1].';');`	233	`eval('$config["'.$cle.'"] = '.$correspondances[1].';');`
233	`}`	234	`}`
234	`}`	235	`}`
235		236
236	`/**`	237	`/**`
237	`* Charge un fichier ini dans le tableau des paramètres de l'appli`	238	`* Charge un fichier ini dans le tableau des paramètres de l'appli`
238	`* @param string $fichier_ini le nom du fichier à charger`	239	`* @param string $fichier_ini le nom du fichier à charger`
239	`* @return array le fichier ini parsé`	240	`* @return array le fichier ini parsé`
240	`*/`	241	`*/`
241	`public static function charger($fichier_ini) {`	242	`public static function charger($fichier_ini) {`
242	`self::verifierCreationInstance();`	243	`self::verifierCreationInstance();`
243	`return self::parserFichierIni($fichier_ini);`	244	`return self::parserFichierIni($fichier_ini);`
244	`}`	245	`}`
245		246
246	`/**`	247	`/**`
247	`* Acesseur pour la valeur d'un paramètre`	248	`* Acesseur pour la valeur d'un paramètre`
248	`* @param string $param le nom du paramètre`	249	`* @param string $param le nom du paramètre`
249	`* @return string la valeur du paramètre`	250	`* @return string la valeur du paramètre`
250	`*/`	251	`*/`
251	`public static function get($param = null) {`	252	`public static function get($param = null) {`
252	`self::verifierCreationInstance();`	253	`self::verifierCreationInstance();`
253	`return self::getValeur($param, self::$parametres);`	254	`return self::getValeur($param, self::$parametres);`
254	`}`	255	`}`
255		256
256	`/**`	257	`/**`
257	`* Vérifie si la valeur d'un paramètre existe`	258	`* Vérifie si la valeur d'un paramètre existe`
258	`* @param string $param le nom du paramètre`	259	`* @param string $param le nom du paramètre`
259	`* @return boolean vrai si le paramètre existe, false sinon`	260	`* @return boolean vrai si le paramètre existe, false sinon`
260	`*/`	261	`*/`
261	`public static function existe($param) {`	262	`public static function existe($param) {`
262	`self::verifierCreationInstance();`	263	`self::verifierCreationInstance();`
263	`return self::existeValeur($param, self::$parametres);`	264	`return self::existeValeur($param, self::$parametres);`
264	`}`	265	`}`
265	`}`	266	`}`
266	`?>`	267	`?>`