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 }