Subversion Repositories eFlore/Applications.coel

Rev

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

Rev Author Line No. Line
69 jpm 1
package org.tela_botanica.client.modeles;
2
 
3
import java.io.Serializable;
1173 jpm 4
import java.util.Arrays;
385 gduche 5
import java.util.Collection;
248 gduche 6
import java.util.HashMap;
193 jp_milcent 7
import java.util.Iterator;
248 gduche 8
import java.util.LinkedList;
1173 jpm 9
import java.util.List;
306 jp_milcent 10
import java.util.Map;
193 jp_milcent 11
import java.util.Set;
306 jp_milcent 12
import java.util.TreeSet;
69 jpm 13
 
949 jpm 14
import org.tela_botanica.client.util.Debug;
233 jp_milcent 15
import org.tela_botanica.client.util.UtilArray;
1369 cyprien 16
import org.tela_botanica.client.util.UtilString;
233 jp_milcent 17
 
534 gduche 18
import com.extjs.gxt.ui.client.core.FastMap;
69 jpm 19
import com.extjs.gxt.ui.client.data.BaseModelData;
602 jp_milcent 20
import com.google.gwt.core.client.GWT;
385 gduche 21
import com.google.gwt.http.client.URL;
775 jpm 22
import com.google.gwt.json.client.JSONObject;
69 jpm 23
 
193 jp_milcent 24
/**
25
 * @author jpm
26
 *
27
 */
69 jpm 28
public abstract class aDonnee extends BaseModelData implements Serializable {
29
 
30
	private static final long serialVersionUID = 3527760464061629791L;
748 jpm 31
 
789 jpm 32
	public static final String TYPE_AUTRE = "AUTRE";
33
	public static final String TYPE_TOTAL = "TOTAL";
34
	public static final String SEPARATEUR_TYPE_VALEUR = "##";
35
	public static final String SEPARATEUR_VALEURS = ";;";
36
	public static final String SEPARATEUR_DONNEES = "||";
875 jpm 37
	public static final String ETAT_AJOUTE = "A";
883 jpm 38
	public static final Object ETAT_MODIFIE = "M";
1042 gduche 39
	public static final String VALEUR_NULL = "NC";
1257 gduche 40
	public HashMap<String, String> valeursInitiales = new HashMap<String, String>();
789 jpm 41
 
1173 jpm 42
 
748 jpm 43
	protected abstract String getPrefixe();
1173 jpm 44
	protected abstract String[] getChampsObligatoires();
748 jpm 45
 
789 jpm 46
	public String getDateModification() {
47
		return (String) renvoyerValeurCorrecte("cmhl_date_modification");
48
	}
49
 
50
	public String getNotes() {
51
		return (String) renvoyerValeurCorrecte("cmhl_notes");
52
	}
53
 
54
	public String getIdModifierPar() {
55
		return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");
56
	}
57
 
58
	public String getIdEtat() {
59
		return (String) renvoyerValeurCorrecte("cmhl_ce_etat");
60
	}
61
 
62
	public String getIp() {
63
		return (String) renvoyerValeurCorrecte("cmhl_ip");
64
	}
65
 
775 jpm 66
	protected void initialiserModele(JSONObject jsonObjet) {
67
		// l'objet JSON est une table de hachage
68
		Set<String> im = jsonObjet.keySet();
1173 jpm 69
		valeursInitiales = new HashMap<String, String>();
70
 
775 jpm 71
		// Parcourt pour chaque clé
72
		for (Iterator<String> it = im.iterator(); it.hasNext();) {
73
			// Si elle est associée à une valeur, nous l'ajoutons
74
			String cle = it.next();
1173 jpm 75
			if (cle.startsWith(getPrefixe()+"_") ||cle.matches("^_.+_$")) {
775 jpm 76
				// Suppression de l'abréviation du champ. Inutile dans le contexte d'un objet
77
				String cleObjet = cle.replaceFirst("^"+getPrefixe()+"_", "");
78
				// Sinon, nous ajoutons la clé avec une valeur vide
79
				String valeur = "";
80
				if (jsonObjet.get(cle).isString() != null) {
81
					valeur = jsonObjet.get(cle).isString().stringValue();
82
				}
1173 jpm 83
				valeursInitiales.put(cleObjet, valeur);
775 jpm 84
				this.set(cleObjet, valeur);
1173 jpm 85
			}
775 jpm 86
		}
87
	}
88
 
1173 jpm 89
	public void setValeurInitiale(String cleObjet, String valeur)	{
90
 
91
	}
69 jpm 92
	/**
93
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
94
	 * cette fonction qui retire les charactères nuls qui font planter
95
	 * l'affichage, il ne faut pas utiliser get directement
96
	 *
97
	 * @param cle
98
	 * @return la valeur associée à la clé
99
	 */
193 jp_milcent 100
	protected String renvoyerValeurCorrecte(String cle) {
1042 gduche 101
 
188 jp_milcent 102
		String sortie = "";
69 jpm 103
		if (this.get(cle) != null) {
891 aurelien 104
			String valeur = ""+this.get(cle);
188 jp_milcent 105
			if (! valeur.equals("null")) {
69 jpm 106
				char nullChar = '\u0000';
107
				String sNull = "" + nullChar;
108
				valeur = valeur.replaceAll(sNull, "");
188 jp_milcent 109
				sortie =  valeur;
69 jpm 110
			}
111
		}
891 aurelien 112
 
188 jp_milcent 113
		return sortie;
69 jpm 114
	}
233 jp_milcent 115
 
193 jp_milcent 116
	/**
242 jp_milcent 117
	 * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
118
	 * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
119
	 * Si l'élément existe déjà, il ne sera pas ajouté.
193 jp_milcent 120
	 *
121
	 * @param champ le nom du champ dénormalisé
122
	 * @param type le type de la valeur à ajouter
123
	 * @param valeur la valeur à ajouter
124
	 */
242 jp_milcent 125
	protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
193 jp_milcent 126
		if (valeur instanceof String) {
127
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 128
			if (UtilString.isEmpty(chaineExistante)) {
789 jpm 129
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
193 jp_milcent 130
			} else {
242 jp_milcent 131
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
789 jpm 132
				if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+valeur+"("+SEPARATEUR_VALEURS+"|$)")) {
133
					this.set(champ, chaineExistante+";;"+type+SEPARATEUR_TYPE_VALEUR+valeur);
242 jp_milcent 134
				}
193 jp_milcent 135
			}
