Subversion Repositories eFlore/Projets.eflore-projets

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
46 jpm 1 
<?php
2 
class GenerateurNomSciHtml {
3 
	protected $bdd = null;
4 
	protected $table = null;
5 
 
6 
	protected $num = null;
7 
	protected $compo_nom = array();
8 
 
9 
	protected $abbr = array (
10 
			'infra-gen.' 	=>	'Infra-Genre',
11 
			'sect.'			=> 'Section',
12 
			'subsect.'		=> 'Sous-Section',
13 
			'ser.'			=> 'Série',
14 
			'subser.'		=> 'Sous-Série',
15 
			'gr.'			=> 'Groupe',
16 
			'agg.' 			=> 'Agrégat',
17 
			'sp.' 			=> 'Espèce',
18 
			'subsp.'		=> 'Sous-Espèce',
19 
			'infra-sp.'		=> 'Infra-Espèce',
20 
			'var.'			=> 'Variété',
21 
			'subvar.'		=> 'Sous-Variété',
22 
			'fa'			=> 'Forme',
23 
			'subf.'			=> 'Sous-Forme',
24 
			'f. sp.'		=> 'Forma species',
25 
			'proles' 		=> 'Race prole'
26 
	);
27 
 
129 jpm 28 
	private $nomSciTpl = '<span class="sci">%s</span>';
353 jpm 29 
 
46 jpm 30 
	private $nomSupraGenTpl = '<span class="supra_gen">%s</span>';
31 
	private $genTpl = '<span class="gen">%s</span>';
32 
	private $infraGenTpl = '<span class="infra-gen">%s</span>';
33 
	private $spFHTpl = '<span class="gen">%s</span> <span class="sp">%s</span>';
34 
	private $typeEpitheteTpl = '<abbr class="type_epithete" title="%s">%s</abbr>';
35 
	private $infraSpFHTpl = '<span class="gen">%s</span> <span class="sp">%s</span> <abbr class="type-epithete" title="%s">%s</abbr> <span class="infra-sp">%s</span>';
353 jpm 36 
 
37 
	private $hybrideTpl = '<span class="hyb">× <span class="%s">%s</span></span>';
38 
	private $chimereTpl = '<span class="chimere">+ <span class="%s">%s</span></span>';
46 jpm 39 
	private $formuleHybTpl = '<span class="formule-hyb">%s</span>';
353 jpm 40 
	private $hybriditeTpl = '<span class="%s">%s</span>';
46 jpm 41 
 
353 jpm 42 
	private $gpGxAvecCvarTpl = '<span class="gp">%s <abbr title="grex">gx</abbr>(%s <abbr title="groupe">Gp</abbr>)</span>';
43 
	private $gpGxSansCvarTpl = '<span class="gp">%s <abbr title="grex">gx</abbr>%s <abbr title="groupe">Gp</abbr></span>';
44 
	private $gxTpl = '<span class="gp">%s <abbr title="grex">gx</abbr></span>';
45 
	private $gpAvecCvarTpl = '<span class="gp">(%s <abbr title="groupe">Gp</abbr>)</span>';
46 
	private $gpSansCvarTpl = '<span class="gp">%s <abbr title="groupe">Gp</abbr></span>';
47 
	private $commTpl = '<span class="commercial">%s</span>';
48 
	private $cvarTpl = '<span class="cultivar">\'%s\'</span>';
49 
 
46 jpm 50 
	public function generer(Array $nomsDecomposes) {
51 
		$nomsSciHtml = array();
334 jpm 52 
		foreach ($nomsDecomposes as $infos) {
485 jpm 53 
			$nom = $this->genererNomSciHtml($infos);
54 
			if ($nom != '') {
55 
				$nomsSciHtml[$this->num] = $nom;
46 jpm 56 
			}
57 
		}
58 
		return $nomsSciHtml;
59 
	}
60 
 
485 jpm 61 
	public function genererNomSciHtml(Array $nomDecomposes) {
62 
		$this->initialiserVariables($nomDecomposes);
63 
 
64 
		$nomSciHtml = '';
65 
		$nomSciHtml .= $this->ajouterBaliseNomSupraGen();
66 
		$nomSciHtml .= $this->verifierHybridite($this->compo_nom['genre'], 'gen');
67 
		$nomSciHtml .= $this->ajouterBaliseInfraGen();
68 
		$nomSciHtml .= $this->verifierHybridite($this->compo_nom['epithete_sp'], 'sp');
69 
		$nomSciHtml .= $this->ajouterBaliseTypeInfraSp();
70 
		$nomSciHtml .= $this->verifierHybridite($this->compo_nom['epithete_infra_sp'], 'infra-sp');
71 
		$nomSciHtml .= $this->ajouterCultivarGpComm();
72 
 
73 
		if ($nomSciHtml != '') {
74 
			$nomSciHtml = sprintf($this->nomSciTpl, trim($nomSciHtml));
75 
		}
76 
		return $nomSciHtml;
77 
	}
78 
 
46 jpm 79 
	private function initialiserVariables($infos) {
80 
		$this->num = $infos['num_nom'];
81 
		$this->compo_nom = $infos;
82 
	}
83 
 
84 
	private function ajouterBaliseNomSupraGen() {
85 
		$html = '';
86 
		if ($this->compo_nom['nom_supra_generique'] != '') {
87 
			$html = sprintf($this->nomSupraGenTpl, $this->compo_nom['nom_supra_generique']);
88 
		}
89 
		return $html;
90 
	}
91 
 
92 
	private function ajouterTypeEpithete($type) {
93 
		if (!array_key_exists($type, $this->abbr)) {
94 
			$this->abbr[$type] = $type;
95 
		}
96 
	}
97 
 
98 
	private function ajouterBaliseInfraGen() {
99 
		$html = '';
100 
		if ($this->verifierTypeInfraGen()) {
485 jpm 101 
			$html = $this->ajouterBaliseTypeInfraGen();
46 jpm 102 
		} else {
103 
			if ($this->avoirInfo('epithete_infra_generique')) {
485 jpm 104 
				$html = sprintf($this->infraGenTpl, $this->compo_nom['epithete_infra_generique']);
46 jpm 105 
			}
106 
		}
107 
		return $html;
108 
	}
109 
 
110 
	private function verifierTypeInfraGen() {
111 
		$ok = false;
112 
		if ($this->compo_nom['type_epithete'] != '' && $this->compo_nom['epithete_infra_generique'] != '') {
113 
			$this->ajouterTypeEpithete($this->compo_nom['type_epithete']);
114 
			$ok = true;
115 
		}
116 
		return $ok;
117 
	}
118 
 
119 
	private function ajouterBaliseTypeInfraGen() {
120 
		$html = '';
121 
		$type = $this->compo_nom['type_epithete'];
122 
 
123 
		if ($type == 'agg.') {
124 
			// Ajout de l'infra gen avant le type s'il est égal à agg.
485 jpm 125 
			$html = ' '.$this->ajouterBaliseInfraGen().
46 jpm 126 
					' '.sprintf($this->typeEpitheteTpl, $this->abbr[$type], $type);
127 
		} else {
485 jpm 128 
			$html = ' '.sprintf($this->typeEpitheteTpl, $this->abbr[$type], $type).
46 jpm 129 
					' '.$this->ajouterBaliseInfraGen();
130 
		}
131 
		return $html;
132 
	}
133 
 
134 
	private function ajouterBaliseTypeInfraSp() {
135 
		$html = '';
136 
		$type = $this->compo_nom['type_epithete'];
137 
		$infraSp = $this->compo_nom['epithete_infra_sp'];
138 
 
139 
		if ($infraSp != '') {
140 
			if ($type != '') {
141 
				$this->ajouterTypeEpithete($type);
142 
				$html = ' '.sprintf($this->typeEpitheteTpl, $this->abbr[$type], $type);
143 
			} else {
661 jpm 144 
				$message = "Nom #{$this->num} contient un épithète infra-spécifique mais son type n'est pas renseigné.";
145 
				throw new Exception($message);
46 jpm 146 
			}
147 
		}
148 
		return $html;
149 
	}
150 
 
151 
	private function ajouterCultivarGpComm() {
152 
		$html = '';
153 
		if ($this->avoirInfo('cultivar_groupe')) {
154 
			$html .= ' '.$this->ajouterCultivarGroupe();
155 
		}
156 
		if ($this->avoirInfo('nom_commercial')) {
353 jpm 157 
			$html .= ' '.sprintf($this->commTpl, $this->compo_nom['nom_commercial']);
46 jpm 158 
		}
159 
		if ($this->avoirInfo('cultivar')) {
353 jpm 160 
			$html .= ' '.sprintf($this->cvarTpl, $this->compo_nom['cultivar']);
46 jpm 161 
		}
162 
		return $html;
163 
	}
164 
 
165 
	private function avoirInfo($valeur) {
166 
		return (isset($this->compo_nom[$valeur]) && $this->compo_nom[$valeur] != '') ? true : false;
167 
	}
168 
 
169 
	/**
170 
	 * Permet d'ajouter les groupes de cultivar en fonction de la présence d'un cultivar et de la présence d'un grex
171 
	 *
172 
	 * L'ensemble des individus obtenu par une fécondation particulière s'appelle un le Grex (que pour les orchidées).
173 
	 * Au sein du grex, certains individus peuvent se distinguer par des formes, des coloris ou autres qui font que
174 
	 * l'obtenteur du grex va les sélectionner.
175 
	 * les noms de groupes de cultivars sont suivis de l'abréviation « Gp » et placés entre parenthèses
176 
	 * les noms de grex, s'ils sont utilisés devant une épithète de cultivar, ne se mettent pas entre parenthèses
177 
	 *	 ex : Cymbidium Alexanderi gx 'Westonbirt' (cultivar_groupe = Alexanderi gx) ;
178 
	 * les noms de groupe se mettent entre parenthèses s'ils sont devant une épithète de cultivar
179 
	 *	 ex : Dracaena fragrans (Deremenis Gp) 'Christianne' (cultivar_groupe = Deremenis)
180 
	 * Un grex peut contenir des groupes (rédaction d'un exemple de l'ICNCP)
181 
	 *	 ex : × Rhyncosophrocattleya Marie Lemon Stick grex Francis Suzuki Group
182 
	 *	 ou : × Rhyncosophrocattleya Marie Lemon Stick gx Francis Suzuki Gp
183 
	 * @param unknown_type $val
184 
	 *
185 
	 */
186 
	private function ajouterCultivarGroupe() {
187 
		$html = '';
353 jpm 188 
		// si le champ cultivar_groupe n'est pas vide
46 jpm 189 
		if ($this->avoirInfo('cultivar_groupe')) {
353 jpm 190 
			$groupe = trim($this->compo_nom['cultivar_groupe']);
191 
 
192 
			// Sélection des templates
193 
			$tplGx = $this->gxTpl;
194 
			$tplGpGx = $this->gpGxSansCvarTpl;
195 
			$tplGp = $this->gpSansCvarTpl;
196 
			// s'il y a un cultivar, on ajoute des parenthèses au groupe (mais pas au grex)
352 jpm 197 
			if ($this->avoirInfo('cultivar')) {
353 jpm 198 
				$tplGpGx = $this->gpGxAvecCvarTpl;
199 
				$tplGp = $this->gpAvecCvarTpl;
46 jpm 200 
			}
353 jpm 201 
 
202 
			// Création du HTML du groupe de cultivar
203 
			if (strrpos($groupe, ' gx ') !== false) {//si le grex est composé de groupe
204 
				$gpEtGx = explode(' gx ', $groupe);
205 
				$html = sprintf($tplGpGx, $gpEtGx[0], $gpEtGx[1]);
206 
			} else if (preg_match('/ gx$/', $groupe)) {//s'il y a un grex et pas de groupe
207 
				$gx = str_replace(' gx', '', $groupe);
208 
				$html = sprintf($tplGx, $gx);
209 
			} else { //s'il n'y a pas de grex mais un groupe
210 
				$html = sprintf($tplGp, $groupe);
211 
			}
46 jpm 212 
		}
213 
		return $html;
214 
	}
215 
 
216 
	/**
217 
	 *
218 
	 * Permet de repérer s'il s'agit d'un hybride (infra-sp, genre, sp) ou d'une chimère.
219 
	 * @param unknown_type $val
220 
	 * @param unknown_type $type
221 
	 */
222 
	private function verifierHybridite($epithete, $type) {
223 
		$html = '';
224 
		if ($epithete != '') {
225 
			if (substr($epithete, 0, 2) == 'x ') {
353 jpm 226 
				$hybride = str_replace('x ', '', $epithete);
227 
				$html = ' '.sprintf($this->hybrideTpl, $type, $hybride);
46 jpm 228 
			} elseif (substr($epithete, 0, 2) == '+ ') {
353 jpm 229 
				$hybride = str_replace('+ ', '', $epithete);
230 
				$html = ' '.sprintf($this->chimereTpl, $type, $hybride);
231 
			} else if (substr_count($epithete, ' x ') > 1) {// Cas d'une formule d'hybridité comprenant des parents hybrides
46 jpm 232 
				$html = ' '.$this->insererBaliseFormuleHyb($epithete);
353 jpm 233 
			} elseif (substr_count($epithete, ' x ') == 1) {// Cas d'une formule d'hybridité simple
46 jpm 234 
				$html = ' '.$this->ajouterFomuleHybridite($epithete, $type);
353 jpm 235 
			} else {// Autre cas...
236 
				$html = ' '.sprintf($this->hybriditeTpl, $type, $epithete);
46 jpm 237 
			}
238 
		}
239 
		return $html;
240 
	}
241 
 
242 
	private function ajouterFomuleHybridite($formule, $type) {
243 
		$tab_x = explode(' x ', $formule);
244 
		$formule_hyb = array();
245 
		switch ($type) {
246 
			case 'gen' 		:
247 
				foreach ($tab_x as $hyb) {
248 
					$formule_hyb[] = sprintf($this->genTpl, $hyb);
249 
				}
250 
				break;
251 
			case 'sp'		:
252 
				foreach ($tab_x as $hyb) {
253 
					if (substr_count($hyb, ' ') >= 1) {
254 
						list($gen, $sp) = explode(' ', $hyb);
255 
						$formule_hyb[] = sprintf($this->spFHTpl, $gen, $sp);
185 jpm 256 
					} else if (preg_match('/^[A-Z]/', $hyb)) {
257 
						$gen = $hyb;
258 
						$formule_hyb[] = sprintf($this->genTpl, $gen);
46 jpm 259 
					}
260 
				}
261 
				break;
262 
			case 'infra-sp' :
263 
				foreach ($tab_x as $hyb) {
264 
					list($gen, $sp, $typeEpithete, $infraSp) = explode (' ', $hyb);
265 
					$formule_hyb[] = sprintf($this->infraSpFHTpl, $gen, $sp, $this->abbr[$typeEpithete], $typeEpithete, $infraSp);
266 
				}
267 
				break;
268 
			default : break;
269 
		}
270 
		return $this->insererBaliseFormuleHyb(implode(' x ', $formule_hyb));
271 
	}
272 
 
273 
	private function insererBaliseFormuleHyb($formule) {
274 
		return sprintf($this->formuleHybTpl, $formule);
275 
	}
276 
}
277 
?>