519fcdd4b794638f0b7fac5456a6518acf28bd53
[scilab.git] / 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 }