Javasci: fix java build, javadoc warnings
[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     @Override
134     public byte getByteElement(final int i, final int j) {
135         return byteBuffer.get(i + nbRows * j);
136     }
137
138     /**
139      * {@inheritDoc}
140      */
141     @Override
142     public short getShortElement(final int i, final int j) {
143         return shortBuffer.get(i + nbRows * j);
144     }
145
146     /**
147      * {@inheritDoc}
148      */
149     @Override
150     public int getIntElement(final int i, final int j) {
151         return intBuffer.get(i + nbRows * j);
152     }
153
154     /**
155      * {@inheritDoc}
156      */
157     @Override
158     public long getLongElement(final int i, final int j) {
159         return longBuffer.get(i + nbRows * j);
160     }
161
162     /**
163      * {@inheritDoc}
164      */
165     @Override
166     public void setByteElement(final int i, final int j, final byte x) {
167         byteBuffer.put(i + nbRows * j, x);
168     }
169
170     /**
171      * {@inheritDoc}
172      */
173     @Override
174     public void setShortElement(final int i, final int j, final short x) {
175         shortBuffer.put(i + nbRows * j, x);
176     }
177
178     /**
179      * {@inheritDoc}
180      */
181     @Override
182     public void setIntElement(final int i, final int j, final int x) {
183         intBuffer.put(i + nbRows * j, x);
184     }
185
186     /**
187      * {@inheritDoc}
188      */
189     @Override
190     public void setLongElement(final int i, final int j, final long x) {
191         longBuffer.put(i + nbRows * j, x);
192     }
193
194     /**
195      * Set the current values
196      *
197      * @param data
198      *            the values to set
199      * @param bUnsigned
200      *            true, if these values are unsigned; false otherwise.
201      */
202     @Override
203     public void setData(byte[][] data, boolean bUnsigned) {
204         ScilabTypeUtils.setPart(byteBuffer, data);
205         if (bUnsigned) {
206             this.precision = ScilabIntegerTypeEnum.sci_uint8;
207         } else {
208             this.precision = ScilabIntegerTypeEnum.sci_int8;
209         }
210     }
211
212     /**
213      * Set the current values
214      *
215      * @param data
216      *            the values to set
217      * @param bUnsigned
218      *            true, if these values are unsigned; false otherwise.
219      */
220     @Override
221     public void setData(short[][] data, boolean bUnsigned) {
222         ScilabTypeUtils.setPart(shortBuffer, data);
223         if (bUnsigned) {
224             this.precision = ScilabIntegerTypeEnum.sci_uint16;
225         } else {
226             this.precision = ScilabIntegerTypeEnum.sci_int16;
227         }
228     }
229
230     /**
231      * Set the current values
232      *
233      * @param data
234      *            the values to set
235      * @param bUnsigned
236      *            true, if these values are unsigned; false otherwise.
237      */
238     @Override
239     public void setData(int[][] data, boolean bUnsigned) {
240         ScilabTypeUtils.setPart(intBuffer, data);
241         if (bUnsigned) {
242             this.precision = ScilabIntegerTypeEnum.sci_uint32;
243         } else {
244             this.precision = ScilabIntegerTypeEnum.sci_int32;
245         }
246     }
247
248     /**
249      * Set the current values
250      *
251      * @param data
252      *            the values to set
253      * @param bUnsigned
254      *            true, if these values are unsigned; false otherwise.
255      */
256     @Override
257     public void setData(long[][] data, boolean bUnsigned) {
258         ScilabTypeUtils.setPart(longBuffer, data);
259         if (bUnsigned) {
260             this.precision = ScilabIntegerTypeEnum.sci_uint64;
261         } else {
262             this.precision = ScilabIntegerTypeEnum.sci_int64;
263         }
264     }
265
266     /**
267      * Returns the value as the form of short
268      *
269      * @return the values as short
270      */
271     @Override
272     public short[][] getDataAsShort() {
273         short[][] d = new short[nbRows][nbCols];
274         ScilabTypeUtils.setBuffer(d, shortBuffer);
275
276         return d;
277     }
278
279     /**
280      * Returns the value as the form of byte
281      *
282      * @return the values as byte
283      */
284     @Override
285     public byte[][] getDataAsByte() {
286         byte[][] d = new byte[nbRows][nbCols];
287         ScilabTypeUtils.setBuffer(d, byteBuffer);
288
289         return d;
290     }
291
292     /**
293      * Returns the value as the form of int
294      *
295      * @return the values as int
296      */
297     @Override
298     public int[][] getDataAsInt() {
299         int[][] d = new int[nbRows][nbCols];
300         ScilabTypeUtils.setBuffer(d, intBuffer);
301
302         return d;
303     }
304
305     /**
306      * Returns the value as the form of long Only for Scilab 6.X
307      *
308      * @return the values as long
309      */
310     @Override
311     public long[][] getDataAsLong() {
312         long[][] d = new long[nbRows][nbCols];
313         ScilabTypeUtils.setBuffer(d, longBuffer);
314
315         return d;
316     }
317
318     /**
319      * @return the height of the value matrix
320      * @see org.scilab.modules.types.ScilabType#getHeight()
321      */
322     @Override
323     public int getHeight() {
324         return nbRows;
325     }
326
327     /**
328      * @return the width of the value matrix
329      * @see org.scilab.modules.types.ScilabType#getWidth()
330      */
331     @Override
332     public int getWidth() {
333         return nbCols;
334     }
335
336     /**
337      * @return true, if there is no values; false otherwise.
338      */
339     @Override
340     public boolean isEmpty() {
341         return nbRows == 0 || nbCols == 0;
342     }
343
344     /**
345      * @see org.scilab.modules.types.ScilabType#equals(Object)
346      */
347     @Override
348     public boolean equals(Object obj) {
349         if (obj instanceof ScilabInteger) {
350             ScilabInteger sciInt = (ScilabInteger) obj;
351             if (isEmpty() && sciInt.isEmpty()) {
352                 return true;
353             }
354
355             if (this.getWidth() != sciInt.getWidth() || this.getHeight() != sciInt.getHeight()) {
356                 return false;
357             }
358
359             return ScilabTypeUtils.equalsInteger(this.getRawData(), this.isSwaped(), sciInt.getRawData(), sciInt.isSwaped());
360         } else {
361             return false;
362         }
363     }
364
365     /**
366      * {@inheritDoc}
367      */
368     @Override
369     public Object getRawData() {
370         switch (this.getPrec()) {
371             case sci_int8:
372             case sci_uint8:
373                 return byteBuffer;
374             case sci_int16:
375             case sci_uint16:
376                 return shortBuffer;
377             case sci_int32:
378             case sci_uint32:
379                 return intBuffer;
380             case sci_int64:
381             case sci_uint64:
382                 return longBuffer;
383         }
384
385         return null;
386     }
387
388     /**
389      * {@inheritDoc}
390      */
391     @Override
392     public Object getCorrectData() {
393         switch (this.getPrec()) {
394             case sci_int8:
395             case sci_uint8:
396                 return getDataAsByte();
397             case sci_int16:
398             case sci_uint16:
399                 return getDataAsShort();
400             case sci_int32:
401             case sci_uint32:
402                 return getDataAsInt();
403             case sci_int64:
404             case sci_uint64:
405                 return getDataAsLong();
406         }
407
408         return null;
409     }
410
411     /**
412      * When this object is deserialized we want a ScilabInteger, not a ScilabIntegerReference.
413      * @return a ScilabInteger
414      */
415     private Object readResolve() throws ObjectStreamException {
416         switch (precision) {
417             case sci_int8:
418                 return new ScilabInteger(varName, byteData, false, swaped);
419             case sci_uint8:
420                 return new ScilabInteger(varName, byteData, true, swaped);
421             case sci_int16:
422                 return new ScilabInteger(varName, shortData, false, swaped);
423             case sci_uint16:
424                 return new ScilabInteger(varName, shortData, true, swaped);
425             case sci_int32:
426                 return new ScilabInteger(varName, intData, false, swaped);
427             case sci_uint32:
428                 return new ScilabInteger(varName, intData, true, swaped);
429             case sci_int64:
430                 return new ScilabInteger(varName, longData, false, swaped);
431             case sci_uint64:
432                 return new ScilabInteger(varName, longData, true, swaped);
433         }
434
435         return this;
436     }
437 }