136
		}
137
	}
119 jpm 138
 
306 jp_milcent 139
	protected void supprimerTypeDansChaineDenormalise(String champ, String type) {
140
		String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 141
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 142
			if (chaineExistante.matches("(?:^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*")) {
143
				chaineExistante = chaineExistante.replaceFirst("(^|.*"+SEPARATEUR_VALEURS+")"+type+SEPARATEUR_TYPE_VALEUR+".*?("+SEPARATEUR_VALEURS+".*|$)", "$1$2");
144
				chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+SEPARATEUR_VALEURS+"(.*)", "$1"+SEPARATEUR_VALEURS+"$2");
145
				chaineExistante = chaineExistante.replaceAll("^"+SEPARATEUR_VALEURS+"(.*)", "$1");
146
				chaineExistante = chaineExistante.replaceAll("(.*)"+SEPARATEUR_VALEURS+"$", "$1");
306 jp_milcent 147
				this.set(champ, chaineExistante);
148
			}
149
		}
150
	}
151
 
152
	protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) {
153
		if (valeur != null && !valeur.equals("")) {
154
			ajouterChaineDenormaliseAvecType(champ, type, valeur);
155
		} else {
156
			supprimerTypeDansChaineDenormalise(champ, type);
157
		}
158
	}
233 jp_milcent 159
	/**
242 jp_milcent 160
	 * Ajoute un nouvel élément sans type à une chaine dénormalisée.
161
	 * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
162
	 * Si l'élément existe déjà, il ne sera pas ajouté.
163
	 *
164
	 * @param champ le nom du champ dénormalisé
165
	 * @param valeur la valeur à ajouter
166
	 */
167
	protected void ajouterChaineDenormalise(String champ, Object valeur) {
168
		if (valeur instanceof String) {
169
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 170
			if (UtilString.isEmpty(chaineExistante)) {
242 jp_milcent 171
				this.set(champ, valeur);
172
			} else {
173
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
789 jpm 174
				if (!chaineExistante.matches("(^|"+SEPARATEUR_VALEURS+")"+valeur+"("+SEPARATEUR_VALEURS+"|$)")) {
175
					this.set(champ, chaineExistante+SEPARATEUR_VALEURS+valeur);
242 jp_milcent 176
				}
177
			}
178
		}
179
	}
