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 }