1 package atg.util.service.identifiant;
2
3 import java.io.Serializable;
4
5 import atg.service.constante.AtgConstantes;
6 import atg.service.log.AtgLogManager;
7 import atg.util.service.ATGBasicClass;
8
9 /**
10 * <p>
11 * Titre : Classe représentant un critère de recherche
12 * </p>
13 * <p>
14 * Description : Cette classe représente un critère d'interrogation sous la
15 * forme clé-opératuer-valeur. La clé doit être valorisée dans le fichier de
16 * constante par une valeur qui sera interprétée dans le DAO correspondant
17 * (exemple, la valeur du champs pour Jdbc.
18 * </p>
19 * 22/09/2006 Reizz :<br />
20 * -Mise en place de la gestion de la valeur en objet (en préservant le
21 * fonctionnement actuel avec les string)<br />
22 * -compareTo valable pour le couple key+valeur qqs le type de valeur (s'il
23 * implémente Comparable bien sûr)
24 *
25 * <p>
26 * Copyright : FERRARI Olivier
27 * </p>
28 *
29 * @author FERRARI Olivier, Reizz
30 * @version 1.4 Ce logiciel est régi par la licence CeCILL soumise au droit
31 * français et respectant les principes de diffusion des logiciels
32 * libres. Vous pouvez utiliser, modifier et/ou redistribuer ce
33 * programme sous les conditions de la licence CeCILL telle que
34 * diffusée par le CEA, le CNRS et l'INRIA sur le site
35 * http://www.cecill.info.
36 *
37 * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
38 * connaissance de la licence CeCILL, et que vous en avez accepté les termes.
39 */
40 public class ATGCritereValue extends ATGBasicClass implements Serializable,
41 Comparable {
42
43
44
45
46
47 /**
48 *
49 */
50 private static final long serialVersionUID = 1L;
51
52 /**
53 * Clé du critère
54 */
55 private String key;
56
57 /**
58 * Opération entre la clé et la valeur, exemple "=", ">"....
59 */
60
61 private String operation;
62
63 /**
64 * Valeur de recherche pour la clé
65 */
66 private Object value;
67
68 /**
69 * Classe sur laquelle on veut faire la recherche
70 */
71 private Class classe;
72
73 /**
74 * Attriubt de la classe sur lequel on veut faire la recherche
75 */
76 private String attribut;
77
78 /**
79 * Opérateur : Egalité
80 */
81 static public String OPERATION_EGAL = " = ";
82
83 /**
84 * Opérateur : Supérieur strict
85 */
86 static public String OPERATION_SUPERIEUR_STRICT = " > ";
87
88 /**
89 * Opérateur : Supérieur ou égal
90 */
91 static public String OPERATION_SUPERIEUR_OU_EGAL = " >= ";
92
93 /**
94 * Opérateur : Inférieur strict
95 */
96 static public String OPERATION_INFERIEUR_STRICT = " < ";
97
98 /**
99 * Opérateur : Inférieur ou égal
100 */
101 static public String OPERATION_INFERIEUR_OU_EGAL = " >= ";
102
103 /**
104 * Opérateur : Supérieur ou égal
105 */
106 static public String OPERATION_COMME = " LIKE ";
107
108 /**
109 * Opérateur : Entre
110 */
111 static public String OPERATION_ENTRE = " BETWEEN ";
112
113
114
115
116 /**
117 * Constructeur
118 *
119 * @param keyParam
120 * @param operationParam
121 * @param valueParam
122 */
123 public ATGCritereValue(String keyParam, String operationParam,
124 String valueParam) {
125 key = keyParam;
126 operation = operationParam;
127 value = valueParam;
128 }
129
130 /**
131 * Constructeur
132 *
133 * @param laClasse
134 * @param attribut
135 * @param operationParam
136 * @param valueParam
137 */
138 public ATGCritereValue(Class laClasse, String attribut,
139 String operationParam, String valueParam) {
140
141 this(laClasse.getName() + '.' + attribut, operationParam, valueParam);
142 this.classe = laClasse;
143 this.attribut = attribut;
144 }
145
146 /**
147 * Constructeur
148 *
149 * @param keyParam
150 * @param operationParam
151 * @param valueParam
152 */
153 public ATGCritereValue(String keyParam, String operationParam,
154 Object valueParam) {
155 key = keyParam;
156 operation = operationParam;
157 value = valueParam;
158 }
159
160 /**
161 * Constructeur
162 *
163 * @param laClasse
164 * @param attribut
165 * @param operationParam
166 * @param valueParam
167 */
168 public ATGCritereValue(Class laClasse, String attribut,
169 String operationParam, Object valueParam) {
170
171 this(laClasse.getName() + '.' + attribut, operationParam, valueParam);
172 this.classe = laClasse;
173 this.attribut = attribut;
174 }
175
176 /**
177 * Getter sur la clé
178 *
179 * @return clé
180 */
181 public String getKey() {
182 return key;
183 }
184
185 /**
186 * Getter sur l'opération
187 *
188 * @return Opération
189 */
190 public String getOperation() {
191 return operation;
192 }
193
194 public Object getValue() {
195 return value;
196 }
197
198 /**
199 * Getter sur la valeur
200 *
201 * @return Valeur
202 */
203 public String getStringValue() {
204 return value.toString();
205 }
206
207 /**
208 * @return Renvoie attribut.
209 */
210 public String getAttribut() {
211 return attribut;
212 }
213
214 /**
215 * @return Renvoie classe.
216 */
217 public Class getClasse() {
218 return classe;
219 }
220
221
222
223
224
225
226 @SuppressWarnings("unchecked")
227 public int compareTo(Object arg0) {
228 if ((arg0 != null) && (arg0 instanceof ATGCritereValue)) {
229 ATGCritereValue to = ((ATGCritereValue) (arg0));
230 if (this.getKey().equals(to.getKey())) {
231 if (this.getValue() instanceof Comparable) {
232 Comparable compare = (Comparable) this.getValue();
233 return compare.compareTo(to.getValue());
234 }
235 } else {
236 return this.getKey().compareTo(to.getKey());
237 }
238 }
239 return -1;
240 }
241
242
243
244
245
246 /**
247 * référence vers le log
248 */
249 protected static java.util.logging.Logger logger_ = null;
250
251 /**
252 * Retourne le log associé
253 *
254 * @return java.util.logging.Logger Trace associée
255 */
256 protected java.util.logging.Logger getLogger() {
257 if (logger_ == null)
258 logger_ = AtgLogManager
259 .getLog(AtgConstantes.ATG_LOG_CATEGORY_UTILITAIRE);
260
261 return logger_;
262 }
263 }