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