WebSVN – eFlore/Applications.coel – Diff – /branches/v1.9-nebbiolo/src/org/tela_botanica/client/modeles/aDonnee.java


package org.tela_botanica.client.modeles;
 
import java.io.Serializable;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
 
import org.tela_botanica.client.util.UtilArray;
 
import com.extjs.gxt.ui.client.data.BaseModelData;
 
/**
 * @author jpm
 *
 */
public abstract class aDonnee extends BaseModelData implements Serializable {
 
	/**
	 * Identifiant pour sérialisé l'objet...
	 */
	private static final long serialVersionUID = 3527760464061629791L;
 
	/**
	 * Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par
	 * cette fonction qui retire les charactères nuls qui font planter
	 * l'affichage, il ne faut pas utiliser get directement
	 * 
	 * @param cle
	 * @return la valeur associée à la clé
	 */
	protected String renvoyerValeurCorrecte(String cle) {
		String sortie = "";
		if (this.get(cle) != null) {
			String valeur = this.get(cle);
			if (! valeur.equals("null")) {
				char nullChar = '\u0000';
				String sNull = "" + nullChar;
				valeur = valeur.replaceAll(sNull, "");
				sortie =  valeur;
			}
		}
		return sortie;
	}
	
	/**
	 * Ajoute un nouvel élément avec son type à une chaine dénormalisée.
	 * Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".
	 * Si l'élément existe déjà, il ne sera pas ajouté.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à ajouter
	 * @param valeur la valeur à ajouter
	 */
	protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, type+"##"+valeur);
			} else {
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
				if (!chaineExistante.matches("(^|;;)"+type+"##"+valeur+"(;;|$)")) {
					this.set(champ, chaineExistante+";;"+type+"##"+valeur);
				}
			}
		}
	}
	
	protected void supprimerTypeDansChaineDenormalise(String champ, String type) {
		String chaineExistante = renvoyerValeurCorrecte(champ);
		if (!chaineExistante.equals("")) {
			// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
			if (chaineExistante.matches("(^|;;)"+type+"##")) {
				chaineExistante = chaineExistante.replaceFirst(type+"##", "");
				chaineExistante = chaineExistante.replaceAll(";;;;", ";;");
				chaineExistante = chaineExistante.replaceAll("(^;;|;;$)", "");
				this.set(champ, chaineExistante);
			}
		}
	}
	
	protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) {
		if (valeur != null && !valeur.equals("")) {
			ajouterChaineDenormaliseAvecType(champ, type, valeur);
		} else {
			supprimerTypeDansChaineDenormalise(champ, type);
		}
	}
	/**
	 * Ajoute un nouvel élément sans type à une chaine dénormalisée.
	 * Champ de type "truk" contenant seulement des valeurs séparées par ";;".
	 * Si l'élément existe déjà, il ne sera pas ajouté.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param valeur la valeur à ajouter
	 */
	protected void ajouterChaineDenormalise(String champ, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, valeur);
			} else {
				// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons
				if (!chaineExistante.matches("(^|;;)"+valeur+"(;;|$)")) {
					this.set(champ, chaineExistante+";;"+valeur);
				}
			}
		}
	}
	
	/**
	 * Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à ajouter
	 * @param valeur la valeur à ajouter
	 */
	protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			this.set(champ, type+"##"+valeur);
		}
	}
	
	/**
	 * Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").
	 * 
	 * @param champ le nom du champ dénormalisé
	 */
	protected String getChaineDenormaliseUnique(String champ) {
		String sortie = renvoyerValeurCorrecte(champ);
		
		if (!sortie.equals("")) {
			sortie = sortie.replaceFirst("^AUTRE##", "");
		}
		
		return sortie;
	}
	
	protected String getInfoDenormaliseParType(String chaineExistante, String type) {
		String sortie = "";
		if (!chaineExistante.equals("")) {
			String[] valeurs = chaineExistante.split(";;");
			for (int i = 0; i < valeurs.length; i++) {
				if (valeurs[i].startsWith(type+"##")) {
					sortie =  valeurs[i].replaceFirst("^"+type+"##", "");
				}
			}
		}
		return sortie;
	}
	
	
	/**
	 * Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)
	 */
	
	public Object getChaineDenormaliseAsMapOrList(String champ)	{
				
			Object retourObjet = null;
			
			String valeurChamp = renvoyerValeurCorrecte(champ);
			
			if ((valeurChamp!=null)&&(!valeurChamp.trim().equals("")))	{
				String[] valeurs = valeurChamp.split(";;");
			
				if (valeurs.length > 0)	{
					if (valeurs[0].contains("##"))	{
						// Les champs sont typés, on en fait une Map
						HashMap mapValeurs = new HashMap();
						
						for (int i = 0; i < valeurs.length; i++)	{
							String typeEtValeur[] = valeurs[i].split("##");
							mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);						
						}
						
						retourObjet = mapValeurs;
					}
					else	{
						
						//Les champs ne sont pas typés, on en fait une Liste
						LinkedList listeValeurs = new LinkedList<String>();
						for (int i = 0; i < valeurs.length; i++)	{
							if ((valeurs[i]!=null)&&(!valeurs[i].equals("")))	{
								listeValeurs.add(valeurs[i]);
							}
						}
						retourObjet = listeValeurs;
					}
					
				}
			}
			
			return retourObjet;
			
	}
	
	
	/**
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
	 * Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param type le type de la valeur à modifier
	 * @param valeur la valeur pour le type en question
	 */
	protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (chaineExistante.equals("")) {
				this.set(champ, type+"##"+valeur);
			} else {
				String[] valeurs = chaineExistante.split(";;");
				for (int i = 0; i < valeurs.length; i++) {
					if (valeurs[i].startsWith(type+"##") || i == (valeurs.length -1)) {
						valeurs[i] = type+"##"+valeur;
						break;
					}
				}
				this.set(champ, UtilArray.implode(valeurs, ";;"));
			}
		}
	}
	
	protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {
		String sortie = "";
		if (!chaineExistante.equals("")) {
			String[] valeurs = chaineExistante.split(";;");
			if (valeurs.length >= position) {
				for (int i = 0; i < valeurs.length; i++) {
					if (i == (position - 1)) {
						if (valeurs[i].contains("##")) {
							sortie =  valeurs[i].replaceFirst("^[^#]+##", "");
						} else {
							sortie =  valeurs[i];
						}
						break;
					}
				}
			}
		}
		return sortie;
	}
	
	/**
	 * Permet de modifier correctement une chaine dénormalisée (champ de type "truk").
	 * Remplace par la valeur l'instance dont la position a été indiquée.
	 * Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.
	 * Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.
	 * 
	 * @param champ le nom du champ dénormalisé
	 * @param position le type de la valeur à modifier
	 * @param valeur la valeur à remplacer à la position indiquée
	 */
	protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {
		if (valeur instanceof String) {
			String chaineExistante = renvoyerValeurCorrecte(champ);
			if (!chaineExistante.equals("")) {
				String[] valeurs = chaineExistante.split(";;");
				if (valeurs.length == 0) {
					this.set(champ, valeur);
				} else if (valeurs.length >= position) {
					for (int i = 0; i < valeurs.length; i++) {
						if (i == (position - 1)) {
							valeurs[i] = (String) valeur;
							break;
						}
					}
					this.set(champ, UtilArray.implode(valeurs, ";;"));
				}
			}
		}
	}
	
	public String getDateModification() {
		return (String) renvoyerValeurCorrecte("cmhl_date_modification");
	}
	
	public String getNotes() {
		return (String) renvoyerValeurCorrecte("cmhl_notes");
	}
	
	public String getIdModifierPar() {
		return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");
	}
	
	public String getIdEtat() {
		return (String) renvoyerValeurCorrecte("cmhl_ce_etat");
	}
	
	public String getIp() {
		return (String) renvoyerValeurCorrecte("cmhl_ip");
	}
	
	/** (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString() {
		String sortie = "";
		
		// Champs du BaseModelData
		Set<String> proprietes = this.getProperties().keySet();
		TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes);
		for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) {
			String cle = it.next();
			if (this.get(cle) != null && !this.get(cle).equals("")) {
				sortie += cle+" : "+this.get(cle)+"\n";
			}
		}
		
		return sortie;
	}
	
	public Boolean comparer(BaseModelData objetAComparer) {
		Boolean retour = true;
		Map<String, Object> a = this.getProperties();
		Map<String, Object> b = objetAComparer.getProperties();
		if (a.size() != b.size()) {
			retour = false;
		} else {
			Set<String> cles = a.keySet();
			Iterator<String> it = cles.iterator();
			while (it.hasNext()) {
				String cle = it.next();
				if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) {
					retour = false;
					break;
				}
			}
		}
		
		return retour;
	}
	
	public Object cloner(BaseModelData nouvelleInstance) {
		Map<String, Object> proprietes = this.getProperties();
		Set<String> cles = proprietes.keySet();
		for (Iterator<String> it = cles.iterator(); it.hasNext();) {
			String cle = it.next();
			nouvelleInstance.set(cle, this.get(cle));
		}
		
		return nouvelleInstance;
	}
}

Rev 255	Rev 306
1	`package org.tela_botanica.client.modeles;`	1	`package org.tela_botanica.client.modeles;`
2		2
3	`import java.io.Serializable;`	3	`import java.io.Serializable;`
-		4	`import java.util.Collections;`
4	`import java.util.HashMap;`	5	`import java.util.HashMap;`
5	`import java.util.Iterator;`	6	`import java.util.Iterator;`
6	`import java.util.LinkedList;`	7	`import java.util.LinkedList;`
-		8	`import java.util.List;`
-		9	`import java.util.Map;`
7	`import java.util.Set;`	10	`import java.util.Set;`
-		11	`import java.util.TreeSet;`
8		12
9	`import org.tela_botanica.client.util.UtilArray;`	13	`import org.tela_botanica.client.util.UtilArray;`
10		14
11	`import com.extjs.gxt.ui.client.data.BaseModelData;`	15	`import com.extjs.gxt.ui.client.data.BaseModelData;`
12		16
13	`/**`	17	`/**`
14	`* @author jpm`	18	`* @author jpm`
15	`*`	19	`*`
16	`*/`	20	`*/`
17	`public abstract class aDonnee extends BaseModelData implements Serializable {`	21	`public abstract class aDonnee extends BaseModelData implements Serializable {`
18		22
19	`/**`	23	`/**`
20	`* Identifiant pour sérialisé l'objet...`	24	`* Identifiant pour sérialisé l'objet...`
21	`*/`	25	`*/`
22	`private static final long serialVersionUID = 3527760464061629791L;`	26	`private static final long serialVersionUID = 3527760464061629791L;`
23		27
24	`/**`	28	`/**`
25	`* Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par`	29	`* Pour éviter que l'on traite des valeurs nulles à l'affichage on passe par`
26	`* cette fonction qui retire les charactères nuls qui font planter`	30	`* cette fonction qui retire les charactères nuls qui font planter`
27	`* l'affichage, il ne faut pas utiliser get directement`	31	`* l'affichage, il ne faut pas utiliser get directement`
28	`*`	32	`*`
29	`* @param cle`	33	`* @param cle`
30	`* @return la valeur associée à la clé`	34	`* @return la valeur associée à la clé`
31	`*/`	35	`*/`
32	`protected String renvoyerValeurCorrecte(String cle) {`	36	`protected String renvoyerValeurCorrecte(String cle) {`
33	`String sortie = "";`	37	`String sortie = "";`
34	`if (this.get(cle) != null) {`	38	`if (this.get(cle) != null) {`
35	`String valeur = this.get(cle);`	39	`String valeur = this.get(cle);`
36	`if (! valeur.equals("null")) {`	40	`if (! valeur.equals("null")) {`
37	`char nullChar = '\u0000';`	41	`char nullChar = '\u0000';`
38	`String sNull = "" + nullChar;`	42	`String sNull = "" + nullChar;`
39	`valeur = valeur.replaceAll(sNull, "");`	43	`valeur = valeur.replaceAll(sNull, "");`
40	`sortie = valeur;`	44	`sortie = valeur;`
41	`}`	45	`}`
42	`}`	46	`}`
43	`return sortie;`	47	`return sortie;`
44	`}`	48	`}`
45		49
46	`/**`	50	`/**`
47	`* Ajoute un nouvel élément avec son type à une chaine dénormalisée.`	51	`* Ajoute un nouvel élément avec son type à une chaine dénormalisée.`
48	`* Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".`	52	`* Champ de type "truk" contenant des valeurs séparées par ";;" qui elle même possèdent un type séparé par "##".`
49	`* Si l'élément existe déjà, il ne sera pas ajouté.`	53	`* Si l'élément existe déjà, il ne sera pas ajouté.`
50	`*`	54	`*`
51	`* @param champ le nom du champ dénormalisé`	55	`* @param champ le nom du champ dénormalisé`
52	`* @param type le type de la valeur à ajouter`	56	`* @param type le type de la valeur à ajouter`
53	`* @param valeur la valeur à ajouter`	57	`* @param valeur la valeur à ajouter`
54	`*/`	58	`*/`
55	`protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {`	59	`protected void ajouterChaineDenormaliseAvecType(String champ, String type, Object valeur) {`
56	`if (valeur instanceof String) {`	60	`if (valeur instanceof String) {`
57	`String chaineExistante = renvoyerValeurCorrecte(champ);`	61	`String chaineExistante = renvoyerValeurCorrecte(champ);`
58	`if (chaineExistante.equals("")) {`	62	`if (chaineExistante.equals("")) {`
59	`this.set(champ, type+"##"+valeur);`	63	`this.set(champ, type+"##"+valeur);`
60	`} else {`	64	`} else {`
61	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`	65	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`
62	`if (!chaineExistante.matches("(^\|;;)"+type+"##"+valeur+"(;;\|$)")) {`	66	`if (!chaineExistante.matches("(^\|;;)"+type+"##"+valeur+"(;;\|$)")) {`
63	`this.set(champ, chaineExistante+";;"+type+"##"+valeur);`	67	`this.set(champ, chaineExistante+";;"+type+"##"+valeur);`
64	`}`	68	`}`
65	`}`	69	`}`
66	`}`	70	`}`
67	`}`	71	`}`
-		72
-		73	`protected void supprimerTypeDansChaineDenormalise(String champ, String type) {`
-		74	`String chaineExistante = renvoyerValeurCorrecte(champ);`
-		75	`if (!chaineExistante.equals("")) {`
-		76	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`
-		77	`if (chaineExistante.matches("(^\|;;)"+type+"##")) {`
-		78	`chaineExistante = chaineExistante.replaceFirst(type+"##", "");`
-		79	`chaineExistante = chaineExistante.replaceAll(";;;;", ";;");`
-		80	`chaineExistante = chaineExistante.replaceAll("(^;;\|;;$)", "");`
-		81	`this.set(champ, chaineExistante);`
-		82	`}`
-		83	`}`
-		84	`}`
-		85
-		86	`protected void remplacerTypeDansChaineDenormalise(String champ, String type, Object valeur) {`
-		87	`if (valeur != null && !valeur.equals("")) {`
-		88	`ajouterChaineDenormaliseAvecType(champ, type, valeur);`
-		89	`} else {`
-		90	`supprimerTypeDansChaineDenormalise(champ, type);`
-		91	`}`
68		92	`}`
69	`/**`	93	`/**`
70	`* Ajoute un nouvel élément sans type à une chaine dénormalisée.`	94	`* Ajoute un nouvel élément sans type à une chaine dénormalisée.`
71	`* Champ de type "truk" contenant seulement des valeurs séparées par ";;".`	95	`* Champ de type "truk" contenant seulement des valeurs séparées par ";;".`
72	`* Si l'élément existe déjà, il ne sera pas ajouté.`	96	`* Si l'élément existe déjà, il ne sera pas ajouté.`
73	`*`	97	`*`
74	`* @param champ le nom du champ dénormalisé`	98	`* @param champ le nom du champ dénormalisé`
75	`* @param valeur la valeur à ajouter`	99	`* @param valeur la valeur à ajouter`
76	`*/`	100	`*/`
77	`protected void ajouterChaineDenormalise(String champ, Object valeur) {`	101	`protected void ajouterChaineDenormalise(String champ, Object valeur) {`
78	`if (valeur instanceof String) {`	102	`if (valeur instanceof String) {`
79	`String chaineExistante = renvoyerValeurCorrecte(champ);`	103	`String chaineExistante = renvoyerValeurCorrecte(champ);`
80	`if (chaineExistante.equals("")) {`	104	`if (chaineExistante.equals("")) {`
81	`this.set(champ, valeur);`	105	`this.set(champ, valeur);`
82	`} else {`	106	`} else {`
83	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`	107	`// Si la valeur à ajouter n'est pas déjà présente, nous l'ajoutons`
84	`if (!chaineExistante.matches("(^\|;;)"+valeur+"(;;\|$)")) {`	108	`if (!chaineExistante.matches("(^\|;;)"+valeur+"(;;\|$)")) {`
85	`this.set(champ, chaineExistante+";;"+valeur);`	109	`this.set(champ, chaineExistante+";;"+valeur);`
86	`}`	110	`}`
87	`}`	111	`}`
88	`}`	112	`}`
89	`}`	113	`}`
90		114
91	`/**`	115	`/**`
92	`* Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").`	116	`* Permet de constuire correctement une chaine dénormalisée unique (champ de type "ce_truk").`
93	`*`	117	`*`
94	`* @param champ le nom du champ dénormalisé`	118	`* @param champ le nom du champ dénormalisé`
95	`* @param type le type de la valeur à ajouter`	119	`* @param type le type de la valeur à ajouter`
96	`* @param valeur la valeur à ajouter`	120	`* @param valeur la valeur à ajouter`
97	`*/`	121	`*/`
98	`protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {`	122	`protected void setChaineDenormaliseUnique(String champ, String type, Object valeur) {`
99	`if (valeur instanceof String) {`	123	`if (valeur instanceof String) {`
100	`this.set(champ, type+"##"+valeur);`	124	`this.set(champ, type+"##"+valeur);`
101	`}`	125	`}`
102	`}`	126	`}`
103		127
104	`/**`	128	`/**`
105	`* Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").`	129	`* Permet de récupérer pour l'affichage une chaine dénormalisée unique (champ de type "ce_truk").`
106	`*`	130	`*`
107	`* @param champ le nom du champ dénormalisé`	131	`* @param champ le nom du champ dénormalisé`
108	`*/`	132	`*/`
109	`protected String getChaineDenormaliseUnique(String champ) {`	133	`protected String getChaineDenormaliseUnique(String champ) {`
110	`String sortie = renvoyerValeurCorrecte(champ);`	134	`String sortie = renvoyerValeurCorrecte(champ);`
111		135
112	`if (!sortie.equals("")) {`	136	`if (!sortie.equals("")) {`
113	`sortie = sortie.replaceFirst("^AUTRE##", "");`	137	`sortie = sortie.replaceFirst("^AUTRE##", "");`
114	`}`	138	`}`
115		139
116	`return sortie;`	140	`return sortie;`
117	`}`	141	`}`
118		142
119	`protected String getInfoDenormaliseParType(String chaineExistante, String type) {`	143	`protected String getInfoDenormaliseParType(String chaineExistante, String type) {`
120	`String sortie = "";`	144	`String sortie = "";`
121	`if (!chaineExistante.equals("")) {`	145	`if (!chaineExistante.equals("")) {`
122	`String[] valeurs = chaineExistante.split(";;");`	146	`String[] valeurs = chaineExistante.split(";;");`
123	`for (int i = 0; i < valeurs.length; i++) {`	147	`for (int i = 0; i < valeurs.length; i++) {`
124	`if (valeurs[i].startsWith(type+"##")) {`	148	`if (valeurs[i].startsWith(type+"##")) {`
125	`sortie = valeurs[i].replaceFirst("^"+type+"##", "");`	149	`sortie = valeurs[i].replaceFirst("^"+type+"##", "");`
126	`}`	150	`}`
127	`}`	151	`}`
128	`}`	152	`}`
129	`return sortie;`	153	`return sortie;`
130	`}`	154	`}`
131		155
132		156
133	`/**`	157	`/**`
134	`* Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur`	158	`* Permet de récupérer une map avec toutes les valeurs de la chaine truk sous la forme clé => valeur`
135	`*`	159	`*`
136	`* @param champ le nom du champ dénormalisé`	160	`* @param champ le nom du champ dénormalisé`
137	`* @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)`	161	`* @return map ou liste en fonction du type de chaine truk (list si champ;;champ;; map si type##champ;;)`
138	`*/`	162	`*/`
139		163
140	`public Object getChaineDenormaliseAsMapOrList(String champ) {`	164	`public Object getChaineDenormaliseAsMapOrList(String champ) {`
141		165
142	`Object retourObjet = null;`	166	`Object retourObjet = null;`
143		167
144	`String valeurChamp = renvoyerValeurCorrecte(champ);`	168	`String valeurChamp = renvoyerValeurCorrecte(champ);`
145		169
146	`if ((valeurChamp!=null)&&(!valeurChamp.trim().equals(""))) {`	170	`if ((valeurChamp!=null)&&(!valeurChamp.trim().equals(""))) {`
147	`String[] valeurs = valeurChamp.split(";;");`	171	`String[] valeurs = valeurChamp.split(";;");`
148		172
149	`if (valeurs.length > 0) {`	173	`if (valeurs.length > 0) {`
150	`if (valeurs[0].contains("##")) {`	174	`if (valeurs[0].contains("##")) {`
151	`// Les champs sont typés, on en fait une Map`	175	`// Les champs sont typés, on en fait une Map`
152	`HashMap mapValeurs = new HashMap();`	176	`HashMap mapValeurs = new HashMap();`
153		177
154	`for (int i = 0; i < valeurs.length; i++) {`	178	`for (int i = 0; i < valeurs.length; i++) {`
155	`String typeEtValeur[] = valeurs[i].split("##");`	179	`String typeEtValeur[] = valeurs[i].split("##");`
156	`mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);`	180	`mapValeurs.put(typeEtValeur[0], typeEtValeur[1]);`
157	`}`	181	`}`
158		182
159	`retourObjet = mapValeurs;`	183	`retourObjet = mapValeurs;`
160	`}`	184	`}`
161	`else {`	185	`else {`
162		186
163	`//Les champs ne sont pas typés, on en fait une Liste`	187	`//Les champs ne sont pas typés, on en fait une Liste`
164	`LinkedList listeValeurs = new LinkedList<String>();`	188	`LinkedList listeValeurs = new LinkedList<String>();`
165	`for (int i = 0; i < valeurs.length; i++) {`	189	`for (int i = 0; i < valeurs.length; i++) {`
166	`if ((valeurs[i]!=null)&&(!valeurs[i].equals(""))) {`	190	`if ((valeurs[i]!=null)&&(!valeurs[i].equals(""))) {`
167	`listeValeurs.add(valeurs[i]);`	191	`listeValeurs.add(valeurs[i]);`
168	`}`	192	`}`
169	`}`	193	`}`
170	`retourObjet = listeValeurs;`	194	`retourObjet = listeValeurs;`
171	`}`	195	`}`
172		196
173	`}`	197	`}`
174	`}`	198	`}`
175		199
176	`return retourObjet;`	200	`return retourObjet;`
177		201
178	`}`	202	`}`
179		203
180		204
181	`/**`	205	`/**`
182	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`	206	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`
183	`* Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.`	207	`* Remplace par la valeur de la première instance du type indiqué dans la chaine dénormalisée.`
184	`*`	208	`*`
185	`* @param champ le nom du champ dénormalisé`	209	`* @param champ le nom du champ dénormalisé`
186	`* @param type le type de la valeur à modifier`	210	`* @param type le type de la valeur à modifier`
187	`* @param valeur la valeur pour le type en question`	211	`* @param valeur la valeur pour le type en question`
188	`*/`	212	`*/`
189	`protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {`	213	`protected void modifierChaineDenormaliseParType(String champ, String type, Object valeur) {`
190	`if (valeur instanceof String) {`	214	`if (valeur instanceof String) {`
191	`String chaineExistante = renvoyerValeurCorrecte(champ);`	215	`String chaineExistante = renvoyerValeurCorrecte(champ);`
192	`if (chaineExistante.equals("")) {`	216	`if (chaineExistante.equals("")) {`
193	`this.set(champ, type+"##"+valeur);`	217	`this.set(champ, type+"##"+valeur);`
194	`} else {`	218	`} else {`
195	`String[] valeurs = chaineExistante.split(";;");`	219	`String[] valeurs = chaineExistante.split(";;");`
196	`for (int i = 0; i < valeurs.length; i++) {`	220	`for (int i = 0; i < valeurs.length; i++) {`
197	`if (valeurs[i].startsWith(type+"##") \|\| i == (valeurs.length -1)) {`	221	`if (valeurs[i].startsWith(type+"##") \|\| i == (valeurs.length -1)) {`
198	`valeurs[i] = type+"##"+valeur;`	222	`valeurs[i] = type+"##"+valeur;`
199	`break;`	223	`break;`
200	`}`	224	`}`
201	`}`	225	`}`
202	`this.set(champ, UtilArray.implode(valeurs, ";;"));`	226	`this.set(champ, UtilArray.implode(valeurs, ";;"));`
203	`}`	227	`}`
204	`}`	228	`}`
205	`}`	229	`}`
206		230
207	`protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {`	231	`protected String getInfoDenormaliseParPosition(String chaineExistante, int position) {`
208	`String sortie = "";`	232	`String sortie = "";`
209	`if (!chaineExistante.equals("")) {`	233	`if (!chaineExistante.equals("")) {`
210	`String[] valeurs = chaineExistante.split(";;");`	234	`String[] valeurs = chaineExistante.split(";;");`
211	`if (valeurs.length >= position) {`	235	`if (valeurs.length >= position) {`
212	`for (int i = 0; i < valeurs.length; i++) {`	236	`for (int i = 0; i < valeurs.length; i++) {`
213	`if (i == (position - 1)) {`	237	`if (i == (position - 1)) {`
214	`if (valeurs[i].contains("##")) {`	238	`if (valeurs[i].contains("##")) {`
215	`sortie = valeurs[i].replaceFirst("^[^#]+##", "");`	239	`sortie = valeurs[i].replaceFirst("^[^#]+##", "");`
216	`} else {`	240	`} else {`
217	`sortie = valeurs[i];`	241	`sortie = valeurs[i];`
218	`}`	242	`}`
219	`break;`	243	`break;`
220	`}`	244	`}`
221	`}`	245	`}`
222	`}`	246	`}`
223	`}`	247	`}`
224	`return sortie;`	248	`return sortie;`
225	`}`	249	`}`
226		250
227	`/**`	251	`/**`
228	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`	252	`* Permet de modifier correctement une chaine dénormalisée (champ de type "truk").`
229	`* Remplace par la valeur l'instance dont la position a été indiquée.`	253	`* Remplace par la valeur l'instance dont la position a été indiquée.`
230	`* Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.`	254	`* Si la chaine dénormalisée est vide, l'élement est ajouté quelque soit la position indiquée.`
231	`* Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.`	255	`* Si la position est supérieure au nombre d'élément de la chaine dénormalisé, rien n'est modifié.`
232	`*`	256	`*`
233	`* @param champ le nom du champ dénormalisé`	257	`* @param champ le nom du champ dénormalisé`
234	`* @param position le type de la valeur à modifier`	258	`* @param position le type de la valeur à modifier`
235	`* @param valeur la valeur à remplacer à la position indiquée`	259	`* @param valeur la valeur à remplacer à la position indiquée`
236	`*/`	260	`*/`
237	`protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {`	261	`protected void modifierChaineDenormaliseParPosition(String champ, int position, Object valeur) {`
238	`if (valeur instanceof String) {`	262	`if (valeur instanceof String) {`
239	`String chaineExistante = renvoyerValeurCorrecte(champ);`	263	`String chaineExistante = renvoyerValeurCorrecte(champ);`
240	`if (!chaineExistante.equals("")) {`	264	`if (!chaineExistante.equals("")) {`
241	`String[] valeurs = chaineExistante.split(";;");`	265	`String[] valeurs = chaineExistante.split(";;");`
242	`if (valeurs.length == 0) {`	266	`if (valeurs.length == 0) {`
243	`this.set(champ, valeur);`	267	`this.set(champ, valeur);`
244	`} else if (valeurs.length >= position) {`	268	`} else if (valeurs.length >= position) {`
245	`for (int i = 0; i < valeurs.length; i++) {`	269	`for (int i = 0; i < valeurs.length; i++) {`
246	`if (i == (position - 1)) {`	270	`if (i == (position - 1)) {`
247	`valeurs[i] = (String) valeur;`	271	`valeurs[i] = (String) valeur;`
248	`break;`	272	`break;`
249	`}`	273	`}`
250	`}`	274	`}`
251	`this.set(champ, UtilArray.implode(valeurs, ";;"));`	275	`this.set(champ, UtilArray.implode(valeurs, ";;"));`
252	`}`	276	`}`
253	`}`	277	`}`
254	`}`	278	`}`
255	`}`	279	`}`
256		280
257	`public String getDateModification() {`	281	`public String getDateModification() {`
258	`return (String) renvoyerValeurCorrecte("cmhl_date_modification");`	282	`return (String) renvoyerValeurCorrecte("cmhl_date_modification");`
259	`}`	283	`}`
260		284
261	`public String getNotes() {`	285	`public String getNotes() {`
262	`return (String) renvoyerValeurCorrecte("cmhl_notes");`	286	`return (String) renvoyerValeurCorrecte("cmhl_notes");`
263	`}`	287	`}`
264		288
265	`public String getIdModifierPar() {`	289	`public String getIdModifierPar() {`
266	`return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");`	290	`return (String) renvoyerValeurCorrecte("cmhl_ce_modifier_par");`
267	`}`	291	`}`
268		292
269	`public String getIdEtat() {`	293	`public String getIdEtat() {`
270	`return (String) renvoyerValeurCorrecte("cmhl_ce_etat");`	294	`return (String) renvoyerValeurCorrecte("cmhl_ce_etat");`
271	`}`	295	`}`
272		296
273	`public String getIp() {`	297	`public String getIp() {`
274	`return (String) renvoyerValeurCorrecte("cmhl_ip");`	298	`return (String) renvoyerValeurCorrecte("cmhl_ip");`
275	`}`	299	`}`
276		300
277	`/** (non-Javadoc)`	301	`/** (non-Javadoc)`
278	`* @see java.lang.Object#toString()`	302	`* @see java.lang.Object#toString()`
279	`*/`	303	`*/`
280	`public String toString() {`	304	`public String toString() {`
281	`String sortie = "";`	305	`String sortie = "";`
282		306
283	`// Champs du BaseModelData`	307	`// Champs du BaseModelData`
284	`Set<String> proprietes = this.getProperties().keySet();`	308	`Set<String> proprietes = this.getProperties().keySet();`
-		309	`TreeSet<String> proprietesTriees = new TreeSet<String>(proprietes);`
285	`for (Iterator<String> it = proprietes.iterator(); it.hasNext();) {`	310	`for (Iterator<String> it = proprietesTriees.iterator(); it.hasNext();) {`
286	`String cle = it.next();`	311	`String cle = it.next();`
287	`if (!this.get(cle).equals("")) {`	312	`if (this.get(cle) != null && !this.get(cle).equals("")) {`
288	`sortie += cle+" : "+this.get(cle)+"\n";`	313	`sortie += cle+" : "+this.get(cle)+"\n";`
289	`}`	314	`}`
290	`}`	315	`}`
291		316
292	`return sortie;`	317	`return sortie;`
293	`}`	318	`}`
-		319
-		320	`public Boolean comparer(BaseModelData objetAComparer) {`
-		321	`Boolean retour = true;`
-		322	`Map<String, Object> a = this.getProperties();`
-		323	`Map<String, Object> b = objetAComparer.getProperties();`
-		324	`if (a.size() != b.size()) {`
-		325	`retour = false;`
-		326	`} else {`
-		327	`Set<String> cles = a.keySet();`
-		328	`Iterator<String> it = cles.iterator();`
-		329	`while (it.hasNext()) {`
-		330	`String cle = it.next();`
-		331	`if (a.get(cle) != null && !a.get(cle).equals(b.get(cle))) {`
-		332	`retour = false;`
-		333	`break;`
-		334	`}`
-		335	`}`
-		336	`}`
-		337
-		338	`return retour;`
-		339	`}`
-		340
-		341	`public Object cloner(BaseModelData nouvelleInstance) {`
-		342	`Map<String, Object> proprietes = this.getProperties();`
-		343	`Set<String> cles = proprietes.keySet();`
-		344	`for (Iterator<String> it = cles.iterator(); it.hasNext();) {`
-		345	`String cle = it.next();`
-		346	`nouvelleInstance.set(cle, this.get(cle));`
-		347	`}`
-		348
-		349	`return nouvelleInstance;`
-		350	`}`
294	`}`	351	`}`

Subversion Repositories eFlore/Applications.coel

(root)/branches/v1.9-nebbiolo/src/org/tela_botanica/client/modeles/aDonnee.java @ 1901 – Rev 255 → 306