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


<?php
// declare(encoding='UTF-8');
/**
 * Classe de base du Framework :
 *  - fournissant des infos sur l'application,
 *  - paramétrant l'environnement de l'appli et du framework,
 *  - réalisant des traitements sur les variables globales ($_GET, $_POST, $_COOKIE...)
 *
 * Cette classe contient la fonction de chargement automatique de classes.
 * Ce fichier doit toujours rester à la racine du framework car il initialise le chemin
 * de l'application en se basant sur son propre emplacement.
 *
 * @category	PHP 5.2
 * @package	Framework
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright	Copyright (c) 2010, 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	$Id: Framework.php 393 2011-11-10 13:36:48Z jpm $
 * @since		0.3
 * @link		/doc/framework/
 */
class Framework {
 
	/** Variable statique indiquant que les tableaux _GET et _POST ont déjà été encodé au format de l'appli. */
	private static $encodage = false;
 
	/** Tableau d'informations sur l'application */
	private static $info = null;
 
	/** Chemin de base de l'application */
	private static $chemin = null;
 
	/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
	private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',
		'url_arg_separateur_entree', 'url_arg_separateur_sortie',
		'encodage_sortie', 'encodage_appli');
 
	/**
	 * Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments
	 * d'url.
	 * Cette méthode est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().
	 */
	private static function initialiserEnvironnement() {
		self::enregistrerMethodesAutoload();
		self::initialiserUrl();
	}
 
	/**
	 * Initialise différentes classes du Framework nécessaires pour le fonctionnement de l'application.
	 * Ces classes sont ensuites controlées via les fichiers de config.ini.
	 * Elle est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().
	 */
	private static function initialiserFramework() {
		GestionnaireException::configurer();
		//Log::configurer();
		self::verifierEtReencoderTableauRequete();
	}
 
	/**
	 * Redéfinit des constantes globales utiles pour le Framework et les applis.
	 */
	private static function definirConstantesGlobales() {
		if (!defined('DS')) {
			/** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */
			define('DS', DIRECTORY_SEPARATOR);
		}
		if (!defined('PS')) {
			/** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */
			define('PS', PATH_SEPARATOR);
		}
	}
 
	private static function definirCheminAppli($chemin) {
		if (is_file($chemin)) {
			self::$chemin = dirname($chemin).DS;
		} else if (is_dir($chemin)) {
			self::$chemin = $chemin;
		} else {
			throw new Exception("Le chemin indiqué '$chemin' n'est ni un fichier ni un dossier.");
		}
	}
 
	private static function enregistrerMethodesAutoload() {
		spl_autoload_register(array(get_class(), 'autoloadFw'));
 
		// Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework
		Config::verifierPresenceParametres(self::$parametres_obligatoires);
 
		// Initialisation du gestionnaire d'erreur avant toute chose
		GestionnaireException::initialiser();
 
		spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));
 
		// Autoload défini par l'application
		if (function_exists('__autoload')) {
			spl_autoload_register('__autoload');
		}
	}
 
	/**
	 * Autoload pour le Framework.
	 */
	private static function autoloadFw($nom_classe_fw) {
		$racine_fw = dirname(__FILE__).DS;
		$dossiers_classes = array(	$racine_fw,
									$racine_fw.'utilitaires'.DS,
									$racine_fw.'brouillons'.DS);
		foreach ($dossiers_classes as $chemin) {
			$fichier_a_tester = $chemin.$nom_classe_fw.'.php';
			if (file_exists($fichier_a_tester)) {
				include_once $fichier_a_tester;
				return null;
			}
		}
	}
 
	/**
	 * Autoload par défaut pour l'application
	 */
	private static function autoloadAppliDefaut($nom_classe) {
		$dossiers_classes = array(	Config::get('chemin_controleurs'),
									Config::get('chemin_modeles'),
									Config::get('chemin_bibliotheque'));
 
		foreach ($dossiers_classes as $chemin) {
			$fichier_a_tester = $chemin.$nom_classe.'.php';
			if (file_exists($fichier_a_tester)) {
				include_once $fichier_a_tester;
				return null;
			}
		}
	}
 
	/**
	 * Initialise le format des urls.
	 */
	private static function initialiserUrl() {
		ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));
		ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));
	}
 
	/**
	 * Permet d'indiquer le chemin de base de l'Application.
	 * Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.
	 * @param string $chemin_fichier_principal chemin de base
	 */
	public static function setCheminAppli($chemin_fichier_principal) {
		if (self::$chemin === null) {
			if (!file_exists($chemin_fichier_principal)) {
				trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);
			} else {
				self::definirConstantesGlobales();
				self::definirCheminAppli($chemin_fichier_principal);
				self::initialiserEnvironnement();
				self::initialiserFramework();
			}
		} else {
			trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);
		}
	}
 
	/**
	 * accesseur pour le chemin
	 * @return string le chemin
	 */
	public static function getCheminAppli() {
		return self::$chemin;
	}
 
	/** Le tableau des informations sur l'application possède les clés suivantes :
	 * - nom : nom de l'application
	 * - abr : abréviation de l'application
	 * - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
	 *
	 * @param array $info tableau fournissant des informations sur l'application
	 * @return void
	 */
	public static function setInfoAppli($info) {
		if (self::$info === null) {
			self::$info = $info;
		} else {
			trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);
		}
	}
 
	/**
	 * Accesseur pour le tableau d'infos sur l'application.
	 * @param string $cle la clé à laquelle on veut accéder
	 */
	public static function getInfoAppli($cle = null) {
		if ($cle !== null) {
			if (isset(self::$info[$cle])) {
				return self::$info[$cle];
			}
		} else {
			return self::$info;
		}
	}
 
	/**
	 * Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application
	 */
	protected static function verifierEtReencoderTableauRequete() {
		if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {
			$_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));
			$_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));
 
			// Traitement des magic quotes
			self::verifierEtTraiterSlashTableauRequete();
 
			self::$encodage = true;
		}
	}
 
	/**
	 * Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete
	 */
	private static function verifierEtTraiterSlashTableauRequete() {
		if (get_magic_quotes_gpc()) {
			if (!function_exists('nettoyerSlashProfond')) {
				function nettoyerSlashProfond($valeur) {
					return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);
				}
			}
			$_GET = array_map('nettoyerSlashProfond', $_GET);
			$_POST = array_map('nettoyerSlashProfond', $_POST);
			$_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);
		}
	}
 
	/**
	 * Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné
	 * @param $tableau Array Un tableau de données à encoder
	 * @param $encodage_sortie String l'encodage vers lequel on doit transcoder
	 * @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)
	 * @return Array Le tableau encodé dans l'encodage de sortie
	 *
	 */
	final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {
		if (is_array($tableau)) {
			foreach ($tableau as $cle => $valeur) {
				if (is_array($valeur)) {
				 	$tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);
				} else {
					$tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);
				}
			}
		}
		return $tableau;
	}
}
?>