180
 
181
	/**
233 jp_milcent 182
	 * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
183
	 *
184
	 * @param champ le nom du champ dénormalisé
185
	 * @param type le type de la valeur à ajouter
186
	 * @param valeur la valeur à ajouter
187
	 */
793 jpm 188
	protected void setChaineDenormaliseUnique(String champ, String type, String valeur) {
1369 cyprien 189
		if (valeur == null || UtilString.isEmpty(valeur)) {
608 jp_milcent 190
			this.set(champ, "");
191
		} else if (valeur instanceof String) {
793 jpm 192
			if (((String) valeur).matches("^[0-9]+$")) {
193
				this.set(champ, valeur);
194
			} else {
195
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
196
			}
233 jp_milcent 197
		}
198
	}
199
 
245 jp_milcent 200
	/**
201
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
202
	 *
203
	 * @param champ le nom du champ dénormalisé
204
	 */
205
	protected String getChaineDenormaliseUnique(String champ) {
793 jpm 206
		String valeur = renvoyerValeurCorrecte(champ);
245 jp_milcent 207
 
1369 cyprien 208
		if (!UtilString.isEmpty(valeur)) {
793 jpm 209
			valeur = valeur.replaceFirst("^"+TYPE_AUTRE+SEPARATEUR_TYPE_VALEUR, "");
245 jp_milcent 210
		}
211
 
793 jpm 212
		return valeur;
245 jp_milcent 213
	}
214
 
208 jp_milcent 215
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
216
		String sortie = "";
1369 cyprien 217
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 218
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 219
			for (int i = 0; i < valeurs.length; i++) {
789 jpm 220
				if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
221
					sortie =  valeurs[i].replaceFirst("^"+type+SEPARATEUR_TYPE_VALEUR, "");
208 jp_milcent 222
				}
223
			}
224
		}
225
		return sortie;
226
	}
227
 
248 gduche 228
 
233 jp_milcent 229
	/**
248 gduche 230
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
231
	 *
232
	 * @param champ le nom du champ dénormalisé
233
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
234
	 */
235
 
236
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
237
 
238
			Object retourObjet = null;
239
 
240
			String valeurChamp = renvoyerValeurCorrecte(champ);
252 gduche 241
 
242
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
789 jpm 243
				String[] valeurs = valeurChamp.split(SEPARATEUR_VALEURS);
252 gduche 244
 
245
				if (valeurs.length > 0)	{
789 jpm 246
					if (valeurs[0].contains(SEPARATEUR_TYPE_VALEUR))	{
252 gduche 247
						// Les champs sont typés, on en fait une Map
748 jpm 248
						HashMap<String,String> mapValeurs = new HashMap<String,String>();
252 gduche 249
						for (int i = 0; i < valeurs.length; i++)	{
789 jpm 250
							String typeEtValeur[] = valeurs[i].split(SEPARATEUR_TYPE_VALEUR);
251
							mapValeurs.put(typeEtValeur[1], typeEtValeur[0]);
252 gduche 252
						}
253
						retourObjet = mapValeurs;
248 gduche 254
					}
252 gduche 255
					else	{
256
 
257
						//Les champs ne sont pas typés, on en fait une Liste
748 jpm 258
						LinkedList<String> listeValeurs = new LinkedList<String>();
252 gduche 259
						for (int i = 0; i < valeurs.length; i++)	{
260
							if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))	{
261
								listeValeurs.add(valeurs[i]);
262
							}
249 gduche 263
						}
252 gduche 264
						retourObjet = listeValeurs;
248 gduche 265
					}
252 gduche 266
 
248 gduche 267
				}
268
			}
269
 
270
			return retourObjet;
271
 
272
	}
273
 
274
 
275
	/**
233 jp_milcent 276
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
277
	 * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
602 jp_milcent 278
	 * Si aucun type n'est trouvé, nous en ajoutons un avec la nouvelle valeur.
233 jp_milcent 279
	 *
280
	 * @param champ le nom du champ dénormalisé
281
	 * @param type le type de la valeur à modifier
282
	 * @param valeur la valeur pour le type en question
283
	 */
242 jp_milcent 284
	protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
