Source code: org/fudaa/dodico/collection/DTableau.java
1 /*
2 * @file DTableau.java
3 * @creation 1998-12-18
4 * @modification $Date: 2001/09/11 14:29:51 $
5 * @license GNU General Public License 2
6 * @copyright (c)1998-2001 CETMEF 2 bd Gambetta F-60231 Compiegne
7 * @mail devel@fudaa.org
8 */
9
10 package org.fudaa.dodico.collection;
11
12 import org.fudaa.dodico.corba.collection.ITableau;
13 import org.fudaa.dodico.corba.collection.ITableauOperations;
14 import org.fudaa.dodico.corba.objet.IObjetHelper;
15 import org.fudaa.dodico.corba.objet.IObjet;
16
17 import org.fudaa.dodico.objet.DObjet;
18
19 import java.util.Vector;
20 import java.util.Enumeration;
21
22 /**
23 * Cette classe implante un tableau d'objet dynamique (cf
24 * <code>java.util.Vector</code>) : un tableau dont la taille est geree
25 * automatiquement et dont les elements sont accessibles par l'intermediaire
26 * d'un index numerique. Les elements de ce tableau peuvent etre manipules tres
27 * facilement :suppression, ajout, remplacement...<br>
28 * En interne, toutes les operations sont deleguees a un attribut prive du type
29 * <code>java.lang.Vector</code>.
30 *
31 * @version $Revision: 1.4 $ $Date: 2001/09/11 14:29:51 $ by $Author: deniger $
32 * @author Guillaume Desnoix
33 */
34 public class DTableau
35 extends DObjet implements ITableauOperations
36 {
37 /**
38 * Le vecteur utilise pour stocké les donnees.
39 */
40 private Vector v_;
41
42 /**
43 * Initialise le vecteur (<code>java.lang.Vector</code>) interne utilise pour
44 * stocker les IObjets.
45 */
46 public DTableau()
47 {
48 v_ = new Vector();
49 }
50
51 /**
52 * Convertit l'objet corba en un objet java (<code>java.lang.Vector</code>).
53 * Le Vector retourne est en fait un clone.
54 *
55 * @return clone du vector utilise en interne.
56 */
57 public Vector toVector()
58 {
59 return (Vector)(v_.clone());
60 }
61
62 /**
63 * Attention: les methodes <code>clone()</code> ne sont pas implementees
64 * correctement.
65 *
66 * @return tableau avec les memes elements.
67 */
68 public Object clone()
69 {
70 DTableau r = new DTableau();
71 r.elements(elements());
72 return r;
73 }
74
75
76 /**
77 * Renvoie une chaine decrivant l'objet.
78 *
79 * @return "DTableau(" + v_.size() + " elements)"
80 */
81 public String toString()
82 {
83 return "DTableau(" + v_.size() + " elements)";
84 }
85
86
87 /**
88 * Initialise cet objet avec <code>_o</code>, si <code>_o</code> est une
89 * instance de <code>ITableau</code>.
90 * Les elements seront les memes que ceux de <code>_o</code>.
91 *
92 * @param _o l'objet servant de reference pour l'initialisation.
93 */
94 public void initialise(IObjet _o)
95 {
96 if(_o instanceof ITableau)
97 {
98 ITableau q = (ITableau)_o;
99 elements(q.elements());
100 }
101 }
102
103 /**
104 * Ajoute l'objet <code>_o</code> au ITableau.
105 *
106 * @param _o objet a ajouter.
107 */
108 public void ajoute(IObjet _o)
109 {
110 v_.addElement(_o);
111 }
112
113
114 /**
115 * Supprime tous les elements du tableau.
116 */
117 public void vide()
118 {
119 v_.removeAllElements();
120 }
121
122
123 /**
124 * Teste si l'IObjet <code>_o</code> appartient a ce tableau.
125 *
126 * @param _o
127 * @return <code>true</code> si <code>_o</code> est present.
128 */
129 public boolean contient(IObjet _o)
130 {
131 return v_.contains(_o);
132 }
133
134
135 /**
136 * Teste si le tableau est vide.
137 *
138 * @return <code>true</code> si le tableau est vide
139 */
140 public boolean estVide()
141 {
142 return v_.isEmpty();
143 }
144
145
146 /**
147 * Enleve l'IObjet <code>_o</code> du tableau.
148 *
149 * @param _o objet a enlever
150 */
151 public void enleve(IObjet _o)
152 {
153 v_.removeElement(_o);
154 }
155
156
157 /**
158 * Renvoie la taille du tableau: le nombre d'IObjets stockés.
159 *
160 * @return taille du tableau.
161 */
162 public int taille()
163 {
164 return v_.size();
165 }
166
167 /**
168 * Renvoie l'IObjet situe a la position <code>_i</code> du tableau.
169 *
170 * @param _i la position de l'objet voulu.
171 * @return null si <code>_i</code> ne correspond pas a un indice valide
172 * ,l'IObjet correspondant sinon.
173 */
174 public IObjet element(int _i)
175 {
176 IObjet r = null;
177 if((_i >= 0) && (_i < v_.size()))
178 {
179 r = IObjetHelper.narrow((org.omg.CORBA.Object)(v_.elementAt(_i)));
180 }
181 return r;
182 }
183
184 /**
185 * Si <code>_i</code> est un indice valide, remplace l'objet correspondant par
186 * <code>_o</code>.
187 *
188 * @param _i l'indice de l'objet a remplacer.
189 * @param _o la nouvelle valeur pour l'objet situe a l'indice
190 <code>_i</code>
191 */
192 public void remplace(int _i, IObjet _o)
193 {
194 if((_i >= 0) && (_i < v_.size()))
195 {
196 v_.setElementAt(_o, _i);
197 }
198 }
199
200 /**
201 * Renvoie le tableau sous forme d'un tableau d'IObjets.
202 *
203 * @return tous les elements du tableau.
204 */
205 public IObjet[] elements()
206 {
207 // JDK120: return (IObjet[])(v.toArray());
208 /*
209 * Enumeration e;
210 * Object[] o = new Object[v_.size()];
211 * for( i = 0, e = v_.elements(); e.hasMoreElements(); i++ )
212 * {
213 * o[i] = e.nextElement();
214 * }
215 */
216 int i;
217 Object[] o = v_.toArray();
218 IObjet[] r = new IObjet[o.length];
219 for(i = 0; i < o.length; i++)
220 {
221 r[i] = IObjetHelper.narrow((org.omg.CORBA.Object)o[i]);
222 }
223 return r;
224 }
225
226
227 /**
228 * Vide le tableau et ajoute tous les objets du tableau <code>_o</code>.
229 *
230 * @param _o les nouveaux elements du tableau.
231 */
232 public void elements(IObjet[] _o)
233 {
234 vide();
235 for(int i = 0; i < _o.length; i++)
236 {
237 ajoute(_o[i]);
238 }
239 }
240
241 /*
242 * public void ajouteTous( ICollection c )
243 * {
244 * }
245 */
246
247 /*
248 * public void contientTous( ICollection c )
249 * {
250 * }
251 */
252
253 /*
254 * public void enleveTous( ICollection c )
255 * {
256 * }
257 */
258
259 // Vector
260
261 /*
262 * JDK120:
263 * public void ajoute(IObjet _o) { v_.add(_o); }
264 * public void vide() { v_.clear(); }
265 * public boolean contient(IObjet _o) { return v_.contains(_o); }
266 * public boolean estVide() { return v_.isEmpty(); }
267 * public void enleve(IObjet _o) { v_.remove(_o); }
268 * public int taille() { return v_.size(); }
269 * public IObjet element(int _i) { return (IObjet)v_.get(_i); }
270 * public void remplace(int _i, IObjet _o) { v_.set(_i,_o); }
271 */
272
273
274 }
275
276