Subversion Repositories Applications.framework

(root)/trunk/framework/Framework.php @ 485 – Rev 392 → 393

Rev 392		Rev 393
1	`<?php`	1	`<?php`
2	`// declare(encoding='UTF-8');`	2	`// declare(encoding='UTF-8');`
3	`/**`	3	`/**`
4	`* Classe de base du Framework :`	4	`* Classe de base du Framework :`
5	`* - fournissant des infos sur l'application,`	5	`* - fournissant des infos sur l'application,`
6	`* - paramétrant l'environnement de l'appli et du framework,`	6	`* - paramétrant l'environnement de l'appli et du framework,`
7	`* - réalisant des traitements sur les variables globales ($_GET, $_POST, $_COOKIE...)`	7	`* - réalisant des traitements sur les variables globales ($_GET, $_POST, $_COOKIE...)`
8	`*`	8	`*`
9	`* Cette classe contient la fonction de chargement automatique de classes.`	9	`* Cette classe contient la fonction de chargement automatique de classes.`
10	`* Ce fichier doit toujours rester à la racine du framework car il initialise le chemin`	10	`* Ce fichier doit toujours rester à la racine du framework car il initialise le chemin`
11	`* de l'application en se basant sur son propre emplacement.`	11	`* de l'application en se basant sur son propre emplacement.`
12	`*`	12	`*`
13	`* @category PHP 5.2`	13	`* @category PHP 5.2`
14	`* @package Framework`	14	`* @package Framework`
15	`* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>`	15	`* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>`
16	`* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)`	16	`* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)`
17	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3`	17	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3`
18	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2`	18	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2`
19	`* @version $Id: Framework.php 392 2011-11-09 16:56:34Z jpm $`	19	`* @version $Id: Framework.php 393 2011-11-10 13:36:48Z jpm $`
20	`* @since 0.3`	20	`* @since 0.3`
21	`* @link /doc/framework/`	21	`* @link /doc/framework/`
22	`*/`	22	`*/`
23	`class Framework {`	23	`class Framework {`
24		24
25	`/** Variable statique indiquant que les tableaux _GET et _POST ont déjà été encodé au format de l'appli. */`	25	`/** Variable statique indiquant que les tableaux _GET et _POST ont déjà été encodé au format de l'appli. */`
26	`private static $encodage = false;`	26	`private static $encodage = false;`
27		27
28	`/** Tableau d'informations sur l'application */`	28	`/** Tableau d'informations sur l'application */`
29	`private static $info = null;`	29	`private static $info = null;`
30		30
31	`/** Chemin de base de l'application */`	31	`/** Chemin de base de l'application */`
32	`private static $chemin = null;`	32	`private static $chemin = null;`
33		33
34	`/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/`	34	`/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/`
35	`private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',`	35	`private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',`
36	`'url_arg_separateur_entree', 'url_arg_separateur_sortie',`	36	`'url_arg_separateur_entree', 'url_arg_separateur_sortie',`
37	`'encodage_sortie', 'encodage_appli');`	37	`'encodage_sortie', 'encodage_appli');`
38		38
39	`/**`	39	`/**`
40	`* Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments`	40	`* Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments`
41	`* d'url.`	41	`* d'url.`
42	`* Cette méthode est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().`	42	`* Cette méthode est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().`
43	`*/`	43	`*/`
44	`private static function initialiserEnvironnement() {`	44	`private static function initialiserEnvironnement() {`
45	`self::enregistrerMethodesAutoload();`	45	`self::enregistrerMethodesAutoload();`
46	`self::initialiserUrl();`	46	`self::initialiserUrl();`
47	`}`	47	`}`
48		48
49	`/**`	49	`/**`
50	`* Initialise différentes classes du Framework nécessaires pour le fonctionnement de l'application.`	50	`* Initialise différentes classes du Framework nécessaires pour le fonctionnement de l'application.`
51	`* Ces classes sont ensuites controlées via les fichiers de config.ini.`	51	`* Ces classes sont ensuites controlées via les fichiers de config.ini.`
52	`* Elle est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().`	52	`* Elle est appelée automatiquement suite à la définition du chemin de l'application via Application::setChemin().`
53	`*/`	53	`*/`
54	`private static function initialiserFramework() {`	54	`private static function initialiserFramework() {`
55	`GestionnaireException::configurer();`	55	`GestionnaireException::configurer();`
56	`//Log::configurer();`	56	`//Log::configurer();`
57	`self::verifierEtReencoderTableauRequete();`	57	`self::verifierEtReencoderTableauRequete();`
58	`}`	58	`}`
59		59
60	`/**`	60	`/**`
61	`* Redéfinit des constantes globales utiles pour le Framework et les applis.`	61	`* Redéfinit des constantes globales utiles pour le Framework et les applis.`
62	`*/`	62	`*/`
63	`private static function definirConstantesGlobales() {`	63	`private static function definirConstantesGlobales() {`
64	`if (!defined('DS')) {`	64	`if (!defined('DS')) {`
65	`/** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */`	65	`/** Redéfinition de la constante DIRECTORY_SEPARATOR en version abrégée DS */`
66	`define('DS', DIRECTORY_SEPARATOR);`	66	`define('DS', DIRECTORY_SEPARATOR);`
67	`}`	67	`}`
68	`if (!defined('PS')) {`	68	`if (!defined('PS')) {`
69	`/** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */`	69	`/** Redéfinition de la constante PATH_SEPARATOR en version abrégée PS */`
70	`define('PS', PATH_SEPARATOR);`	70	`define('PS', PATH_SEPARATOR);`
71	`}`	71	`}`
72	`}`	72	`}`
-		73
-		74	`private static function definirCheminAppli($chemin) {`
-		75	`if (is_file($chemin)) {`
-		76	`self::$chemin = dirname($chemin).DS;`
-		77	`} else if (is_dir($chemin)) {`
-		78	`self::$chemin = $chemin;`
-		79	`} else {`
-		80	`throw new Exception("Le chemin indiqué '$chemin' n'est ni un fichier ni un dossier.");`
-		81	`}`
-		82	`}`
73		83
74	`private static function enregistrerMethodesAutoload() {`	84	`private static function enregistrerMethodesAutoload() {`
75	`spl_autoload_register(array(get_class(), 'autoloadFw'));`	85	`spl_autoload_register(array(get_class(), 'autoloadFw'));`
76		86
77	`// Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework`	87	`// Vérification des paramètres de configuration obligatoire pour assurer le fonctionnement du Framework`
78	`Config::verifierPresenceParametres(self::$parametres_obligatoires);`	88	`Config::verifierPresenceParametres(self::$parametres_obligatoires);`
79		89
80	`// Initialisation du gestionnaire d'erreur avant toute chose`	90	`// Initialisation du gestionnaire d'erreur avant toute chose`
81	`GestionnaireException::initialiser();`	91	`GestionnaireException::initialiser();`
82		92
83	`spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));`	93	`spl_autoload_register(array(get_class(), 'autoloadAppliDefaut'));`
84		94
85	`// Autoload défini par l'application`	95	`// Autoload défini par l'application`
86	`if (function_exists('__autoload')) {`	96	`if (function_exists('__autoload')) {`
87	`spl_autoload_register('__autoload');`	97	`spl_autoload_register('__autoload');`
88	`}`	98	`}`
89	`}`	99	`}`
90		100
91	`/**`	101	`/**`
92	`* Autoload pour le Framework.`	102	`* Autoload pour le Framework.`
93	`*/`	103	`*/`
94	`private static function autoloadFw($nom_classe_fw) {`	104	`private static function autoloadFw($nom_classe_fw) {`
95	`$racine_fw = dirname(__FILE__).DS;`	105	`$racine_fw = dirname(__FILE__).DS;`
96	`$dossiers_classes = array( $racine_fw,`	106	`$dossiers_classes = array( $racine_fw,`
97	`$racine_fw.'utilitaires'.DS,`	107	`$racine_fw.'utilitaires'.DS,`
98	`$racine_fw.'brouillons'.DS);`	108	`$racine_fw.'brouillons'.DS);`
99	`foreach ($dossiers_classes as $chemin) {`	109	`foreach ($dossiers_classes as $chemin) {`
100	`$fichier_a_tester = $chemin.$nom_classe_fw.'.php';`	110	`$fichier_a_tester = $chemin.$nom_classe_fw.'.php';`
101	`if (file_exists($fichier_a_tester)) {`	111	`if (file_exists($fichier_a_tester)) {`
102	`include_once $fichier_a_tester;`	112	`include_once $fichier_a_tester;`
103	`return null;`	113	`return null;`
104	`}`	114	`}`
105	`}`	115	`}`
106	`}`	116	`}`
107		117
108	`/**`	118	`/**`
109	`* Autoload par défaut pour l'application`	119	`* Autoload par défaut pour l'application`
110	`*/`	120	`*/`
111	`private static function autoloadAppliDefaut($nom_classe) {`	121	`private static function autoloadAppliDefaut($nom_classe) {`
112	`$dossiers_classes = array( Config::get('chemin_controleurs'),`	122	`$dossiers_classes = array( Config::get('chemin_controleurs'),`
113	`Config::get('chemin_modeles'),`	123	`Config::get('chemin_modeles'),`
114	`Config::get('chemin_bibliotheque'));`	124	`Config::get('chemin_bibliotheque'));`
115		125
116	`foreach ($dossiers_classes as $chemin) {`	126	`foreach ($dossiers_classes as $chemin) {`
117	`$fichier_a_tester = $chemin.$nom_classe.'.php';`	127	`$fichier_a_tester = $chemin.$nom_classe.'.php';`
118	`if (file_exists($fichier_a_tester)) {`	128	`if (file_exists($fichier_a_tester)) {`
119	`include_once $fichier_a_tester;`	129	`include_once $fichier_a_tester;`
120	`return null;`	130	`return null;`
121	`}`	131	`}`
122	`}`	132	`}`
123	`}`	133	`}`
124		134
125	`/**`	135	`/**`
126	`* Initialise le format des urls.`	136	`* Initialise le format des urls.`
127	`*/`	137	`*/`
128	`private static function initialiserUrl() {`	138	`private static function initialiserUrl() {`
129	`ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));`	139	`ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));`
130	`ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));`	140	`ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));`
131	`}`	141	`}`
132		142
133	`/**`	143	`/**`
134	`* Permet d'indiquer le chemin de base de l'Application.`	144	`* Permet d'indiquer le chemin de base de l'Application.`
135	`* Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.`	145	`* Cette méthode doit obligatoirement être utilisée par l'application pour que le Framework fonctionne correctement.`
136	`* @param string $chemin_fichier_principal chemin de base`	146	`* @param string $chemin_fichier_principal chemin de base`
137	`*/`	147	`*/`
138	`public static function setCheminAppli($chemin_fichier_principal) {`	148	`public static function setCheminAppli($chemin_fichier_principal) {`
139	`if (self::$chemin === null) {`	149	`if (self::$chemin === null) {`
140	`if (!file_exists($chemin_fichier_principal)) {`	150	`if (!file_exists($chemin_fichier_principal)) {`
141	`trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);`	151	`trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode setCheminAppli().", E_USER_ERROR);`
142	`} else {`	152	`} else {`
143	`self::definirConstantesGlobales();`	153	`self::definirConstantesGlobales();`
144	`self::$chemin = dirname($chemin_fichier_principal).DS;`	154	`self::definirCheminAppli($chemin_fichier_principal);`
145	`self::initialiserEnvironnement();`	155	`self::initialiserEnvironnement();`
146	`self::initialiserFramework();`	156	`self::initialiserFramework();`
147	`}`	157	`}`
148	`} else {`	158	`} else {`
149	`trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);`	159	`trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);`
150	`}`	160	`}`
151	`}`	161	`}`
152		162
153	`/**`	163	`/**`
154	`* accesseur pour le chemin`	164	`* accesseur pour le chemin`
155	`* @return string le chemin`	165	`* @return string le chemin`
156	`*/`	166	`*/`
157	`public static function getCheminAppli() {`	167	`public static function getCheminAppli() {`
158	`return self::$chemin;`	168	`return self::$chemin;`
159	`}`	169	`}`
160		170
161	`/** Le tableau des informations sur l'application possède les clés suivantes :`	171	`/** Le tableau des informations sur l'application possède les clés suivantes :`
162	`* - nom : nom de l'application`	172	`* - nom : nom de l'application`
163	`* - abr : abréviation de l'application`	173	`* - abr : abréviation de l'application`
164	`* - encodage : encodage de l'application (ISO-8859-15, UTF-8...)`	174	`* - encodage : encodage de l'application (ISO-8859-15, UTF-8...)`
165	`*`	175	`*`
166	`* @param array $info tableau fournissant des informations sur l'application`	176	`* @param array $info tableau fournissant des informations sur l'application`
167	`* @return void`	177	`* @return void`
168	`*/`	178	`*/`
169	`public static function setInfoAppli($info) {`	179	`public static function setInfoAppli($info) {`
170	`if (self::$info === null) {`	180	`if (self::$info === null) {`
171	`self::$info = $info;`	181	`self::$info = $info;`
172	`} else {`	182	`} else {`
173	`trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);`	183	`trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);`
174	`}`	184	`}`
175	`}`	185	`}`
176		186
177	`/**`	187	`/**`
178	`* Accesseur pour le tableau d'infos sur l'application.`	188	`* Accesseur pour le tableau d'infos sur l'application.`
179	`* @param string $cle la clé à laquelle on veut accéder`	189	`* @param string $cle la clé à laquelle on veut accéder`
180	`*/`	190	`*/`
181	`public static function getInfoAppli($cle = null) {`	191	`public static function getInfoAppli($cle = null) {`
182	`if ($cle !== null) {`	192	`if ($cle !== null) {`
183	`if (isset(self::$info[$cle])) {`	193	`if (isset(self::$info[$cle])) {`
184	`return self::$info[$cle];`	194	`return self::$info[$cle];`
185	`}`	195	`}`
186	`} else {`	196	`} else {`
187	`return self::$info;`	197	`return self::$info;`
188	`}`	198	`}`
189	`}`	199	`}`
190		200
191	`/**`	201	`/**`
192	`* Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application`	202	`* Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application`
193	`*/`	203	`*/`
194	`protected static function verifierEtReencoderTableauRequete() {`	204	`protected static function verifierEtReencoderTableauRequete() {`
195	`if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {`	205	`if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {`
196	`$_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));`	206	`$_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));`
197	`$_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));`	207	`$_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));`
198		208
199	`// Traitement des magic quotes`	209	`// Traitement des magic quotes`
200	`self::verifierEtTraiterSlashTableauRequete();`	210	`self::verifierEtTraiterSlashTableauRequete();`
201		211
202	`self::$encodage = true;`	212	`self::$encodage = true;`
203	`}`	213	`}`
204	`}`	214	`}`
205		215
206	`/**`	216	`/**`
207	`* Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete`	217	`* Procédure vérifiant l'activation des magic quotes et remplacant les slash dans les tableaux de requete`
208	`*/`	218	`*/`
209	`private static function verifierEtTraiterSlashTableauRequete() {`	219	`private static function verifierEtTraiterSlashTableauRequete() {`
210	`if (get_magic_quotes_gpc()) {`	220	`if (get_magic_quotes_gpc()) {`
211	`if (!function_exists('nettoyerSlashProfond')) {`	221	`if (!function_exists('nettoyerSlashProfond')) {`
212	`function nettoyerSlashProfond($valeur) {`	222	`function nettoyerSlashProfond($valeur) {`
213	`return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);`	223	`return ( is_array($valeur) ) ? array_map('nettoyerSlashProfond', $valeur) : stripslashes($valeur);`
214	`}`	224	`}`
215	`}`	225	`}`
216	`$_GET = array_map('nettoyerSlashProfond', $_GET);`	226	`$_GET = array_map('nettoyerSlashProfond', $_GET);`
217	`$_POST = array_map('nettoyerSlashProfond', $_POST);`	227	`$_POST = array_map('nettoyerSlashProfond', $_POST);`
218	`$_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);`	228	`$_COOKIE = array_map('nettoyerSlashProfond', $_COOKIE);`
219	`}`	229	`}`
220	`}`	230	`}`
221		231
222	`/**`	232	`/**`
223	`* Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné`	233	`* Fonction récursive transcodant toutes les valeurs d'un tableau de leur encodage d'entrée vers un encodage de sortie donné`
224	`* @param $tableau Array Un tableau de données à encoder`	234	`* @param $tableau Array Un tableau de données à encoder`
225	`* @param $encodage_sortie String l'encodage vers lequel on doit transcoder`	235	`* @param $encodage_sortie String l'encodage vers lequel on doit transcoder`
226	`* @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)`	236	`* @param $encodage_entree String l'encodage original des chaines du tableau (optionnel)`
227	`* @return Array Le tableau encodé dans l'encodage de sortie`	237	`* @return Array Le tableau encodé dans l'encodage de sortie`
228	`*`	238	`*`
229	`*/`	239	`*/`
230	`final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {`	240	`final static protected function encoderTableau($tableau, $encodage_sortie, $encodage_entree = null) {`
231	`if (is_array($tableau)) {`	241	`if (is_array($tableau)) {`
232	`foreach ($tableau as $cle => $valeur) {`	242	`foreach ($tableau as $cle => $valeur) {`
233	`if (is_array($valeur)) {`	243	`if (is_array($valeur)) {`
234	`$tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);`	244	`$tableau[$cle] = self::encoderTableau($valeur, $encodage_sortie, $encodage_entree);`
235	`} else {`	245	`} else {`
236	`$tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);`	246	`$tableau[$cle] = mb_convert_encoding($valeur, $encodage_sortie, $encodage_entree);`
237	`}`	247	`}`
238	`}`	248	`}`
239	`}`	249	`}`
240	`return $tableau;`	250	`return $tableau;`
241	`}`	251	`}`
242	`}`	252	`}`
243	`?>`	253	`?>`