608 jp_milcent 285
		if (valeur == null || valeur.equals("")) {
602 jp_milcent 286
			supprimerTypeDansChaineDenormalise(champ, type);
287
		} else if (valeur instanceof String) {
233 jp_milcent 288
			String chaineExistante = renvoyerValeurCorrecte(champ);
602 jp_milcent 289
 
1369 cyprien 290
			if (UtilString.isEmpty(chaineExistante)) {
789 jpm 291
				this.set(champ, type+SEPARATEUR_TYPE_VALEUR+valeur);
233 jp_milcent 292
			} else {
789 jpm 293
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
602 jp_milcent 294
				HashMap<String,String> valeursModifiees = new HashMap<String,String>();
233 jp_milcent 295
				for (int i = 0; i < valeurs.length; i++) {
789 jpm 296
					if (valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
297
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
298
					} else if (i == (valeurs.length -1) && !valeurs[i].startsWith(type+SEPARATEUR_TYPE_VALEUR)) {
299
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
300
						valeursModifiees.put(type, type+SEPARATEUR_TYPE_VALEUR+valeur);
602 jp_milcent 301
					} else {
789 jpm 302
						valeursModifiees.put(valeurs[i].split(SEPARATEUR_TYPE_VALEUR)[0], valeurs[i]);
233 jp_milcent 303
					}
304
				}
602 jp_milcent 305
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 306
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
233 jp_milcent 307
			}
308
		}
309
	}
310
 
208 jp_milcent 311
	protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
312
		String sortie = "";
1369 cyprien 313
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 314
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
208 jp_milcent 315
			if (valeurs.length >= position) {
316
				for (int i = 0; i < valeurs.length; i++) {
317
					if (i == (position - 1)) {
789 jpm 318
						if (valeurs[i].contains(SEPARATEUR_TYPE_VALEUR)) {
319
							sortie = valeurs[i].replaceFirst("^[^#]+"+SEPARATEUR_VALEURS, "");
208 jp_milcent 320
						} else {
603 jp_milcent 321
							sortie = valeurs[i];
208 jp_milcent 322
						}
323
						break;
324
					}
325
				}
326
			}
327
		}
328
		return sortie;
329
	}
330
 
233 jp_milcent 331
	/**
332
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
333
	 * Remplace par la valeur l'instance dont la position a été indiquée.
242 jp_milcent 334
	 * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
335
	 * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
233 jp_milcent 336
	 *
337
	 * @param champ le nom du champ dénormalisé
338
	 * @param position le type de la valeur à modifier
339
	 * @param valeur la valeur à remplacer à la position indiquée
340
	 */
242 jp_milcent 341
	protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
608 jp_milcent 342
		if (valeur == null || valeur.equals("")) {
603 jp_milcent 343
			supprimerChaineDenormaliseParPosition(champ, position);
344
		} else if (valeur instanceof String) {
233 jp_milcent 345
			String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 346
			if (UtilString.isEmpty(chaineExistante)) {
603 jp_milcent 347
				this.set(champ, valeur);
348
			} else {
789 jpm 349
				String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 350
				if (valeurs.length >= position) {
233 jp_milcent 351
					for (int i = 0; i < valeurs.length; i++) {
352
						if (i == (position - 1)) {
353
							valeurs[i] = (String) valeur;
354
							break;
355
						}
356
					}
789 jpm 357
					this.set(champ, UtilArray.implode(valeurs, SEPARATEUR_VALEURS));
233 jp_milcent 358
				}
359
			}
360
		}
361
	}
362
 
603 jp_milcent 363
	protected void supprimerChaineDenormaliseParPosition(String champ, int position) {
364
		String chaineExistante = renvoyerValeurCorrecte(champ);
1369 cyprien 365
		if (!UtilString.isEmpty(chaineExistante)) {
789 jpm 366
			String[] valeurs = chaineExistante.split(SEPARATEUR_VALEURS);
603 jp_milcent 367
			HashMap<String,String> valeursModifiees = new HashMap<String,String>();
368
			if (valeurs.length >= position) {
369
				for (int i = 0; i < valeurs.length; i++) {
370
					if (i != (position - 1)) {
371
						valeursModifiees.put(""+i, valeurs[i]);
372
					}
373
				}
374
				String[] tableauValeursModifiees = valeursModifiees.values().toArray(new String[valeursModifiees.size()]);
789 jpm 375
				this.set(champ, UtilArray.implode(tableauValeursModifiees, SEPARATEUR_VALEURS));
603 jp_milcent 376
			}
377
		}
378
	}
