Add comparison options on Java Scilab datatypes (.equals(obj))
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / scilabTypes / ScilabInteger.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2009-2009 - DIGITEO - Antoine ELIAS
4  * 
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  * 
11  */
12
13 package org.scilab.modules.types.scilabTypes;
14
15 import java.util.Arrays;
16
17 /**
18  * This class provides a wrapping on the Scilab Integer datatype
19  */
20 public class ScilabInteger implements ScilabType {
21
22         private Long[][] data;
23         private IntegerType prec;
24         private boolean bUnsigned;
25
26         /**
27          * The different size of the integer type.
28          */
29         public enum IntegerType {
30                 /** Integer of size 8 */
31                 TYPE8,
32                 /** Integer of size 16 */
33                 TYPE16,
34                 /** Integer of size 32 */
35                 TYPE32,
36                 /** Integer of size 64 */
37                 TYPE64
38         }
39         
40         /**
41          * Default constructor
42          */
43         public ScilabInteger() {
44                 data = null;
45         }
46
47         /**
48          * Constructor with values
49          * 
50          * @param data the values
51          * @param bUnsigned true, if the values are unsigned; false if they are signed.
52          */
53         public ScilabInteger(byte[][] data, boolean bUnsigned) {
54                 this.setData(data, bUnsigned);
55         }
56
57         /**
58          * Constructor with values
59          * 
60          * @param data the values
61          * @param bUnsigned true, if the values are unsigned; false if they are signed.
62          */
63         public ScilabInteger(short[][] data, boolean bUnsigned) {
64                 this.setData(data, bUnsigned);
65         }
66
67         /**
68          * Constructor with values
69          * 
70          * @param data the values
71          * @param bUnsigned true, if the values are unsigned; false if they are signed.
72          */
73         public ScilabInteger(int[][] data, boolean bUnsigned) {
74                 this.setData(data, bUnsigned);
75         }
76
77         /**
78          * Constructor with values
79          * 
80          * @param data the values
81          * @param bUnsigned true, if the values are unsigned; false if they are signed.
82          */
83         public ScilabInteger(long[][] data, boolean bUnsigned) {
84                 this.setData(data, bUnsigned);
85         }
86
87         /**
88          * Constructor with single signed value
89          * 
90          * @param value the unique value
91          */
92         public ScilabInteger(byte value) {
93                 this.data = new Long[1][1];
94                 this.data[0][0] = Long.valueOf(value);
95         }
96
97         /**
98          * Constructor with single signed value
99          * 
100          * @param value the unique value
101          */
102         public ScilabInteger(short value) {
103                 this.data = new Long[1][1];
104                 this.data[0][0] = Long.valueOf(value);
105         }
106
107         /**
108          * Constructor with single signed value
109          * 
110          * @param value the unique value
111          */
112         public ScilabInteger(int value) {
113                 this.data = new Long[1][1];
114                 this.data[0][0] = Long.valueOf(value);
115         }
116
117         /**
118          * Constructor with single signed value
119          * 
120          * @param value the unique value
121          */
122         public ScilabInteger(long value) {
123                 this.data = new Long[1][1];
124                 this.data[0][0] = Long.valueOf(value);
125         }
126
127         /**
128          * Set the current values 
129          * 
130          * @param data the values to set
131          * @param bUnsigned true, if these values are unsigned; false otherwise.
132          */
133         public void setData(byte[][] data, boolean bUnsigned) {
134                 this.data = new Long[data.length][data[0].length];
135                 prec = IntegerType.TYPE8;
136                 this.bUnsigned = bUnsigned; 
137                 for (int i = 0; i < data.length; i++) {
138                         for (int j = 0; j < data[0].length; j++) {
139                                 this.data[i][j] = Long.valueOf(data[i][j]);
140                         }
141                 }
142         }
143
144         /**
145          * Set the current values 
146          * 
147          * @param data the values to set
148          * @param bUnsigned true, if these values are unsigned; false otherwise.
149          */
150         public void setData(short[][] data, boolean bUnsigned) {
151                 this.data = new Long[data.length][data[0].length];
152                 prec = IntegerType.TYPE16;
153                 this.bUnsigned = bUnsigned; 
154                 for (int i = 0; i < data.length; i++) {
155                         for (int j = 0; j < data[0].length; j++) {
156                                 this.data[i][j] = Long.valueOf(data[i][j]);
157                         }
158                 }
159         }
160
161         /**
162          * Set the current values 
163          * 
164          * @param data the values to set
165          * @param bUnsigned true, if these values are unsigned; false otherwise.
166          */
167         public void setData(int[][] data, boolean bUnsigned) {
168                 this.data = new Long[data.length][data[0].length];
169                 prec = IntegerType.TYPE32;
170                 this.bUnsigned = bUnsigned; 
171                 for (int i = 0; i < data.length; i++) {
172                         for (int j = 0; j < data[0].length; j++) {
173                                 this.data[i][j] = Long.valueOf(data[i][j]);
174                         }
175                 }
176         }
177
178         /**
179          * Set the current values 
180          * 
181          * @param data the values to set
182          * @param bUnsigned true, if these values are unsigned; false otherwise.
183          */
184         public void setData(long[][] data, boolean bUnsigned) {
185                 this.data = new Long[data.length][data[0].length];
186                 prec = IntegerType.TYPE64;
187                 this.bUnsigned = bUnsigned; 
188                 for (int i = 0; i < data.length; i++) {
189                         for (int j = 0; j < data[0].length; j++) {
190                                 this.data[i][j] = Long.valueOf(data[i][j]);
191                         }
192                 }
193         }
194
195         /**
196          * @return the values
197          */
198         public Long[][] getData() {
199                 return data;
200         }
201         
202         /**
203          * @return the precision of the values
204          */
205         public IntegerType getPrec() {
206                 return prec;
207         }
208
209         /**
210          * @return true, if the values are signed, false otherwise.
211          */
212         public boolean isUnsigned() {
213                 return bUnsigned;
214         }
215
216         /**
217          * @return the height of the value matrix
218          * @see org.scilab.modules.types.scilabTypes.ScilabType#getHeight()
219          */
220         @Override
221         public int getHeight() {
222                 if (data == null) {
223                         return 0;
224                 }
225                 return data.length;
226         }
227
228         /**
229          * @return the width of the value matrix
230          * @see org.scilab.modules.types.scilabTypes.ScilabType#getWidth()
231          */
232         @Override
233         public int getWidth() {
234                 if (data == null) {
235                         return 0;
236                 }
237                 return data[0].length;
238         }
239
240         // int32(X), int8(x) , int16([x,x,x;x,x,x])
241         //       uint32(X), uint8(x) , uint16([x,x,x;x,x,x])
242         
243         /**
244          * @return true, if there is no values; false otherwise.
245          */
246     public boolean isEmpty() {
247         return (data == null);
248     }
249         
250     /**
251          * @see org.scilab.modules.types.scilabTypes.ScilabType#equals(Object)
252      */
253     public boolean equals(Object obj) {
254         if (obj instanceof ScilabInteger) {
255             return Arrays.deepEquals(this.getData(), ((ScilabInteger)obj).getData());
256         } else {
257             return false;
258         }
259     }
260
261     /**
262      * @return the pretty-printed values 
263      * @see java.lang.Object#toString()
264      */
265     @Override
266         public String toString() {
267         StringBuilder result = new StringBuilder();
268                 
269                 
270                 if (isEmpty()) {
271                         result.append("int()");
272                         return result.toString();
273                 }
274                 
275                 if (isUnsigned()) {
276                         result.append("u");
277                 }
278                 result.append("int");
279                 
280                 switch (getPrec()) {
281                 case TYPE8:
282                         result.append("8");
283                         break;
284
285                 case TYPE16:
286                         result.append("16");
287                         break;
288                         
289                 case TYPE32:
290                         result.append("32");
291                         break;
292                         
293                 case TYPE64:
294                         result.append("64");
295                         break;
296                         
297                 default:
298                         break;
299                 }
300
301                 result.append("(");
302                 appendData(result);
303                 result.append(")");
304         
305                 return result.toString();
306         }
307
308         /**
309          * Put each value on the buffer.
310          * 
311          * @param result the current buffer
312          */
313         private void appendData(StringBuilder result) {
314                 for (int i = 0; i < getHeight(); ++i) {
315                         for (int j = 0; j < getWidth(); ++j) {
316
317                                 result.append(getData()[i][j]);
318                                 
319                                 
320                                 if (j != getWidth() - 1) {
321                                         result.append(", ");
322                                 }
323                         }
324                         if (i != getHeight() - 1) {
325                                 result.append(" ; ");
326                         }
327                 }
328         }
329         
330 }