1 package atg.util.service.list;
2
3 import java.util.ArrayList;
4 import java.util.Vector;
5
6 import atg.metier.entite.ATGIEntite;
7 import atg.service.constante.AtgConstantes;
8 import atg.service.log.AtgLogManager;
9
10 /**
11 * <p>
12 * Titre : Classe de liste d'entity
13 * </p>
14 * <p>
15 * Description : Cette classe est une liste d'entity
16 * </p>
17 * <p>
18 * Copyright : FERRARI Olivier
19 * </p>
20 *
21 * @author FERRARI Olivier modifiée par YSMAL Vincent
22 * @version 1.4 correction bug NbPages 1.3 Passage en 1.5. Generic 1.2 Ce logiciel est régi par la licence
23 * CeCILL soumise au droit français et respectant les principes de
24 * diffusion des logiciels libres. Vous pouvez utiliser, modifier et/ou
25 * redistribuer ce programme sous les conditions de la licence CeCILL
26 * telle que diffusée par le CEA, le CNRS et l'INRIA sur le site
27 * http://www.cecill.info.
28 *
29 * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
30 * connaissance de la licence CeCILL, et que vous en avez accepté les termes.
31 */
32
33 public class ATGListEntity<K extends ATGIEntite> extends
34 atg.util.service.ATGBasicClass implements ATGIListEntity<K> {
35
36
37
38
39
40 /**
41 *
42 */
43 private static final long serialVersionUID = 5630972035873956306L;
44
45 /**
46 * Liste de Entity
47 */
48 private ArrayList<K> listeElement;
49
50 /**
51 * Page en cours
52 */
53 private int pageEnCours = 0;
54
55 /**
56 * Index en cours pour le parcours
57 */
58 private int indexEnCours = 0;
59
60 /**
61 * Nombre de Entity renvoyés par page ou lot
62 */
63 private int nombreEnregistrementARetourner = 10;
64
65 /**
66 * Index minimum de la liste renvoyée
67 */
68 private int indexMini = 0;
69
70 /**
71 * Index maximum de la liste renvoyée
72 */
73 private int indexMaxi = 0;
74
75 /**
76 * Total d'enregistrement de la liste
77 */
78 private int totalEnregistrement = 0;
79
80 /**
81 * Référence du log
82 */
83 protected static java.util.logging.Logger logger_ = null;
84
85
86
87
88
89 /**
90 * Initialisation de la liste à parcourrir
91 *
92 * @param listeElement
93 * Liste d'élément de type Entity
94 * @throws ATGListException
95 */
96 public void setListeElement(Vector<K> listeElement) throws ATGListException {
97
98 if (listeElement == null) {
99 this.listeElement = null;
100 throw new ATGListException("Liste Vide");
101 }
102 this.listeElement = new ArrayList<K>(listeElement);
103
104 try {
105
106
107 nombreEnregistrementARetourner = Integer
108 .parseInt(atg.service.constante.AtgConstantesWF
109 .getValue("NBRE_ELEMENT_PAR_PAGE"));
110 } catch (Exception ex) {
111 logSevere("Constante NBRE_ELEMENT_PAR_PAGE non présente dans le fichier Constante");
112 throw new ATGListException("Problème sur le paramètre NBRE_ELEMENT_PAR_PAGE dans le fichier de constantes");
113 }
114 totalEnregistrement = listeElement.size();
115 }
116
117 /**
118 * Positionnement de l'index en cours
119 *
120 * @param index
121 * Index de parcour de liste
122 */
123 public void setIndexEnCours(int index) {
124 this.indexEnCours = index - 1;
125 indexEnCours = indexEnCours - indexEnCours
126 % nombreEnregistrementARetourner;
127 pageEnCours = (indexEnCours + 1) / nombreEnregistrementARetourner;
128 }
129
130 /**
131 * Retourne la liste complète de Entity
132 *
133 * @return Liste de Entitys
134 * @throws ATGListException
135 */
136 public Vector<K> getListeAll() throws ATGListException {
137 if (listeElement == null) {
138 logSevere("Liste element est null");
139 throw new ATGListException("Liste Vide");
140 }
141
142
143 this.indexMini = 0;
144 this.indexMaxi = listeElement.size() - 1;
145 return this.genereListeAenvoyer(indexMini, indexMaxi);
146 }
147
148 /**
149 * Retourne le nombre de pages de NombreParPage éléments
150 *
151 * @return le nombre de pages de NombreParPage éléments
152 */
153 public int getNbPages() throws ATGListException {
154 if (listeElement == null)
155 throw new ATGListException("Liste Vide");
156 if ((listeElement.size() % nombreEnregistrementARetourner) == 0) {
157 return (listeElement.size() / nombreEnregistrementARetourner);
158 } else {
159 return (listeElement.size() / nombreEnregistrementARetourner) + 1;
160 }
161 }
162
163 /**
164 * Retourne une liste de NombreParPage elements correspondante à la page en
165 * paramètre
166 *
167 * @param page
168 * Numéro de la page de 1 à N (si <=0 : 1 par défaut. si > nb
169 * page : nb page par défaut)
170 * @return Liste de Entitys
171 * @throws ATGListException
172 */
173 public Vector<K> getListePage(int page) throws ATGListException {
174 if (listeElement == null)
175 throw new ATGListException("Liste Vide");
176 page = (page < 1) ? 1 : page;
177 page = (page > getNbPages()) ? getNbPages() : page;
178 pageEnCours = page;
179 indexMini = (page - 1) * nombreEnregistrementARetourner;
180 indexMaxi = indexMini + nombreEnregistrementARetourner - 1;
181 if (indexMaxi >= listeElement.size()) {
182 indexMaxi = listeElement.size() - 1;
183 }
184 return genereListeAenvoyer(indexMini, indexMaxi);
185 }
186
187 /**
188 * Retourne la liste des premiers éléments par lot de NombreParPage
189 *
190 * @return Liste de Entitys
191 * @throws ATGListException
192 */
193 public Vector<K> getListePremier() throws ATGListException {
194 if (listeElement == null)
195 throw new ATGListException("Liste Vide");
196 return getListePage(1);
197 }
198
199 /**
200 * Retourne la dernière liste de Entity
201 *
202 * @return Vector
203 * @throws ATGListException
204 */
205 public Vector<K> getListeDernier() throws ATGListException {
206 if (listeElement == null)
207 throw new ATGListException("Liste Vide");
208 return getListePage(getNbPages());
209 }
210
211 /**
212 * Retourne la liste suivante de Entity par rapport à l'index en cours
213 *
214 * @return Vector
215 * @throws ATGListException
216 */
217 public Vector<K> getListeSuivante() throws ATGListException {
218 if (listeElement == null)
219 throw new ATGListException("Liste Vide");
220 return getListePage(pageEnCours + 1);
221 }
222
223 /**
224 * Retourne la liste précédente de Entity par rapport à l'index en cours
225 *
226 * @return Vector
227 * @throws ATGListException
228 */
229 public Vector<K> getListePrecedente() throws ATGListException {
230 if (listeElement == null)
231 throw new ATGListException("Liste Vide");
232 return getListePage(pageEnCours - 1);
233 }
234
235 /**
236 * Retourne l'index Minimun de la liste renvoyée
237 *
238 * @return int Retourne l'index Minimun de la liste renvoyée
239 * @throws ATGListException
240 */
241 public int getIndexMiniListeRenvoyee() throws ATGListException {
242 if (listeElement == null)
243 throw new ATGListException("Liste Vide");
244 return indexMini + 1;
245 }
246
247 /**
248 * Retourne l'index maximum de la liste renvoyée
249 *
250 * @return int Retourne l'index maximum de la liste renvoyée
251 * @throws ATGListException
252 */
253 public int getIndexMaxiListeRenvoyee() throws ATGListException {
254 if (listeElement == null)
255 throw new ATGListException("Liste Vide");
256 return indexMaxi + 1;
257 }
258
259 /**
260 * Retourne le nombre total de la liste
261 *
262 * @return Vector
263 * @throws ATGListException
264 */
265 public int getTotalEnregistrement() throws ATGListException {
266 if (listeElement == null){
267 logSevere("Liste element est null");
268 throw new ATGListException("Liste Vide");
269 }
270 return totalEnregistrement;
271 }
272
273
274
275
276
277 /**
278 * Construit une liste entre deux index
279 *
280 * @param mini
281 * Index minimum de la liste
282 * @param maxi
283 * Index Maximum de la liste
284 * @return
285 */
286 private Vector<K> genereListeAenvoyer(int mini, int maxi) {
287 Vector<K> listeAEnvoyer = new Vector<K>();
288
289
290 for (int i = mini; i <= maxi; i++)
291 listeAEnvoyer.add(listeElement.get(i));
292 return listeAEnvoyer;
293 }
294
295 /**
296 * Retourne la trace associée
297 *
298 * @return java.util.logging.Logger Trace associée
299 */
300 protected java.util.logging.Logger getLogger() {
301 if (logger_ == null)
302 logger_ = AtgLogManager
303 .getLog(AtgConstantes.ATG_LOG_CATEGORY_SERVICE_VALUEOBJECT);
304
305 return logger_;
306 }
307
308 }