Typo fixes
[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     private static final ScilabTypeEnum type = ScilabTypeEnum.sci_mlist;
46
47     private static final int VERSION = 0;
48
49     private String varName = "";
50
51     /**
52      * Construct an empty mlist.
53      *
54      * Note that the first element of this collection is the header used by
55      * Scilab to find each field name.
56      */
57     public ScilabMList() {
58         super();
59     }
60
61     /**
62      * Construct an empty mlist.
63      *
64      * Note that the first element of this collection is the header used by
65      * Scilab to find each field 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     public boolean isReference() {
118         return false;
119     }
120
121     /**
122      * {@inheritDoc}
123      */
124     public String getVarName() {
125         return varName;
126     }
127
128     /**
129      * {@inheritDoc}
130      */
131     public boolean isSwaped() {
132         return false;
133     }
134
135     /**
136      * Get a map between the fields name and the associated ScilabType objects
137      *
138      * @return the map
139      */
140     public Map<String, ScilabType> getMListFields() {
141         Map<String, ScilabType> map = new HashMap<String, ScilabType>();
142         if (isEmpty()) {
143             return map;
144         }
145
146         ScilabString mat = (ScilabString) get(0);
147         if (mat.isEmpty()) {
148             return map;
149         }
150
151         String[] fields = mat.getData()[0];
152         for (int i = 1; i < fields.length; i++) {
153             if (i < size()) {
154                 map.put(fields[i], get(i));
155             } else {
156                 map.put(fields[i], null);
157             }
158         }
159
160         return map;
161     }
162
163     /**
164      * Get the mlist type or null if none
165      *
166      * @return the mlist type
167      */
168     public String getMListType() {
169         if (isEmpty()) {
170             return null;
171         }
172
173         ScilabString mat = (ScilabString) get(0);
174         if (mat.isEmpty()) {
175             return null;
176         }
177
178         return mat.getData()[0][0];
179     }
180
181     /**
182      * @return 1 when there is data on the list, 0 otherwise.
183      * @see org.scilab.modules.types.ScilabType#getHeight()
184      */
185     @Override
186     public int getHeight() {
187         if (isEmpty()) {
188             return 0;
189         }
190         return 1;
191     }
192
193     /**
194      * Return the type of Scilab
195      *
196      * @return the type of Scilab
197      * @since 5.4.0
198      */
199     @Override
200     public ScilabTypeEnum getType() {
201         return type;
202     }
203
204     /**
205      * @return 1 when there is data on the list, 0 otherwise.
206      * @see org.scilab.modules.types.ScilabType#getWidth()
207      */
208     @Override
209     public int getWidth() {
210         if (isEmpty()) {
211             return 0;
212         }
213         return size();
214     }
215
216     /**
217      * Get a serialized list; The format is the following: i) returned[0] is an
218      * array of integers containing the Scilab type (ScilabTypeEunm) of the
219      * different elements of the list. ii) returned[i] for i&gt;=1 contains the
220      * serialized form of each items.
221      *
222      * @return a serialized ScilabList/
223      */
224     public Object[] getSerializedObject() {
225         int[] types = new int[size()];
226         Object[] items = new Object[types.length + 1];
227
228         for (int i = 0; i < types.length; i++) {
229             ScilabType var = get(i);
230             types[i] = var.getType().swigValue();
231             items[i + 1] = var.getSerializedObject();
232         }
233         items[0] = types;
234
235         return items;
236     }
237
238     @Override
239     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
240         int version = in.readInt();
241         switch (version) {
242             case 0:
243                 int size = in.readInt();
244                 ensureCapacity(size + 1);
245                 ArrayList list = (ArrayList) this;
246                 for (int i = 0; i < size; i++) {
247                     list.add(in.readObject());
248                 }
249                 varName = (String) in.readObject();
250                 break;
251             default:
252                 throw new ClassNotFoundException("A class ScilabMList with a version " + version + " does not exists");
253         }
254     }
255
256     @Override
257     public void writeExternal(ObjectOutput out) throws IOException {
258         out.writeInt(VERSION);
259         out.writeInt(size());
260         for (Object var : (ArrayList) this) {
261             out.writeObject(var);
262         }
263         out.writeObject(varName);
264     }
265
266     /**
267      * Display the representation in the Scilab language of the type<BR>
268      * Note that the representation can be copied/pasted straight into Scilab
269      *
270      * @return the pretty-printed data
271      * @see java.util.AbstractCollection#toString()
272      */
273     @Override
274     public String toString() {
275
276         StringBuffer result = new StringBuffer();
277         if (isEmpty()) {
278             return "mlist()";
279         }
280
281         result.append("mlist(");
282         for (int i = 0; i < size(); i++) {
283             result.append(get(i));
284             if (i != size() - 1) {
285                 result.append(", ");
286             }
287
288         }
289         result.append(")");
290
291         return result.toString();
292     }
293 }