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 }