Javasci: fix java build, javadoc warnings
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabMList.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
4  *  Copyright (C) 2011-2011 - DIGITEO - Calixte DENIZET
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 package org.scilab.modules.types;
18
19 import java.io.IOException;
20 import java.io.ObjectInput;
21 import java.io.ObjectOutput;
22 import java.util.ArrayList;
23 import java.util.Collection;
24 import java.util.HashMap;
25 import java.util.Map;
26
27 /**
28  * This class provides a representation on the Scilab MList datatype<br>
29  * <br>
30  * This class is {@link java.io.Serializable} and any modification could impact
31  * load and store of data (Xcos files, Javasci saved data, etc...).<br>
32  * <br>
33  * Example:<BR>
34  * <code>
35  * ScilabMList data = new ScilabMList();<BR>
36  * data.add(new ScilabString("hello"));<BR>
37  * data.add(new ScilabDouble(2));<BR>
38  * </code>
39  *
40  * @see org.scilab.modules.javasci.Scilab
41  */
42 public class ScilabMList extends ArrayList<ScilabType> implements ScilabType {
43
44     private static final long serialVersionUID = 3224510024213901841L;
45
46     private static final int VERSION = 0;
47
48     private String varName = "";
49
50     /**
51      * Construct an empty mlist.
52      *
53      * Note that the first element of this collection is the header used by
54      * Scilab to find each field name.
55      */
56     public ScilabMList() {
57         super();
58     }
59
60     /**
61      * Construct an empty mlist.
62      *
63      * Note that the first element of this collection is the header used by
64      * Scilab to find each field name.
65      * @param varName the variable name
66      */
67     public ScilabMList(String varName) {
68         super();
69         this.varName = varName;
70     }
71
72     /**
73      * Construct an mlist with a specified header.
74      *
75      * @param types
76      *            field names used by the accessors.
77      */
78     public ScilabMList(String[] types) {
79         super();
80         String[][] typesData = new String[1][types.length];
81         typesData[0] = types;
82         add(new ScilabString(typesData));
83     }
84
85     /**
86      * Construct a tlist containing the elements of the specified collection, in
87      * the order that they are returned by the specified collection's iterator.
88      *
89      * @param names
90      *            field names, used by the accessors.
91      * @param c
92      *            the collection whose elements are to be placed into this
93      *            mlist.
94      */
95     public ScilabMList(String[] names, Collection <? extends ScilabType > c) {
96         super(c.size() + 1);
97
98         String[][] namesData = new String[1][names.length];
99         namesData[0] = names;
100         add(new ScilabString(namesData));
101
102         addAll(c);
103     }
104
105     /**
106      * @param varName the variable name
107      * @param size the initial list size
108      */
109     public ScilabMList(String varName, int size) {
110         super(size);
111         this.varName = varName;
112     }
113
114     /**
115      * {@inheritDoc}
116      */
117     @Override
118     public boolean isReference() {
119         return false;
120     }
121
122     /**
123      * {@inheritDoc}
124      */
125     @Override
126     public String getVarName() {
127         return varName;
128     }
129
130     /**
131      * {@inheritDoc}
132      */
133     @Override
134     public boolean isSwaped() {
135         return false;
136     }
137
138     /**
139      * Get a map between the fields name and the associated ScilabType objects
140      *
141      * @return the map
142      */
143     public Map<String, ScilabType> getMListFields() {
144         Map<String, ScilabType> map = new HashMap<String, ScilabType>();
145         if (isEmpty()) {
146             return map;
147         }
148
149         ScilabString mat = (ScilabString) get(0);
150         if (mat.isEmpty()) {
151             return map;
152         }
153
154         String[] fields = mat.getData()[0];
155         for (int i = 1; i < fields.length; i++) {
156             if (i < size()) {
157                 map.put(fields[i], get(i));
158             } else {
159                 map.put(fields[i], null);
160             }
161         }
162
163         return map;
164     }
165
166     /**
167      * Get the mlist type or null if none
168      *
169      * @return the mlist type
170      */
171     public String getMListType() {
172         if (isEmpty()) {
173             return null;
174         }
175
176         ScilabString mat = (ScilabString) get(0);
177         if (mat.isEmpty()) {
178             return null;
179         }
180
181         return mat.getData()[0][0];
182     }
183
184     /**
185      * @return 1 when there is data on the list, 0 otherwise.
186      * @see org.scilab.modules.types.ScilabType#getHeight()
187      */
188     @Override
189     public int getHeight() {
190         if (isEmpty()) {
191             return 0;
192         }
193         return 1;
194     }
195
196     /**
197      * Return the type of Scilab
198      *
199      * @return the type of Scilab
200      * @since 5.4.0
201      */
202     @Override
203     public ScilabTypeEnum getType() {
204         return ScilabTypeEnum.sci_mlist;
205     }
206
207     /**
208      * @return 1 when there is data on the list, 0 otherwise.
209      * @see org.scilab.modules.types.ScilabType#getWidth()
210      */
211     @Override
212     public int getWidth() {
213         if (isEmpty()) {
214             return 0;
215         }
216         return size();
217     }
218
219     /**
220      * Get a serialized list; The format is the following: i) returned[0] is an
221      * array of integers containing the Scilab type (ScilabTypeEunm) of the
222      * different elements of the list. ii) returned[i] for i&gt;=1 contains the
223      * serialized form of each items.
224      *
225      * @return a serialized ScilabList/
226      */
227     @Override
228     public Object[] getSerializedObject() {
229         int[] types = new int[size()];
230         Object[] items = new Object[types.length + 1];
231
232         for (int i = 0; i < types.length; i++) {
233             ScilabType var = get(i);
234             types[i] = var.getType().swigValue();
235             items[i + 1] = var.getSerializedObject();
236         }
237         items[0] = types;
238
239         return items;
240     }
241
242     @Override
243     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
244         int version = in.readInt();
245         switch (version) {
246             case 0:
247                 int size = in.readInt();
248                 ensureCapacity(size + 1);
249                 ArrayList list = (ArrayList) this;
250                 for (int i = 0; i < size; i++) {
251                     list.add(in.readObject());
252                 }
253                 varName = (String) in.readObject();
254                 break;
255             default:
256                 throw new ClassNotFoundException("A class ScilabMList with a version " + version + " does not exists");
257         }
258     }
259
260     @Override
261     public void writeExternal(ObjectOutput out) throws IOException {
262         out.writeInt(VERSION);
263         out.writeInt(size());
264         for (Object var : (ArrayList) this) {
265             out.writeObject(var);
266         }
267         out.writeObject(varName);
268     }
269
270     /**
271      * Display the representation in the Scilab language of the type<BR>
272      * Note that the representation can be copied/pasted straight into Scilab
273      *
274      * @return the pretty-printed data
275      * @see java.util.AbstractCollection#toString()
276      */
277     @Override
278     public String toString() {
279
280         StringBuffer result = new StringBuffer();
281         if (isEmpty()) {
282             return "mlist()";
283         }
284
285         result.append("mlist(");
286         for (int i = 0; i < size(); i++) {
287             result.append(get(i));
288             if (i != size() - 1) {
289                 result.append(", ");
290             }
291
292         }
293         result.append(")");
294
295         return result.toString();
296     }
297 }