379
 
193 jp_milcent 380
	/** (non-Javadoc)
381
	 * @see java.lang.Object#toString()
382
	 */
383
	public String toString() {
384
		String sortie = "";
385
 
386
		// Champs du BaseModelData
387
		Set<String> proprietes = this.getProperties().keySet();
306 jp_milcent 388
		TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes);
389
		for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) {
193 jp_milcent 390
			String cle = it.next();
306 jp_milcent 391
			if (this.get(cle) != null && !this.get(cle).equals("")) {
949 jpm 392
				sortie += cle+" : "+this.get(cle).toString()+"\n";
202 jp_milcent 393
			}
193 jp_milcent 394
		}
395
 
396
		return sortie;
397
	}
306 jp_milcent 398
 
399
	public Boolean comparer(BaseModelData objetAComparer) {
400
		Boolean retour = true;
401
		Map<String, Object> a = this.getProperties();
402
		Map<String, Object> b = objetAComparer.getProperties();
403
		if (a.size() != b.size()) {
404
			retour = false;
405
		} else {
406
			Set<String> cles = a.keySet();
407
			Iterator<String> it = cles.iterator();
408
			while (it.hasNext()) {
409
				String cle = it.next();
410
				if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) {
411
					retour = false;
412
					break;
413
				}
414
			}
415
		}
416
		return retour;
417
	}
418
 
419
	public Object cloner(BaseModelData nouvelleInstance) {
420
		Map<String, Object> proprietes = this.getProperties();
421
		Set<String> cles = proprietes.keySet();
422
		for (Iterator<String> it = cles.iterator(); it.hasNext();) {
423
			String cle = it.next();
424
			nouvelleInstance.set(cle, this.get(cle));
425
		}
426
 
427
		return nouvelleInstance;
428
	}
385 gduche 429
 
430
	/**
748 jpm 431
	 * Renvoie une chaîne de caractère formatée et encodée pour POST avec toutes les propriétés du modèle
385 gduche 432
	 * */
748 jpm 433
	public String obtenirChainePOST() {
1292 cyprien 434
 
748 jpm 435
		String post = "";
385 gduche 436
 
748 jpm 437
		FastMap<?> proprietees = (FastMap<?>) getProperties();
438
		Collection<String> cles = proprietees.keySet();
439
		Iterator<String> it = cles.iterator();
385 gduche 440
 
441
		while (it.hasNext())	{
748 jpm 442
			String cle = it.next();
1292 cyprien 443
			//Les Radio Box couplées à la fonction autobind créent des variables gxt.RadioGroup.X, qu'il ne faut pas mettre dans la requête
974 gduche 444
			if (!cle.startsWith("gxt.")&&!cle.matches("^_.+_$"))	{
1173 jpm 445
 
446
				//Si, et seulement si, la valeur diffère de la valeur initiale OU la clé est dans les champs obligatoire
1292 cyprien 447
				if (Arrays.asList(getChampsObligatoires()).contains(getPrefixe() + "_" + cle) || ((valeursInitiales.get(cle) != null && !valeursInitiales.get(cle).equals(get(cle))) || valeursInitiales.get(cle) == null))	{
1173 jpm 448
					post += getPrefixe() + "_" +  cle + "=" + URL.encodeComponent(renvoyerValeurCorrecte(cle));
449
					if (it.hasNext())	{
450
						post += "&";
451
					}
826 gduche 452
				}
385 gduche 453
			}
454
		}
1292 cyprien 455
 
748 jpm 456
		return post;
786 jpm 457
	}
458
 
459
	/**
460
	 * Met à jour l'objet this avec les données de l'objet passé en paramêtre.
461
	 *
462
	 * */
463
	public void mettreAJour(aDonnee nouveau) {
464
		Collection<String> cles = nouveau.getProperties().keySet();
465
		Iterator<String> it = cles.iterator();
466
		while (it.hasNext())	{
467
			String cle = it.next();
468
			if (!this.get(cle).equals(nouveau.get(cle))) {
469
				this.set(cle, nouveau.get(cle));
470
			}
471
		}
472
	}
69 jpm 473
}