a14d8d6f34cfba7529d6ec3cccb8949c11ba7838
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabTList.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 TList 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  * ScilabTList data = new ScilabTList();<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 ScilabTList extends ArrayList<ScilabType> implements ScilabType {
43
44     private static final long serialVersionUID = 8080160982092586620L;
45     private static final ScilabTypeEnum type = ScilabTypeEnum.sci_tlist;
46
47     private static final int VERSION = 0;
48
49     private String varName;
50
51     /**
52      * Construct an empty tlist.
53      *
54      * Note that the first element of this collection is the header used by
55      * Scilab to find each field type.
56      */
57     public ScilabTList() {
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 ScilabTList(String varName) {
68         super();
69         this.varName = varName;
70     }
71
72     /**
73      * Construct a tlist with a specified header.
74      *
75      * @param types
76      *            type names of the fields.
77      */
78     public ScilabTList(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 types
90      *            type names of the fields.
91      * @param c
92      *            the collection whose elements are to be placed into this
93      *            tlist.
94      */
95     public ScilabTList(String[] types, Collection <? extends ScilabType > c) {
96         super(c.size() + 1);
97
98         String[][] typesData = new String[1][types.length];
99         typesData[0] = types;
100         add(new ScilabString(typesData));
101
102         addAll(c);
103     }
104
105     /**
106      * @param varName the variable name
107      * @param size the initial list size
108      */
109     public ScilabTList(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> getTListFields() {
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 getTListType() {
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 the type of Scilab
183      *
184      * @return the type of Scilab
185      * @since 5.4.0
186      */
187     @Override
188     public ScilabTypeEnum getType() {
189         return type;
190     }
191
192     /**
193      * @return 1 when there is data on the list, 0 otherwise.
194      * @see org.scilab.modules.types.ScilabType#getHeight()
195      */
196     @Override
197     public int getHeight() {
198         if (isEmpty()) {
199             return 0;
200         }
201         return 1;
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 ScilabTList 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         StringBuffer result = new StringBuffer();
276         if (isEmpty()) {
277             return "tlist()";
278         }
279
280         result.append("tlist(");
281         for (int i = 0; i < size(); i++) {
282             result.append(get(i));
283             if (i != size() - 1) {
284                 result.append(", ");
285             }
286
287         }
288         result.append(")");
289
290         return result.toString();
291     }
292 }