3f3881b4c9241495951203c636974e811957721c
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabIntegerReference.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2009-2009 - DIGITEO - Antoine ELIAS
4  *  Copyright (C) 2011 - DIGITEO - Calixte DENIZET
5  *  Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
6  *
7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  */
17
18 package org.scilab.modules.types;
19
20 import java.io.ObjectStreamException;
21 import java.nio.ByteBuffer;
22 import java.nio.IntBuffer;
23 import java.nio.LongBuffer;
24 import java.nio.ShortBuffer;
25
26 /**
27  * This class provides a representation on the Scilab Integer datatype<br>
28  * <br>
29  * This class is {@link java.io.Serializable} and any modification could impact
30  * load and store of data (Xcos files, Javasci saved data, etc...).<br>
31  * <br>
32  * Example:<BR>
33  * <code>
34  * byte [][]a={{32,42,41}, {12,13,32}};<BR>
35  * ScilabInteger aMatrix = new ScilabInteger(a, true); // true = unsigned
36  * </code>
37  *
38  * @see org.scilab.modules.javasci.Scilab
39  */
40 public class ScilabIntegerReference extends ScilabInteger {
41
42     private LongBuffer longBuffer;
43     private IntBuffer intBuffer;
44     private ShortBuffer shortBuffer;
45     private ByteBuffer byteBuffer;
46     private final int nbRows;
47     private final int nbCols;
48
49     /**
50      * Default constructor
51      */
52     public ScilabIntegerReference() {
53         super();
54         nbRows = 0;
55         nbCols = 0;
56     }
57
58     /**
59      * Constructor with values
60      *
61      * @param data
62      *            the values
63      * @param bUnsigned
64      *            true, if the values are unsigned; false if they are signed.
65      */
66     ScilabIntegerReference(String varName, ByteBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
67         this.varName = varName;
68         this.byteBuffer = data;
69         this.nbRows = nbRows;
70         this.nbCols = nbCols;
71         this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint8 : ScilabIntegerTypeEnum.sci_int8;
72         this.byref = true;
73         this.swaped = false;
74     }
75
76     /**
77      * Constructor with values
78      *
79      * @param data
80      *            the values
81      * @param bUnsigned
82      *            true, if the values are unsigned; false if they are signed.
83      */
84     ScilabIntegerReference(String varName, ShortBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
85         this.varName = varName;
86         this.shortBuffer = data;
87         this.nbRows = nbRows;
88         this.nbCols = nbCols;
89         this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint16 : ScilabIntegerTypeEnum.sci_int16;
90         this.byref = true;
91         this.swaped = false;
92     }
93
94     /**
95      * Constructor with values
96      *
97      * @param data
98      *            the values
99      * @param bUnsigned
100      *            true, if the values are unsigned; false if they are signed.
101      */
102     ScilabIntegerReference(String varName, IntBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
103         this.varName = varName;
104         this.intBuffer = data;
105         this.nbRows = nbRows;
106         this.nbCols = nbCols;
107         this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint32 : ScilabIntegerTypeEnum.sci_int32;
108         this.byref = true;
109         this.swaped = false;
110     }
111
112     /**
113      * Constructor with values
114      *
115      * @param data
116      *            the values
117      * @param bUnsigned
118      *            true, if the values are unsigned; false if they are signed.
119      */
120     ScilabIntegerReference(String varName, LongBuffer data, int nbRows, int nbCols, boolean bUnsigned) {
121         this.varName = varName;
122         this.longBuffer = data;
123         this.nbRows = nbRows;
124         this.nbCols = nbCols;
125         this.precision = bUnsigned ? ScilabIntegerTypeEnum.sci_uint64 : ScilabIntegerTypeEnum.sci_int64;
126         this.byref = true;
127         this.swaped = false;
128     }
129
130     /**
131      * {@inheritDoc}
132      */
133     public byte getByteElement(final int i, final int j) {
134         return byteBuffer.get(i + nbRows * j);
135     }
136
137     /**
138      * {@inheritDoc}
139      */
140     public short getShortElement(final int i, final int j) {
141         return shortBuffer.get(i + nbRows * j);
142     }
143
144     /**
145      * {@inheritDoc}
146      */
147     public int getIntElement(final int i, final int j) {
148         return intBuffer.get(i + nbRows * j);
149     }
150
151     /**
152      * {@inheritDoc}
153      */
154     public long getLongElement(final int i, final int j) {
155         return longBuffer.get(i + nbRows * j);
156     }
157
158     /**
159      * {@inheritDoc}
160      */
161     public void setByteElement(final int i, final int j, final byte x) {
162         byteBuffer.put(i + nbRows * j, x);
163     }
164
165     /**
166      * {@inheritDoc}
167      */
168     public void setShortElement(final int i, final int j, final short x) {
169         shortBuffer.put(i + nbRows * j, x);
170     }
171
172     /**
173      * {@inheritDoc}
174      */
175     public void setIntElement(final int i, final int j, final int x) {
176         intBuffer.put(i + nbRows * j, x);
177     }
178
179     /**
180      * {@inheritDoc}
181      */
182     public void setLongElement(final int i, final int j, final long x) {
183         longBuffer.put(i + nbRows * j, x);
184     }
185
186     /**
187      * Set the current values
188      *
189      * @param data
190      *            the values to set
191      * @param bUnsigned
192      *            true, if these values are unsigned; false otherwise.
193      */
194     public void setData(byte[][] data, boolean bUnsigned) {
195         ScilabTypeUtils.setPart(byteBuffer, data);
196         if (bUnsigned) {
197             this.precision = ScilabIntegerTypeEnum.sci_uint8;
198         } else {
199             this.precision = ScilabIntegerTypeEnum.sci_int8;
200         }
201     }
202
203     /**
204      * Set the current values
205      *
206      * @param data
207      *            the values to set
208      * @param bUnsigned
209      *            true, if these values are unsigned; false otherwise.
210      */
211     public void setData(short[][] data, boolean bUnsigned) {
212         ScilabTypeUtils.setPart(shortBuffer, data);
213         if (bUnsigned) {
214             this.precision = ScilabIntegerTypeEnum.sci_uint16;
215         } else {
216             this.precision = ScilabIntegerTypeEnum.sci_int16;
217         }
218     }
219
220     /**
221      * Set the current values
222      *
223      * @param data
224      *            the values to set
225      * @param bUnsigned
226      *            true, if these values are unsigned; false otherwise.
227      */
228     public void setData(int[][] data, boolean bUnsigned) {
229         ScilabTypeUtils.setPart(intBuffer, data);
230         if (bUnsigned) {
231             this.precision = ScilabIntegerTypeEnum.sci_uint32;
232         } else {
233             this.precision = ScilabIntegerTypeEnum.sci_int32;
234         }
235     }
236
237     /**
238      * Set the current values
239      *
240      * @param data
241      *            the values to set
242      * @param bUnsigned
243      *            true, if these values are unsigned; false otherwise.
244      */
245     public void setData(long[][] data, boolean bUnsigned) {
246         ScilabTypeUtils.setPart(longBuffer, data);
247         if (bUnsigned) {
248             this.precision = ScilabIntegerTypeEnum.sci_uint64;
249         } else {
250             this.precision = ScilabIntegerTypeEnum.sci_int64;
251         }
252     }
253
254     /**
255      * Returns the value as the form of short
256      *
257      * @return the values as short
258      */
259     public short[][] getDataAsShort() {
260         short[][] d = new short[nbRows][nbCols];
261         ScilabTypeUtils.setBuffer(d, shortBuffer);
262
263         return d;
264     }
265
266     /**
267      * Returns the value as the form of byte
268      *
269      * @return the values as byte
270      */
271     public byte[][] getDataAsByte() {
272         byte[][] d = new byte[nbRows][nbCols];
273         ScilabTypeUtils.setBuffer(d, byteBuffer);
274
275         return d;
276     }
277
278     /**
279      * Returns the value as the form of int
280      *
281      * @return the values as int
282      */
283     public int[][] getDataAsInt() {
284         int[][] d = new int[nbRows][nbCols];
285         ScilabTypeUtils.setBuffer(d, intBuffer);
286
287         return d;
288     }
289
290     /**
291      * Returns the value as the form of long Only for Scilab 6.X
292      *
293      * @return the values as long
294      */
295     public long[][] getDataAsLong() {
296         long[][] d = new long[nbRows][nbCols];
297         ScilabTypeUtils.setBuffer(d, longBuffer);
298
299         return d;
300     }
301
302     /**
303      * @return the height of the value matrix
304      * @see org.scilab.modules.types.ScilabType#getHeight()
305      */
306     @Override
307     public int getHeight() {
308         return nbRows;
309     }
310
311     /**
312      * @return the width of the value matrix
313      * @see org.scilab.modules.types.ScilabType#getWidth()
314      */
315     @Override
316     public int getWidth() {
317         return nbCols;
318     }
319
320     /**
321      * @return true, if there is no values; false otherwise.
322      */
323     @Override
324     public boolean isEmpty() {
325         return nbRows == 0 || nbCols == 0;
326     }
327
328     /**
329      * @see org.scilab.modules.types.ScilabType#equals(Object)
330      */
331     @Override
332     public boolean equals(Object obj) {
333         if (obj instanceof ScilabInteger) {
334             ScilabInteger sciInt = (ScilabInteger) obj;
335             if (isEmpty() && sciInt.isEmpty()) {
336                 return true;
337             }
338
339             if (this.getWidth() != sciInt.getWidth() || this.getHeight() != sciInt.getHeight()) {
340                 return false;
341             }
342
343             return ScilabTypeUtils.equalsInteger(this.getRawData(), this.isSwaped(), sciInt.getRawData(), sciInt.isSwaped());
344         } else {
345             return false;
346         }
347     }
348
349     /**
350      * {@inheritDoc}
351      */
352     public Object getRawData() {
353         switch (this.getPrec()) {
354             case sci_int8:
355             case sci_uint8:
356                 return byteBuffer;
357             case sci_int16:
358             case sci_uint16:
359                 return shortBuffer;
360             case sci_int32:
361             case sci_uint32:
362                 return intBuffer;
363             case sci_int64:
364             case sci_uint64:
365                 return longBuffer;
366         }
367
368         return null;
369     }
370
371     /**
372      * {@inheritDoc}
373      */
374     public Object getCorrectData() {
375         switch (this.getPrec()) {
376             case sci_int8:
377             case sci_uint8:
378                 return getDataAsByte();
379             case sci_int16:
380             case sci_uint16:
381                 return getDataAsShort();
382             case sci_int32:
383             case sci_uint32:
384                 return getDataAsInt();
385             case sci_int64:
386             case sci_uint64:
387                 return getDataAsLong();
388         }
389
390         return null;
391     }
392
393     /**
394      * When this object is deserialized we want a ScilabInteger, not a ScilabIntegerReference.
395      * @return a ScilabInteger
396      */
397     private Object readResolve() throws ObjectStreamException {
398         switch (precision) {
399             case sci_int8:
400                 return new ScilabInteger(varName, byteData, false, swaped);
401             case sci_uint8:
402                 return new ScilabInteger(varName, byteData, true, swaped);
403             case sci_int16:
404                 return new ScilabInteger(varName, shortData, false, swaped);
405             case sci_uint16:
406                 return new ScilabInteger(varName, shortData, true, swaped);
407             case sci_int32:
408                 return new ScilabInteger(varName, intData, false, swaped);
409             case sci_uint32:
410                 return new ScilabInteger(varName, intData, true, swaped);
411             case sci_int64:
412                 return new ScilabInteger(varName, longData, false, swaped);
413             case sci_uint64:
414                 return new ScilabInteger(varName, longData, true, swaped);
415         }
416
417         return this;
418     }
419 }