scilab/modules/types/src/java/org/scilab/modules/types/ScilabString.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.Arrays;
  23
  24 /**
  25  * This class provides a representation on the Scilab String datatype<br>
  26  * <br>
  27  * This class is {@link java.io.Serializable} and any modification could impact
  28  * load and store of data (Xcos files, Javasci saved data, etc...).<br>
  29  * <br>
  30  * Example:<BR>
  31  * <code>
  32  * String [][]a={{"This","is","my","string"},{"and","I want to", "compare"," them"}};<BR>
  33  * ScilabString aMatrix = new ScilabString(a);
  34  * </code>
  35  *
  36  * @see org.scilab.modules.javasci.Scilab
  37  */
  38 public class ScilabString implements ScilabType {
  39
  40     private static final long serialVersionUID = 359802519980180085L;
  41     private static final ScilabTypeEnum type = ScilabTypeEnum.sci_strings;
  42
  43     private static final int VERSION = 0;
  44
  45     private String[][] data;
  46     private String varName;
  47     private boolean swaped;
  48
  49     /**
  50      * Default constructor
  51      */
  52     public ScilabString() {
  53         data = null;
  54     }
  55
  56     /**
  57      * Constructor with data.
  58      *
  59      * @param data
  60      *            the associated data.
  61      */
  62     public ScilabString(String[][] data) {
  63         this.data = data;
  64     }
  65
  66     /**
  67      * Constructor with data.
  68      *
  69      * @param data
  70      *            the associated data.
  71      */
  72     public ScilabString(String varName, String[][] data, boolean swaped) {
  73         this.varName = varName;
  74         this.data = data;
  75         this.swaped = swaped;
  76     }
  77
  78     /**
  79      * Constructor with vector data.
  80      *
  81      * @param data
  82      *            the column vector data
  83      */
  84     public ScilabString(String[] data) {
  85         if (data == null || data.length == 0) {
  86             this.data = new String[1][1];
  87             this.data[0][0] = "";
  88         } else {
  89             this.data = new String[1][data.length];
  90             for (int i = 0; i < data.length; i++) {
  91                 this.data[0][i] = data[i];
  92             }
  93         }
  94     }
  95
  96     /**
  97      * Constructor with a unique value
  98      *
  99      * @param string
 100      *            the value
 101      */
 102     public ScilabString(String string) {
 103         if (string == null) {
 104             throw new IllegalArgumentException("string == null");
 105         }
 106         this.data = new String[1][1];
 107         this.data[0][0] = string;
 108     }
 109
 110     /**
 111      * Set the values.
 112      *
 113      * @param data
 114      *            the values
 115      */
 116     public void setData(String[][] data) {
 117         this.data = data;
 118     }
 119
 120     /**
 121      * Return the type of Scilab
 122      *
 123      * @return the type of Scilab
 124      * @since 5.4.0
 125      */
 126     @Override
 127     public ScilabTypeEnum getType() {
 128         return type;
 129     }
 130
 131     /**
 132      * @return the associated values
 133      */
 134     public String[][] getData() {
 135         return data;
 136     }
 137
 138     /**
 139      * {@inheritDoc}
 140      */
 141     public String getVarName() {
 142         return varName;
 143     }
 144
 145     /**
 146      * {@inheritDoc}
 147      */
 148     public boolean isSwaped() {
 149         return swaped;
 150     }
 151
 152     /**
 153      * {@inheritDoc}
 154      */
 155     public boolean isReference() {
 156         return false;
 157     }
 158
 159     /**
 160      * @return the height of the data matrix
 161      * @see org.scilab.modules.types.ScilabType#getHeight()
 162      */
 163     @Override
 164     public int getHeight() {
 165         if (data == null) {
 166             return 0;
 167         }
 168         return data.length;
 169     }
 170
 171     /**
 172      * @return the width of the data matrix
 173      * @see org.scilab.modules.types.ScilabType#getWidth()
 174      */
 175     @Override
 176     public int getWidth() {
 177         if (data == null) {
 178             return 0;
 179         }
 180         return data[0].length;
 181     }
 182
 183     /**
 184      * Check the emptiness of the associated data.
 185      *
 186      * @return true, if the associated data array is empty.
 187      */
 188     @Override
 189     public boolean isEmpty() {
 190         return (data == null);
 191     }
 192
 193     @Override
 194     public int hashCode() {
 195         final int prime = 31;
 196         int result = 1;
 197         result = prime * result + Arrays.deepHashCode(data);
 198         return result;
 199     }
 200
 201     /**
 202      * @see org.scilab.modules.types.ScilabType#equals(Object)
 203      */
 204     @Override
 205     public boolean equals(Object obj) {
 206         if (obj instanceof ScilabString) {
 207             return Arrays.deepEquals(this.getData(), ((ScilabString) obj).getData());
 208         } else {
 209             return false;
 210         }
 211     }
 212
 213     /**
 214      * {@inheritDoc}
 215      */
 216     public Object getSerializedObject() {
 217         return data;
 218     }
 219
 220     @Override
 221     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
 222         int version = in.readInt();
 223         switch (version) {
 224             case 0:
 225                 data = (String[][]) in.readObject();
 226                 varName = (String) in.readObject();
 227                 swaped = in.readBoolean();
 228                 break;
 229             default:
 230                 throw new ClassNotFoundException("A class ScilabString with a version " + version + " does not exists");
 231         }
 232     }
 233
 234     @Override
 235     public void writeExternal(ObjectOutput out) throws IOException {
 236         out.writeInt(VERSION);
 237         out.writeObject(data);
 238         out.writeObject(varName);
 239         out.writeBoolean(swaped);
 240     }
 241
 242     /**
 243      * Display the representation in the Scilab language of the type<BR>
 244      * Note that the representation can be copied/pasted straight into Scilab
 245      *
 246      * @return a Scilab-like String representation of the data.
 247      * @see java.lang.Object#toString()
 248      */
 249     @Override
 250     public String toString() {
 251         StringBuilder result = new StringBuilder();
 252         if (isEmpty()) {
 253             return "[]";
 254         }
 255
 256         result.append("[");
 257         for (int i = 0; i < getHeight(); ++i) {
 258             for (int j = 0; j < getWidth(); ++j) {
 259                 result.append('"');
 260                 result.append(data[i][j].replaceAll("[\"\']", "\"\""));
 261                 result.append('"');
 262
 263                 if (j != getWidth() - 1) {
 264                     result.append(", ");
 265                 }
 266             }
 267             if (i != getHeight() - 1) {
 268                 result.append(" ; ");
 269             }
 270         }
 271         result.append("]");
 272         return result.toString();
 273     }
 274 }